diff --git a/.gitignore b/.gitignore index 93ea9b3..37b2ca0 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ __pycache__/ .vscode/ .idea/ -# tr808 calibration notebook work dirs (downloaded reference set + renders) +# tr808 calibration notebook work dirs (downloaded reference set + renders + figures) notebooks/_tr808_ref/ notebooks/_tr808_ours/ +notebooks/_swing_figs/ diff --git a/include/taptools/swing_vca.h b/include/taptools/swing_vca.h index 9be0953..d0a0257 100644 --- a/include/taptools/swing_vca.h +++ b/include/taptools/swing_vca.h @@ -7,9 +7,11 @@ /// /// - `decay_env` — trigger to a level, one-pole rise (fast, configurable), then /// exponential decay with a settable time constant: the RC discharge shape. -/// - `swing_vca` — the envelope applied as a gain. Modeled linear; the hardware -/// VCAs add "many high harmonics" (Service Notes on the RS/CL VCA) — a flagged -/// refinement for the circuit-simulation phase. +/// - `swing_vca` — the envelope applied as a gain. Linear by default (`drive` 0), +/// with an opt-in `drive` that engages the swing VCA's symmetric harmonic +/// saturation — the "many high harmonics" the Service Notes note (RS/CL VCA) — +/// via the shared `vca.h` `swing_shape` (also `tap.vca~`'s `swing` circuit). Off +/// by default so every calibrated voice stays bit-identical until a voice opts in. /// - `white_noise` — the shared white-noise source (the 808 has a single noise /// generator feeding SD snappy, CP, MA, and the tom "reverberation"). Seeded /// xorshift64*: deterministic per seed, so renders and tests reproduce and mc. @@ -25,6 +27,8 @@ #include #include +#include "vca.h" // taptools::vca::swing_shape — the shared swing-type saturator + namespace taptools { namespace tr808 { @@ -107,9 +111,13 @@ namespace taptools { double m_env{0.0}, m_target{0.0}; }; - /// The swing-type VCA: envelope as gain. Linear model (see header note). - inline double swing_vca(double x, double env) { - return x * env; + /// The swing-type VCA: envelope as gain. Linear by default (`drive` 0 → `x * env`, the + /// calibrated model, bit-for-bit); `drive > 0` engages the swing VCA's symmetric harmonic + /// saturation (the "many high harmonics" the Service Notes note) on the enveloped signal, + /// via the shared taptools::vca::swing_shape. The character rides the envelope — quiet tails + /// stay clean, hot transients pick up grit and gentle compression. + inline double swing_vca(double x, double env, double drive = 0.0) { + return vca::swing_shape(x * env, drive); } } // namespace tr808 diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index 5a2d9ac..7ef5f30 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -30,5 +30,6 @@ #include "tr808_rim.h" #include "tr808_snare.h" #include "tr808_tom.h" +#include "vca.h" #include "vco.h" #include "vocoder.h" diff --git a/include/taptools/tb303_voice.h b/include/taptools/tb303_voice.h index 6d2c2ff..0a57ad3 100644 --- a/include/taptools/tb303_voice.h +++ b/include/taptools/tb303_voice.h @@ -111,6 +111,7 @@ #include #include "diode_ladder.h" +#include "vca.h" #include "vco.h" namespace taptools { @@ -178,8 +179,10 @@ namespace taptools { enum vca_mode : int { vca_clean = 0, vca_warm, k_num_vca_modes }; // Phase-2 transistor-VCA saturator (see header): informed constants, probe-calibrated. - constexpr double k_vca_sat_drive = 2.0; - constexpr double k_vca_sat_bias = 0.3; + // The saturator itself lives in the shared vca.h kernel (taptools::vca) so tap.303~ and the + // standalone tap.vca~ run one implementation; these are the values the voice configures it with. + constexpr double k_vca_sat_drive = taptools::vca::k_default_drive; // 2.0 + constexpr double k_vca_sat_bias = taptools::vca::k_default_bias; // 0.3 constexpr int k_factory_presets = 8; // slots 0..7 ship authored; 8..15 are defaults @@ -273,7 +276,10 @@ namespace taptools { m_osc.set_waveform(vco::wave_saw); // always the saw core; the square is shaped from it m_osc.snap(); m_filter.prepare(m_sr); - m_filter.set_smooth_ms(0.0); // the voice owns all smoothing + m_filter.set_smooth_ms(0.0); // the voice owns all smoothing + m_vca_stage.set_drive(k_vca_sat_drive); // stock 303 transistor-stage calibration + m_vca_stage.set_bias(k_vca_sat_bias); + m_vca_stage.set_mode(m_vca_mode); apply_unit_spread(); m_pre_hp.set(k_pre_hpf_hz, m_sr); m_post_hp.set(k_post_hpf_hz, m_sr); @@ -339,8 +345,11 @@ namespace taptools { /// Phase-2 VCA circuit: vca_clean (linear, default — bit-identical to phase 1) or /// vca_warm (the one-transistor stage's biased saturation; see the header). - void set_vca(int mode) { m_vca_mode = std::clamp(mode, 0, k_num_vca_modes - 1); } - int vca() const { return m_vca_mode; } + void set_vca(int mode) { + m_vca_mode = std::clamp(mode, 0, k_num_vca_modes - 1); + m_vca_stage.set_mode(m_vca_mode); + } + int vca() const { return m_vca_mode; } /// Deterministic per-unit component spread: `seed` picks the unit, `tolerance` (0..1) /// scales how far off nominal it is. tolerance 0 = the nominal schematic exactly. @@ -499,7 +508,7 @@ namespace taptools { // hardware order: the transistor stage saturates the enveloped signal, then the // output coupling removes the shaper's signal-dependent DC const double v = filtered * m_vca * accent_boost; - const double s = (std::tanh(k_vca_sat_drive * v + k_vca_sat_bias) - m_vca_sat_off) * m_vca_sat_norm; + const double s = m_vca_stage.shape(v); // shared transistor-stage saturator (vca.h) return m_post_hp.tick(s) * m_out_gain; } const double shaped = m_post_hp.tick(filtered); @@ -615,22 +624,19 @@ namespace taptools { // Recompute the per-unit component offsets and every coefficient built on them. // tolerance 0 leaves the nominal schematic exactly (all factors 1, imperfect 0). void apply_unit_spread() { - m_vca_sat_off = std::tanh(k_vca_sat_bias); - const double sech_sq = 1.0 - m_vca_sat_off * m_vca_sat_off; - m_vca_sat_norm = 1.0 / (k_vca_sat_drive * sech_sq); - const double t = m_tolerance; - m_unit_tune_cents = 8.0 * t * unit_draw(m_seed, 0); // converter trim - m_unit_cutoff_scale = std::exp2(0.12 * t * unit_draw(m_seed, 1)); // VCF tracking - m_unit_env = 1.0 + 0.10 * t * unit_draw(m_seed, 2); // envelope caps - m_unit_vca = 1.0 + 0.10 * t * unit_draw(m_seed, 3); - m_unit_slide = 1.0 + 0.15 * t * unit_draw(m_seed, 4); // slide RC - m_unit_c13 = 1.0 + 0.15 * t * unit_draw(m_seed, 5); // accent-sweep RC - m_unit_attack = 1.0 + 0.20 * t * unit_draw(m_seed, 6); - m_meg_attack = attack_coef(k_meg_attack_ms); - m_vca_decay = decay_coef(k_vca_decay_ms * m_unit_vca); - m_vca_release = decay_coef(k_vca_release_ms); - m_c13_charge = one_pole_coef(k_c13_charge_ms * m_unit_c13); - m_c13_drain = one_pole_coef(k_c13_discharge_ms * m_unit_c13); + const double t = m_tolerance; + m_unit_tune_cents = 8.0 * t * unit_draw(m_seed, 0); // converter trim + m_unit_cutoff_scale = std::exp2(0.12 * t * unit_draw(m_seed, 1)); // VCF tracking + m_unit_env = 1.0 + 0.10 * t * unit_draw(m_seed, 2); // envelope caps + m_unit_vca = 1.0 + 0.10 * t * unit_draw(m_seed, 3); + m_unit_slide = 1.0 + 0.15 * t * unit_draw(m_seed, 4); // slide RC + m_unit_c13 = 1.0 + 0.15 * t * unit_draw(m_seed, 5); // accent-sweep RC + m_unit_attack = 1.0 + 0.20 * t * unit_draw(m_seed, 6); + m_meg_attack = attack_coef(k_meg_attack_ms); + m_vca_decay = decay_coef(k_vca_decay_ms * m_unit_vca); + m_vca_release = decay_coef(k_vca_release_ms); + m_c13_charge = one_pole_coef(k_c13_charge_ms * m_unit_c13); + m_c13_drain = one_pole_coef(k_c13_discharge_ms * m_unit_c13); m_osc.set_seed(m_seed); m_osc.set_imperfect(0.6 * t); // waveform imperfection rides the same tolerance push_filter_params(); @@ -663,10 +669,9 @@ namespace taptools { double m_vca_decay{0.9999}, m_vca_release{0.99}; double m_slide_coef{0.001}; - // phase-2 VCA circuit - int m_vca_mode{vca_clean}; - double m_vca_sat_off{0.291313}; // tanh(bias); recomputed in apply_unit_spread - double m_vca_sat_norm{0.546366}; // 1/(drive*sech^2(bias)) + // phase-2 VCA circuit — the saturator math lives in the shared taptools::vca stage + int m_vca_mode{vca_clean}; + ::taptools::vca m_vca_stage; // shape() only; the voice runs its own coupling + gain // per-unit component spread (seed/tolerance) double m_unit_tune_cents{0.0}; diff --git a/include/taptools/tr808_clap.h b/include/taptools/tr808_clap.h index 561703d..a9da1ea 100644 --- a/include/taptools/tr808_clap.h +++ b/include/taptools/tr808_clap.h @@ -132,6 +132,13 @@ namespace taptools { /// wash, leaving only the three teeth). void set_tail(double amount) { m_tail = std::clamp(amount, 0.0, 2.0); } + /// Swing-VCA drive on the output VCA (0 = the calibrated linear model, bit-identical; + /// > 0 engages the swing VCA's symmetric harmonic saturation — grit and compression + /// that ride the envelope). Applies to both the clap and maracas models. See + /// swing_vca.h / vca.h swing_shape. + void set_drive(double amount) { m_drive = std::max(0.0, amount); } + double drive() const { return m_drive; } + /// Noise-source seed (deterministic; mc. instances decorrelate by seed). void set_seed(uint64_t seed) { m_noise.set_seed(seed); } @@ -155,7 +162,7 @@ namespace taptools { if (m_model == model_maracas) { const double y = - swing_vca(m_ma_lp.process(m_ma_hp2.process(m_ma_hp1.process(n))), m_ma_env.process()); + swing_vca(m_ma_lp.process(m_ma_hp2.process(m_ma_hp1.process(n))), m_ma_env.process(), m_drive); return y * m_level * k_ma_out_scale; } @@ -185,7 +192,7 @@ namespace taptools { m_bp2_z2 = -m_bp_b0 * b1 - m_bp_a2 * bp; const double env = m_tooth_env + k_cp_tail_level * m_tail * m_tail_env; - return swing_vca(bp, env) * m_level * k_cp_out_scale; + return swing_vca(bp, env, m_drive) * m_level * k_cp_out_scale; } private: @@ -207,6 +214,7 @@ namespace taptools { white_noise m_noise; double m_level{1.0}, m_tail{1.0}, m_accent{1.0}; + double m_drive{0.0}; // swing-VCA saturation on the output VCA; 0 = linear (default) }; } // namespace tr808 diff --git a/include/taptools/tr808_cowbell.h b/include/taptools/tr808_cowbell.h index ff47d66..3787c09 100644 --- a/include/taptools/tr808_cowbell.h +++ b/include/taptools/tr808_cowbell.h @@ -80,6 +80,12 @@ namespace taptools { /// Output level, 0..1 (VR5, CB LEVEL). void set_level(double amount) { m_level = std::clamp(amount, 0.0, 1.0); } + /// Swing-VCA drive on the oscillator pair (0 = calibrated linear model, bit-identical; + /// > 0 engages the swing VCA's symmetric harmonic saturation before the bandpass — the + /// experimental fidelity hook for the tonal-voice sweep, plans/tap.808.md). + void set_drive(double amount) { m_drive = std::max(0.0, amount); } + double drive() const { return m_drive; } + void set_tuning(double ratio) { m_bank.set_tuning(ratio); } void set_tolerance(double amount) { m_bank.set_tolerance(amount); } void set_seed(uint64_t seed) { m_bank.set_seed(seed); } @@ -96,7 +102,7 @@ namespace taptools { // The gates pass only the trimpot pair (oscillators #5 and #6: 800 / 540 Hz). const double pair = 0.5 * (m_bank.osc(4) + m_bank.osc(5)); const double env = m_env_fast.process() + m_env_tail.process(); - return m_bp.process(swing_vca(pair, env)) * m_level * k_cb_out_scale; + return m_bp.process(swing_vca(pair, env, m_drive)) * m_level * k_cb_out_scale; } private: @@ -107,6 +113,7 @@ namespace taptools { decay_env m_env_fast, m_env_tail; double m_level{1.0}; + double m_drive{0.0}; // swing-VCA saturation on the osc pair; 0 = linear (default) }; } // namespace tr808 diff --git a/include/taptools/tr808_rim.h b/include/taptools/tr808_rim.h index c030fcf..539d73f 100644 --- a/include/taptools/tr808_rim.h +++ b/include/taptools/tr808_rim.h @@ -103,6 +103,13 @@ namespace taptools { /// Output level, 0..1 (VR16, RS/CL LEVEL). void set_level(double amount) { m_level = std::clamp(amount, 0.0, 1.0); } + /// Swing-VCA drive (the Q62 harmonic VCA). Sentinel < 0 (default) uses each model's + /// calibrated value — rimshot k_rs_drive (2.2, as always shipped), claves linear (0). + /// A value >= 0 overrides both models — the experimental hook for the claves fidelity + /// sweep (plans/tap.808.md; the rimshot already ships saturated). + void set_drive(double amount) { m_drive = std::max(-1.0, amount); } + double drive() const { return m_drive; } + void trigger(double accent = 1.0) { const double a = std::clamp(accent, 0.0, 1.0); m_vtrig = k_rim_vtrig_min + a * (k_rim_vtrig_max - k_rim_vtrig_min); @@ -117,19 +124,23 @@ namespace taptools { --m_pulse_remaining; } - const double drive = v_pulse * 0.02; - double ring = m_hi.process(drive, 0.0, 0.0); + const double exc = v_pulse * 0.02; + double ring = m_hi.process(exc, 0.0, 0.0); if (m_model == model_rimshot) { - ring = ring * k_rs_hi_mix + m_lo.process(drive, 0.0, 0.0); + ring = ring * k_rs_hi_mix + m_lo.process(exc, 0.0, 0.0); } const double env = m_env.process(); if (m_model == model_rimshot) { - // The Q62 swing VCA's harmonic generation: drive the gated sum. - return std::tanh(ring * k_rs_drive * env) / k_rs_drive * m_level * k_rim_out_scale - * k_rim_vtrig_max; + // The Q62 swing VCA's harmonic generation (Service Notes, RS/CL VCA): the shared + // swing_shape (vca.h) IS tanh(d*v)/d, so swing_vca(ring, env, k_rs_drive) is the + // exact tanh(ring*k_rs_drive*env)/k_rs_drive this always shipped — now unified. + const double d = (m_drive < 0.0) ? k_rs_drive : m_drive; + return swing_vca(ring, env, d) * m_level * k_rim_out_scale * k_rim_vtrig_max; } - return swing_vca(ring, env) * k_cl_mix * m_level * k_rim_out_scale; + // Claves: linear by default (m_drive < 0 → 0), with the same opt-in swing saturation. + const double d = (m_drive < 0.0) ? 0.0 : m_drive; + return swing_vca(ring, env, d) * k_cl_mix * m_level * k_rim_out_scale; } private: @@ -168,6 +179,7 @@ namespace taptools { decay_env m_env; double m_level{1.0}; + double m_drive{-1.0}; // swing-VCA drive; <0 = per-model calibrated (RS 2.2 / CL linear) double m_vtrig{0.0}; int m_pulse_remaining{0}; }; diff --git a/include/taptools/tr808_snare.h b/include/taptools/tr808_snare.h index 2acfc92..390d54c 100644 --- a/include/taptools/tr808_snare.h +++ b/include/taptools/tr808_snare.h @@ -29,10 +29,11 @@ /// K. J. Werner's TR-808 SD analysis). STOCK HERE IS THE LATER REVISION; the /// `tuning` bend scales both resonators from there. /// -/// Behavioral simplifications: the hardware VCA's harmonic generation is modeled -/// linear (see swing_vca.h); the slight re-excitation of the resonators by the -/// snappy envelope (the composite-trigger path through Q47) is omitted, as in -/// Werner's model; accent maps to the common trigger bus voltage as in the kick. +/// Behavioral simplifications: the hardware VCA's harmonic generation is linear by +/// default, with an opt-in `drive` for the swing VCA's symmetric saturation (see +/// swing_vca.h); the slight re-excitation of the resonators by the snappy envelope +/// (the composite-trigger path through Q47) is omitted, as in Werner's model; accent +/// maps to the common trigger bus voltage as in the kick. /// /// §7.2 calibration (2026-07-17), vs the Fischer 1994 set (unit 103852): /// fundamentals within 1.2% at every dial position, including the tone-max @@ -177,6 +178,13 @@ namespace taptools { // -- circuit bends (stock hardware at the defaults) ---------------------------- + /// Swing-VCA drive on the snappy noise path (0 = the calibrated linear model, + /// bit-identical; > 0 engages the swing VCA's symmetric harmonic saturation — grit and + /// compression that ride the snappy envelope, hardest on the transient crack). See + /// swing_vca.h / vca.h swing_shape. + void set_drive(double amount) { m_drive = std::max(0.0, amount); } + double drive() const { return m_drive; } + /// Pitch as a ratio of the stock tuning (0.25..4): scales both resonators' arm /// capacitors together. 1.0 = the late-revision schematic (~173/336 Hz). void set_tuning(double ratio) { @@ -211,7 +219,7 @@ namespace taptools { const double snap = swing_vca(m_noise_lp2.process(m_noise_lp.process( m_noise_hp2.process(m_noise_hp1.process(m_noise.process())))), - m_env.process()) + m_env.process(), m_drive) * std::pow(m_snappy, k_sd_snappy_taper) * k_sd_snappy_gain; const double mix = f * (1.0 - m_tone) + h * m_tone + snap; @@ -228,6 +236,7 @@ namespace taptools { double m_tone{0.5}, m_snappy{0.5}, m_level{1.0}; double m_tuning{1.0}; + double m_drive{0.0}; // swing-VCA saturation on the snappy path; 0 = linear (default) double m_vtrig{0.0}; int m_pulse_remaining{0}; }; diff --git a/include/taptools/tr808_tom.h b/include/taptools/tr808_tom.h index 06f9c1b..79f1c32 100644 --- a/include/taptools/tr808_tom.h +++ b/include/taptools/tr808_tom.h @@ -131,6 +131,13 @@ namespace taptools { /// Output level, 0..1. void set_level(double amount) { m_level = std::clamp(amount, 0.0, 1.0); } + /// Swing-VCA drive on the noise "reverberation" path (0 = the calibrated linear model, + /// bit-identical; > 0 engages the swing VCA's symmetric harmonic saturation on the + /// noise layer, riding its envelope). Toms only (congas have no noise layer). See + /// swing_vca.h / vca.h swing_shape. + void set_drive(double amount) { m_drive = std::max(0.0, amount); } + double drive() const { return m_drive; } + /// Noise-layer seed (toms only audible; deterministic). void set_seed(uint64_t seed) { m_noise.set_seed(seed); } @@ -165,8 +172,8 @@ namespace taptools { m_pink2 = 0.96300 * m_pink2 + w * 0.2965164; m_pink3 = 0.57000 * m_pink3 + w * 1.0526913; const double p = m_pink1 + m_pink2 + m_pink3 + w * 0.1848; - noise = - swing_vca(m_noise_lp.process(p), m_noise_env.process()) * k_tom_noise_mix * k_tomc_vtrig_max; + noise = swing_vca(m_noise_lp.process(p), m_noise_env.process(), m_drive) * k_tom_noise_mix + * k_tomc_vtrig_max; } else { m_noise_env.process(); // keep envelope state moving for model switches @@ -218,6 +225,7 @@ namespace taptools { double m_pink1{0.0}, m_pink2{0.0}, m_pink3{0.0}; double m_tuning{0.5}, m_level{1.0}; + double m_drive{0.0}; // swing-VCA saturation on the noise layer; 0 = linear (default) double m_r_leg{4.7e3}, m_base_c{1e-8}; double m_vtrig{0.0}; int m_pulse_remaining{0}; diff --git a/include/taptools/vca.h b/include/taptools/vca.h new file mode 100644 index 0000000..86681bf --- /dev/null +++ b/include/taptools/vca.h @@ -0,0 +1,145 @@ +/// @file +/// @brief Portable voltage-controlled-amplifier kernel for tap.vca~ — no Max/Min dependency. +/// @details A gain stage with a selectable circuit model, following the same two-circuit idiom +/// as svf.h (clean vs. driven). The `warm` circuit is the discrete class-A transistor +/// VCA extracted from the TB-303 voice (tb303_voice.h, phase 2) so there is one +/// implementation shared between `tap.303~` and the standalone object: +/// +/// - `mode_clean` (default) is the pure linear multiply, x * gain — bit-identical to a +/// `*~`. Cheap, transparent, no added harmonics or DC. +/// - `mode_warm` models a one-transistor class-A VCA stage as a slope-normalized biased +/// saturator applied to the ALREADY-GAINED signal: +/// S(v) = (tanh(d*v + b) - tanh(b)) / (d * sech^2(b)), d = drive, b = bias +/// The `- tanh(b)` term removes the operating-point DC and the `1/(d*sech^2(b))` +/// normalization gives unity slope at v = 0, so quiet signals pass essentially clean +/// (a few % harmonic content) while hot signals pick up even harmonics (~11% h2 on a +/// full-scale sine at the stock drive) and audible compression (~-4 dB at full whack). +/// Because the saturator sees the post-gain signal, the warmth TRACKS the control +/// voltage — the discrete-VCA character a linear multiply cannot produce. +/// +/// The asymmetric shaper leaves a signal-dependent DC component on AC material (the +/// mean of tanh over a symmetric swing is not tanh(b)); the discrete hardware sheds it +/// through the stage's output coupling capacitor. The kernel models that with an +/// optional one-pole DC block (leaky-integrator high-pass, sub-audio corner) engaged in +/// `warm` mode — matching the hardware order (saturate, then couple out). `tap.303~` +/// does NOT use this path: it composes `shape()` directly and runs its own Open303 +/// output-coupling high-pass, so its numbers are untouched by this extraction. +/// +/// Defaults (drive 2.0, bias 0.3) are the probe-calibrated 303 constants; both are +/// exposed so the same stage can be driven harder or biased more asymmetrically for +/// non-303 use. Plain C++17, stdlib only, allocation-free, no Max/Min dependency. +/// @author Timothy Place +/// @copyright Copyright 2026 Timothy Place. Distributed under the New BSD License. + +#pragma once + +#include +#include + +namespace taptools { + + /// Selectable-circuit gain stage: linear multiply, or the 303's class-A transistor saturator. + class vca { + public: + enum mode : int { + mode_clean = 0, // pure linear multiply — bit-identical to *~ + mode_warm, // one-transistor class-A stage (biased, slope-normalized tanh) + mode_swing, // TR-808 swing-type VCA: symmetric (odd-harmonic) saturation + k_num_modes + }; + + // Stock 303 transistor-stage constants (tb303_voice.h k_vca_sat_drive / k_vca_sat_bias): + // probe-calibrated for musical THD. Schematic-derived values are an audition-time refinement. + static constexpr double k_default_drive = 2.0; + static constexpr double k_default_bias = 0.3; + static constexpr double k_dc_block_hz = 20.0; // output-coupling corner (warm mode) + + void prepare(double sample_rate) { + m_dc.set(k_dc_block_hz, sample_rate); + update(); + } + + void reset() { m_dc.reset(); } + + // -- circuit / parameters --------------------------------------------------------------- + void set_mode(int m) { m_mode = std::clamp(m, 0, k_num_modes - 1); } + int circuit() const { return m_mode; } + + void set_drive(double d) { + m_drive = std::max(1e-6, d); + update(); + } + double drive() const { return m_drive; } + + void set_bias(double b) { + m_bias = b; + update(); + } + double bias() const { return m_bias; } + + void set_dc_block(bool on) { m_dc_block = on; } + bool dc_block() const { return m_dc_block; } + + /// The TR-808 swing-type VCA's symmetric saturator, applied to an already-gained sample. + /// A differential-pair transconductance cell is an odd function, so it makes the "many high + /// harmonics" the Service Notes note (RS/CL VCA) with no DC — modeled here as unity-slope-at-0 + /// tanh so quiet signals stay clean and hot signals compress (the character rides the + /// envelope). `drive <= 0` is the exact linear passthru, so the 808 noise voices default to + /// their calibrated linear model bit-for-bit. Static + shared: this is the one implementation + /// swing_vca.h (the voices) and mode_swing both route through. + static double swing_shape(double v, double drive) { return drive > 0.0 ? std::tanh(drive * v) / drive : v; } + + // -- processing ------------------------------------------------------------------------- + + /// The circuit's saturator applied to an already-gained sample. `clean` is the identity, so + /// upstream code that multiplies by its own gain gets a bit-identical passthru. This is the + /// shared primitive tb303_voice.h composes (with its own gain and coupling). + double shape(double v) const { + switch (m_mode) { + case mode_warm: + return (std::tanh(m_drive * v + m_bias) - m_off) * m_norm; + case mode_swing: + return swing_shape(v, m_drive); + default: // mode_clean + return v; + } + } + + /// The full standalone path: apply `gain`, run the circuit, and in `warm` mode couple the + /// output through the DC block (unless disabled — `swing` is symmetric and needs none). + /// `gain` is a plain linear multiplier — feed it a control signal, an envelope, or a constant. + double process(double x, double gain) { + const double s = shape(x * gain); + if (m_mode == mode_warm && m_dc_block) + return m_dc.tick(s); + return s; + } + + private: + // One-pole leaky-integrator high-pass: y = x - lp, lp += (x - lp) * a. Denormal-flushed. + struct dc_hp { + double a{0.0}, lp{0.0}; + void set(double hz, double sr) { a = 1.0 - std::exp(-2.0 * 3.14159265358979323846 * hz / sr); } + double tick(double x) { + lp += (x - lp) * a; + lp = (std::abs(lp) < 1e-15) ? 0.0 : lp; + return x - lp; + } + void reset() { lp = 0.0; } + }; + + // Recompute the operating-point offset and the unity-slope normalization from drive/bias. + void update() { + m_off = std::tanh(m_bias); + m_norm = 1.0 / (m_drive * (1.0 - m_off * m_off)); // 1 / (d * sech^2(b)) + } + + int m_mode{mode_clean}; + double m_drive{k_default_drive}; + double m_bias{k_default_bias}; + double m_off{0.0}, m_norm{1.0}; + bool m_dc_block{true}; + dc_hp m_dc; + }; + +} // namespace taptools diff --git a/notebooks/tr808_swing_vca.ipynb b/notebooks/tr808_swing_vca.ipynb new file mode 100644 index 0000000..3bbd508 --- /dev/null +++ b/notebooks/tr808_swing_vca.ipynb @@ -0,0 +1,1182 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b61219c8", + "metadata": {}, + "source": [ + "# tap.808.* — the swing-VCA `drive`: real 808 vs. our linear vs. our swing\n", + "\n", + "The swing-type VCA in the 808 noise voices adds harmonics/compression the Service Notes\n", + "describe (RS/CL VCA, \"many high harmonics\"). Our kernels modeled it **linearly** (`swing_vca()`\n", + "= `x·env`); `vca.h`'s `mode_swing` / `swing_vca(x, env, drive)` now add an opt-in symmetric\n", + "`tanh(d·v)/d` saturator, wired into snare/clap/tom behind a `drive` attribute (**default 0 →\n", + "bit-identical to the linear model**).\n", + "\n", + "**The question this notebook answers.** A real TR-808 already has its swing VCA baked into every\n", + "sample. So the test is *not* \"does drive change our sound\" (it does) — it's **does adding drive move\n", + "our model toward or away from the real hardware?** If the reference shows transient\n", + "compression / spectral tilt our linear model lacks, `drive > 0` should *reduce* the distance to the\n", + "reference. If our linear model already matches, `drive > 0` moves us away and the honest call is to\n", + "leave it at 0.\n", + "\n", + "**Reference:** Michael Fischer's *Technopolis* TR-808 Sample Set (1994, author-distributed free —\n", + "the same set `tr808_calibration.ipynb` uses), 44.1 kHz / 16-bit mono. Cached in `_tr808_ref/`.\n", + "\n", + "**Caveat carried from the A/B renders:** on broadband *noise* a symmetric shaper mostly limits\n", + "peaks (RMS barely moves) — so expect a transient/`crest-factor` story more than a dramatic harmonic\n", + "one. That is itself part of the finding." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5793ae3a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:51.751867Z", + "iopub.status.busy": "2026-07-19T02:05:51.751639Z", + "iopub.status.idle": "2026-07-19T02:05:52.245951Z", + "shell.execute_reply": "2026-07-19T02:05:52.244451Z" + } + }, + "outputs": [], + "source": [ + "import pathlib, subprocess, urllib.request, zipfile, wave, struct\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.25, \"grid.linewidth\": 0.5,\n", + " \"axes.spines.top\": False, \"axes.spines.right\": False,\n", + " \"axes.titlesize\": 10, \"axes.labelsize\": 9,\n", + " \"xtick.labelsize\": 8, \"ytick.labelsize\": 8, \"legend.fontsize\": 8,\n", + "})\n", + "\n", + "KERNEL = pathlib.Path.cwd().resolve().parent\n", + "RENDER = KERNEL / \"build\" / \"tools\" / \"render\" / \"tr808_render\"\n", + "assert RENDER.exists(), f\"render tool not built at {RENDER}; run cmake with -DTAPTOOLS_BUILD_TOOLS=ON\"\n", + "FIGS = pathlib.Path(\"_swing_figs\"); FIGS.mkdir(exist_ok=True)\n", + "ANALYSIS_SR = 44100" + ] + }, + { + "cell_type": "markdown", + "id": "f5279887", + "metadata": {}, + "source": [ + "## 1. Reference set (download + cache)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4878c4f2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:52.249443Z", + "iopub.status.busy": "2026-07-19T02:05:52.248991Z", + "iopub.status.idle": "2026-07-19T02:05:52.258042Z", + "shell.execute_reply": "2026-07-19T02:05:52.256763Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "116 reference samples\n" + ] + } + ], + "source": [ + "REF_URL = \"http://machines.hyperreal.org/manufacturers/Roland/TR-808/samples/TR808all.zip\"\n", + "REF_DIR = pathlib.Path(\"_tr808_ref\")\n", + "if not any(REF_DIR.rglob(\"*.WAV\")) if REF_DIR.exists() else True:\n", + " REF_DIR.mkdir(exist_ok=True)\n", + " zpath = REF_DIR / \"TR808all.zip\"\n", + " if not zpath.exists():\n", + " print(\"downloading\", REF_URL); urllib.request.urlretrieve(REF_URL, zpath)\n", + " with zipfile.ZipFile(zpath) as z: z.extractall(REF_DIR)\n", + "ref_files = {p.stem.upper(): p for p in REF_DIR.rglob(\"*.WAV\")}\n", + "print(len(ref_files), \"reference samples\")" + ] + }, + { + "cell_type": "markdown", + "id": "77a8570e", + "metadata": {}, + "source": [ + "## 2. Helpers — WAV I/O, resample, onset-align, spectra" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1c485d4f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:52.260863Z", + "iopub.status.busy": "2026-07-19T02:05:52.260533Z", + "iopub.status.idle": "2026-07-19T02:05:52.276460Z", + "shell.execute_reply": "2026-07-19T02:05:52.275027Z" + } + }, + "outputs": [], + "source": [ + "def read_wav(path):\n", + " # Manual RIFF parse: handles PCM (fmt 1, 8/16/24/32-bit) AND IEEE float (fmt 3), which\n", + " # Python's `wave` rejects but our render tool emits.\n", + " data = pathlib.Path(path).read_bytes()\n", + " assert data[:4] == b\"RIFF\" and data[8:12] == b\"WAVE\", f\"not a WAV: {path}\"\n", + " pos, fmt, ch, sr, bits = 12, 1, 1, 44100, 16\n", + " pcm = None\n", + " while pos + 8 <= len(data):\n", + " cid = data[pos:pos+4]; csz = struct.unpack(\" 1: x = x.reshape(-1, ch).mean(axis=1)\n", + " return x, sr\n", + "\n", + "def resample(x, sr, target=ANALYSIS_SR):\n", + " if sr == target: return x\n", + " t = np.arange(len(x)) / sr\n", + " tt = np.arange(0, t[-1], 1.0 / target)\n", + " return np.interp(tt, t, x)\n", + "\n", + "def onset_trim(x, thresh=0.02, pre=64):\n", + " idx = np.argmax(np.abs(x) > thresh * np.max(np.abs(x)))\n", + " return x[max(0, idx - pre):]\n", + "\n", + "def render_ours(voice, sets):\n", + " # Render one hit via the tool; returns float samples at ANALYSIS_SR (onset-trimmed).\n", + " out = pathlib.Path(\"_tr808_ours\"); out.mkdir(exist_ok=True)\n", + " args = [str(RENDER), \"--hit\", voice, \"1.0\", str(out)]\n", + " for k, v in sets: args += [\"--set\", k, str(v)]\n", + " subprocess.run(args, check=True, capture_output=True)\n", + " x, sr = read_wav(out / f\"tr808_{voice}_hit.wav\")\n", + " return onset_trim(resample(x, sr))\n", + "\n", + "def mag_spectrum(x, sr=ANALYSIS_SR, nfft=8192):\n", + " x = x[:nfft] if len(x) >= nfft else np.pad(x, (0, nfft - len(x)))\n", + " X = np.abs(np.fft.rfft(x * np.hanning(len(x))))\n", + " f = np.fft.rfftfreq(nfft, 1 / sr)\n", + " return f, X\n", + "\n", + "def spectral_distance(a, b, sr=ANALYSIS_SR, fmin=100, fmax=16000):\n", + " # Log-magnitude L2 distance between two peak-normalized signals over a band.\n", + " a = a / (np.max(np.abs(a)) + 1e-12); b = b / (np.max(np.abs(b)) + 1e-12)\n", + " f, A = mag_spectrum(a); _, B = mag_spectrum(b)\n", + " band = (f >= fmin) & (f <= fmax)\n", + " la = np.log10(A[band] + 1e-6); lb = np.log10(B[band] + 1e-6)\n", + " return float(np.sqrt(np.mean((la - lb) ** 2)))\n", + "\n", + "def crest_db(x):\n", + " return 20 * np.log10((np.max(np.abs(x)) + 1e-12) / (np.sqrt(np.mean(x ** 2)) + 1e-12))" + ] + }, + { + "cell_type": "markdown", + "id": "d2dbbaa0", + "metadata": {}, + "source": [ + "## 3. Snare — the primary candidate (snappy noise path)\n", + "\n", + "Reference `SD5075` = tone 0.5, snappy 0.75 (the swing VCA acts on the snappy path, so snappy is up).\n", + "We render our snare at the same knobs and sweep `drive`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e6cd8fad", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:52.279287Z", + "iopub.status.busy": "2026-07-19T02:05:52.279049Z", + "iopub.status.idle": "2026-07-19T02:05:53.991972Z", + "shell.execute_reply": "2026-07-19T02:05:53.990950Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "snare: ref crest = 22.8 dB | ours crest d0=22.7 d2=22.5 d4=22.0 d8=22.2\n", + "snare: spectral distance to 808 d0=0.410 d2=0.410 d4=0.412 d8=0.411\n", + "snare: spectral-closest drive=2 (delta=0.000); crest-closest drive=0\n" + ] + } + ], + "source": [ + "snare_ref, _ = None, None\n", + "ref, srr = read_wav(ref_files[\"SD5075\"]); snare_ref = onset_trim(resample(ref, srr))\n", + "drives = [0.0, 2.0, 4.0, 8.0]\n", + "snare_ours = {d: render_ours(\"snare\", [(\"tone\", 0.5), (\"snappy\", 0.75), (\"drive\", d)]) for d in drives}\n", + "\n", + "def compare_voice(name, ref, ours, drives, twin_ms=140, fname=None):\n", + " fig, ax = plt.subplots(1, 3, figsize=(13.5, 3.4))\n", + " N = int(twin_ms * 1e-3 * ANALYSIS_SR)\n", + " t = np.arange(N) / ANALYSIS_SR * 1000\n", + " rn = ref / (np.max(np.abs(ref)) + 1e-12)\n", + " ax[0].plot(t, rn[:N], color=\"k\", lw=1.3, label=\"real 808\")\n", + " for d in drives:\n", + " o = ours[d]; on = o / (np.max(np.abs(o)) + 1e-12)\n", + " ax[0].plot(t, on[:N], lw=0.8, alpha=0.8, label=(\"linear (drive 0)\" if d == 0 else f\"swing d{d:g}\"))\n", + " ax[0].set(title=f\"{name}: waveform (peak-normalized)\", xlabel=\"ms\"); ax[0].legend()\n", + "\n", + " f, R = mag_spectrum(ref / (np.max(np.abs(ref)) + 1e-12))\n", + " ax[1].semilogx(f, 20*np.log10(R + 1e-6), color=\"k\", lw=1.3, label=\"real 808\")\n", + " for d in drives:\n", + " o = ours[d]; _, O = mag_spectrum(o / (np.max(np.abs(o)) + 1e-12))\n", + " ax[1].semilogx(f, 20*np.log10(O + 1e-6), lw=0.8, alpha=0.8, label=(\"linear\" if d == 0 else f\"swing d{d:g}\"))\n", + " ax[1].set(title=f\"{name}: magnitude spectrum\", xlabel=\"Hz\", ylabel=\"dB\", xlim=(80, 20000)); ax[1].legend()\n", + "\n", + " dist = [spectral_distance(ref, ours[d]) for d in drives]\n", + " crest = [crest_db(ours[d]) for d in drives]\n", + " ax[2].plot(drives, dist, \"o-\", label=\"spectral dist. to 808\")\n", + " ax[2].axhline(dist[0], color=\"C0\", ls=\":\", alpha=0.5)\n", + " ax[2].set(title=f\"{name}: distance to reference vs drive\", xlabel=\"drive\", ylabel=\"log-mag L2\")\n", + " ax[2].legend(loc=\"upper left\")\n", + " ax2b = ax[2].twinx(); ax2b.plot(drives, crest, \"s--\", color=\"C3\", label=\"crest factor (dB)\")\n", + " ax2b.set_ylabel(\"crest (dB)\"); ax2b.legend(loc=\"upper right\")\n", + " fig.tight_layout()\n", + " if fname: fig.savefig(FIGS / fname, dpi=110, bbox_inches=\"tight\")\n", + " plt.show()\n", + " print(f\"{name}: ref crest = {crest_db(ref):.1f} dB | ours crest \" +\n", + " \" \".join(f\"d{d:g}={c:.1f}\" for d, c in zip(drives, crest)))\n", + " print(f\"{name}: spectral distance to 808 \" +\n", + " \" \".join(f\"d{d:g}={s:.3f}\" for d, s in zip(drives, dist)))\n", + " spec_best = drives[int(np.argmin(dist))]\n", + " crest_best = drives[int(np.argmin([abs(c - crest_db(ref)) for c in crest]))]\n", + " print(f\"{name}: spectral-closest drive={spec_best:g} (delta={dist[0]-min(dist):.3f}); \"\n", + " f\"crest-closest drive={crest_best:g}\")\n", + " return dist, crest\n", + "\n", + "snare_dist, snare_crest = compare_voice(\"snare\", snare_ref, snare_ours, drives, fname=\"snare.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "3fa60fd5", + "metadata": {}, + "source": [ + "### Listen — snare (real 808 / our linear / our swing)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "62bb2bbe", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:53.997580Z", + "iopub.status.busy": "2026-07-19T02:05:53.997192Z", + "iopub.status.idle": "2026-07-19T02:05:54.016558Z", + "shell.execute_reply": "2026-07-19T02:05:54.013548Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real 808 (SD5075):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our linear (drive 0):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our swing (drive 4):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import Audio, display\n", + "import IPython.display as ipd\n", + "def player(x, sr=ANALYSIS_SR):\n", + " return Audio(x / (np.max(np.abs(x)) + 1e-12) * 0.9, rate=sr)\n", + "print(\"real 808 (SD5075):\"); display(player(snare_ref))\n", + "print(\"our linear (drive 0):\"); display(player(snare_ours[0.0]))\n", + "print(\"our swing (drive 4):\"); display(player(snare_ours[4.0]))" + ] + }, + { + "cell_type": "markdown", + "id": "5a213256", + "metadata": {}, + "source": [ + "## 4. Clap — the sharpest transients (strongest compression in the A/B)\n", + "\n", + "Reference `CP` (the clap has no tone/snappy knobs — a single hardware sample)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7958acb0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:54.019250Z", + "iopub.status.busy": "2026-07-19T02:05:54.019016Z", + "iopub.status.idle": "2026-07-19T02:05:55.976916Z", + "shell.execute_reply": "2026-07-19T02:05:55.975021Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "clap: ref crest = 28.7 dB | ours crest d0=22.9 d2=21.8 d4=19.6 d8=16.0\n", + "clap: spectral distance to 808 d0=0.646 d2=0.609 d4=0.551 d8=0.519\n", + "clap: spectral-closest drive=8 (delta=0.127); crest-closest drive=0\n" + ] + } + ], + "source": [ + "clap_ref = onset_trim(resample(*read_wav(ref_files[\"CP\"])))\n", + "clap_ours = {d: render_ours(\"clap\", [(\"drive\", d)]) for d in drives}\n", + "clap_dist, clap_crest = compare_voice(\"clap\", clap_ref, clap_ours, drives, twin_ms=200, fname=\"clap.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7fe9f761", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:55.980884Z", + "iopub.status.busy": "2026-07-19T02:05:55.980478Z", + "iopub.status.idle": "2026-07-19T02:05:56.003346Z", + "shell.execute_reply": "2026-07-19T02:05:56.001060Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real 808 (CP):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our linear:\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our swing (drive 4):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"real 808 (CP):\"); display(player(clap_ref))\n", + "print(\"our linear:\"); display(player(clap_ours[0.0]))\n", + "print(\"our swing (drive 4):\"); display(player(clap_ours[4.0]))" + ] + }, + { + "cell_type": "markdown", + "id": "3d6f925e", + "metadata": {}, + "source": [ + "## 5. Tom — the weak candidate (noise is a small part of the voice)\n", + "\n", + "Reference `MT50` (mid tom, tuning 0.5). The tom is mostly its tonal shell ring; the swing VCA only\n", + "touches the small noise \"reverberation\" layer, so expect little movement — included for honesty." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "14bf6737", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:56.006074Z", + "iopub.status.busy": "2026-07-19T02:05:56.005802Z", + "iopub.status.idle": "2026-07-19T02:05:57.721365Z", + "shell.execute_reply": "2026-07-19T02:05:57.719990Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tom: ref crest = 18.9 dB | ours crest d0=17.4 d2=16.8 d4=16.7 d8=16.7\n", + "tom: spectral distance to 808 d0=1.399 d2=1.295 d4=1.209 d8=1.103\n", + "tom: spectral-closest drive=8 (delta=0.295); crest-closest drive=0\n" + ] + } + ], + "source": [ + "tom_ref = onset_trim(resample(*read_wav(ref_files[\"MT50\"])))\n", + "tom_ours = {d: render_ours(\"tom\", [(\"size\", 1), (\"tuning\", 0.5), (\"drive\", d)]) for d in drives}\n", + "tom_dist, tom_crest = compare_voice(\"tom\", tom_ref, tom_ours, drives, twin_ms=200, fname=\"tom.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "048958f3", + "metadata": {}, + "source": [ + "## 6. Read-out\n", + "\n", + "For each voice the middle panel asks the calibration question directly: **does the spectral distance\n", + "to the real 808 fall as `drive` rises?**\n", + "\n", + "- If the minimum sits at **drive 0**, our linear model is already the best match and the honest call\n", + " is to keep the default at 0 (the mode stays available as a *creative* bend, not a fidelity fix).\n", + "- If the minimum sits at **drive > 0**, the swing saturation genuinely moves us toward the hardware,\n", + " and that drive is a defensible default candidate.\n", + "\n", + "The crest-factor curve (right axis) shows the mechanism — swing drive lowers crest (peak vs RMS),\n", + "i.e. it is transient compression. Compare our crest at each drive against the **real 808's crest**\n", + "(printed): the drive whose crest lands nearest the hardware's is the physically-motivated setting,\n", + "independent of the spectral metric.\n", + "\n", + "Numbers are printed under each figure; the summary below collects the verdict." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "582fc9e0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:57.723968Z", + "iopub.status.busy": "2026-07-19T02:05:57.723723Z", + "iopub.status.idle": "2026-07-19T02:05:57.732031Z", + "shell.execute_reply": "2026-07-19T02:05:57.730847Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "snare : 808 crest 22.8 dB, linear 22.7 dB | spec-best d2 (delta 0.000), crest-best d0 -> KEEP drive 0 — linear already matches the hardware\n", + "clap : 808 crest 28.7 dB, linear 22.9 dB | spec-best d8 (delta 0.127), crest-best d0 -> KEEP drive 0 — crest (the direct measure) says linear matches; the spectral drift is likely confounded\n", + "tom : 808 crest 18.9 dB, linear 17.4 dB | spec-best d8 (delta 0.295), crest-best d0 -> KEEP drive 0 — crest (the direct measure) says linear matches; the spectral drift is likely confounded\n" + ] + } + ], + "source": [ + "def verdict(name, dist, crest, ref_crest):\n", + " spec_best = drives[int(np.argmin(dist))]; spec_gain = dist[0] - min(dist)\n", + " crest_best = drives[int(np.argmin([abs(c - ref_crest) for c in crest]))]\n", + " if crest_best == 0 and spec_gain < 0.03:\n", + " call = \"KEEP drive 0 — linear already matches the hardware\"\n", + " elif crest_best == 0:\n", + " call = \"KEEP drive 0 — crest (the direct measure) says linear matches; the spectral drift is likely confounded\"\n", + " else:\n", + " call = f\"consider drive ~{crest_best:g} — moves crest toward the hardware\"\n", + " print(f\"{name:6s}: 808 crest {ref_crest:.1f} dB, linear {crest[0]:.1f} dB | \"\n", + " f\"spec-best d{spec_best:g} (delta {spec_gain:.3f}), crest-best d{crest_best:g} -> {call}\")\n", + "\n", + "verdict(\"snare\", snare_dist, snare_crest, crest_db(snare_ref))\n", + "verdict(\"clap\", clap_dist, clap_crest, crest_db(clap_ref))\n", + "verdict(\"tom\", tom_dist, tom_crest, crest_db(tom_ref))" + ] + }, + { + "cell_type": "markdown", + "id": "4a75c1a6", + "metadata": {}, + "source": [ + "### Conclusion (from this run)\n", + "\n", + "**The crest-factor evidence says keep `drive` at 0.** For all three noise voices our existing\n", + "linear model already sits at or above the real 808's transient sharpness — the hardware is *not*\n", + "audibly compressing these hits more than our linear model does, which matches the DAFx-14 finding\n", + "that 808 device nonlinearity matters less than folklore claims. Adding `drive` only compresses\n", + "*past* the hardware. The spectral-distance metric wiggles (snare: negligible; clap: improves but\n", + "**conflicts** with crest, so it's trading one mismatch for another; tom: dominated by shell-tuning,\n", + "not the VCA) — so it does not override the crest read.\n", + "\n", + "**So:** ship `swing` as a *creative* bend (the default stays 0, everything bit-identical), **not**\n", + "as a fidelity default. If we want it as a fidelity feature, the place to look is the **tonal**\n", + "voices the Service Notes actually cite (rim/claves, cowbell), where a symmetric shaper adds audible\n", + "odd harmonics rather than just limiting a noise peak — a separate experiment." + ] + }, + { + "cell_type": "markdown", + "id": "75843e44", + "metadata": {}, + "source": [ + "## 7. Tonal voices — where the Service Notes actually cite the swing VCA (RS / CL, cowbell)\n", + "\n", + "On broadband noise a symmetric shaper mostly limits peaks (§6). On a **tonal** signal it adds\n", + "audible **odd harmonics** — which is exactly what the Service Notes describe for the **RS/CL VCA**.\n", + "So the right metric here is not crest but **high-frequency energy** (\"many high harmonics\") and the\n", + "spectral match to the real hardware.\n", + "\n", + "Telling detail already in the kernel: the **rimshot** path never was linear — it ships\n", + "`tanh(ring·k_rs_drive·env)/k_rs_drive` with `k_rs_drive = 2.2`, i.e. `swing_vca(ring, env, 2.2)`\n", + "(now literally unified onto the shared shaper). So the rimshot is a *built-in* precedent that tonal\n", + "swing saturation is warranted; the sweep below includes drive 0 (a hypothetical *linear* rimshot)\n", + "to show what that constant buys against the real RS. Claves and cowbell were still linear — the\n", + "open question." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8d6ef7b8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:57.734781Z", + "iopub.status.busy": "2026-07-19T02:05:57.734552Z", + "iopub.status.idle": "2026-07-19T02:05:57.750969Z", + "shell.execute_reply": "2026-07-19T02:05:57.749755Z" + } + }, + "outputs": [], + "source": [ + "def hf_ratio(x, cut=4000):\n", + " f, X = mag_spectrum(x / (np.max(np.abs(x)) + 1e-12)); p = X ** 2\n", + " return float(p[f >= cut].sum() / (p.sum() + 1e-12))\n", + "\n", + "def compare_tonal(name, ref, ours, drives, twin_ms=60, fname=None):\n", + " fig, ax = plt.subplots(1, 3, figsize=(13.5, 3.4))\n", + " N = int(twin_ms * 1e-3 * ANALYSIS_SR); t = np.arange(N) / ANALYSIS_SR * 1000\n", + " rn = ref / (np.max(np.abs(ref)) + 1e-12)\n", + " ax[0].plot(t, rn[:N], color=\"k\", lw=1.3, label=\"real 808\")\n", + " for d in drives:\n", + " o = ours[d] / (np.max(np.abs(ours[d])) + 1e-12)\n", + " ax[0].plot(t, o[:N], lw=0.8, alpha=0.8, label=(f\"linear (d0)\" if d == 0 else f\"swing d{d:g}\"))\n", + " ax[0].set(title=f\"{name}: waveform\", xlabel=\"ms\"); ax[0].legend()\n", + " f, R = mag_spectrum(ref / (np.max(np.abs(ref)) + 1e-12))\n", + " ax[1].semilogx(f, 20*np.log10(R + 1e-6), color=\"k\", lw=1.3, label=\"real 808\")\n", + " for d in drives:\n", + " _, O = mag_spectrum(ours[d] / (np.max(np.abs(ours[d])) + 1e-12))\n", + " ax[1].semilogx(f, 20*np.log10(O + 1e-6), lw=0.8, alpha=0.8, label=(f\"linear\" if d == 0 else f\"d{d:g}\"))\n", + " ax[1].set(title=f\"{name}: magnitude spectrum\", xlabel=\"Hz\", ylabel=\"dB\", xlim=(200, 20000)); ax[1].legend()\n", + " dist = [spectral_distance(ref, ours[d]) for d in drives]\n", + " hf = [hf_ratio(ours[d]) for d in drives]; hf_ref = hf_ratio(ref)\n", + " ax[2].plot(drives, dist, \"o-\", label=\"spectral dist. to 808\")\n", + " ax[2].set(title=f\"{name}: fit vs drive\", xlabel=\"drive\", ylabel=\"log-mag L2\"); ax[2].legend(loc=\"upper left\")\n", + " ax2b = ax[2].twinx()\n", + " ax2b.plot(drives, hf, \"s--\", color=\"C3\", label=\"our HF ratio\")\n", + " ax2b.axhline(hf_ref, color=\"k\", ls=\":\", label=\"808 HF ratio\"); ax2b.set_ylabel(\"HF energy ratio (>4 kHz)\")\n", + " ax2b.legend(loc=\"upper right\")\n", + " fig.tight_layout()\n", + " if fname: fig.savefig(FIGS / fname, dpi=110, bbox_inches=\"tight\")\n", + " plt.show()\n", + " spec_best = drives[int(np.argmin(dist))]\n", + " hf_best = drives[int(np.argmin([abs(h - hf_ref) for h in hf]))]\n", + " print(f\"{name}: 808 HF ratio={hf_ref:.3f} | ours \" + \" \".join(f\"d{d:g}={h:.3f}\" for d, h in zip(drives, hf)))\n", + " print(f\"{name}: spectral dist \" + \" \".join(f\"d{d:g}={s:.3f}\" for d, s in zip(drives, dist)))\n", + " print(f\"{name}: spectral-closest drive={spec_best:g}; HF-match drive={hf_best:g}\")\n", + " return dist, hf, hf_ref" + ] + }, + { + "cell_type": "markdown", + "id": "41eb9e73", + "metadata": {}, + "source": [ + "### Rimshot (RS) — ships saturated at 2.2; drive 0 is a hypothetical *linear* rimshot" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8127076c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:57.753468Z", + "iopub.status.busy": "2026-07-19T02:05:57.753240Z", + "iopub.status.idle": "2026-07-19T02:05:59.160360Z", + "shell.execute_reply": "2026-07-19T02:05:59.158961Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rimshot: 808 HF ratio=0.013 | ours d0=0.000 d1=0.000 d2.2=0.001 d4=0.001\n", + "rimshot: spectral dist d0=1.359 d1=0.906 d2.2=0.586 d4=0.474\n", + "rimshot: spectral-closest drive=4; HF-match drive=4\n", + "real 808 (RS):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "linear rimshot (drive 0):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shipped rimshot (drive 2.2):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tdr = [0.0, 1.0, 2.2, 4.0]\n", + "rs_ref = onset_trim(resample(*read_wav(ref_files[\"RS\"])))\n", + "rs_ours = {d: render_ours(\"rimshot\", [(\"drive\", d)]) for d in tdr}\n", + "rs_dist, rs_hf, rs_hfref = compare_tonal(\"rimshot\", rs_ref, rs_ours, tdr, twin_ms=40, fname=\"rimshot.png\")\n", + "print(\"real 808 (RS):\"); display(player(rs_ref))\n", + "print(\"linear rimshot (drive 0):\"); display(player(rs_ours[0.0]))\n", + "print(\"shipped rimshot (drive 2.2):\"); display(player(rs_ours[2.2]))" + ] + }, + { + "cell_type": "markdown", + "id": "8d036810", + "metadata": {}, + "source": [ + "### Claves (CL) — currently linear; does swing move it toward the real CL?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1580d4d8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:05:59.162806Z", + "iopub.status.busy": "2026-07-19T02:05:59.162556Z", + "iopub.status.idle": "2026-07-19T02:06:00.799653Z", + "shell.execute_reply": "2026-07-19T02:06:00.798177Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "claves: 808 HF ratio=0.000 | ours d0=0.000 d1=0.034 d2.2=0.042 d4=0.048\n", + "claves: spectral dist d0=1.254 d1=1.085 d2.2=1.247 d4=1.371\n", + "claves: spectral-closest drive=1; HF-match drive=0\n", + "real 808 (CL):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our linear (drive 0):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our swing (drive 2.2):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cl_ref = onset_trim(resample(*read_wav(ref_files[\"CL\"])))\n", + "cl_ours = {d: render_ours(\"claves\", [(\"drive\", d)]) for d in tdr}\n", + "cl_dist, cl_hf, cl_hfref = compare_tonal(\"claves\", cl_ref, cl_ours, tdr, twin_ms=40, fname=\"claves.png\")\n", + "print(\"real 808 (CL):\"); display(player(cl_ref))\n", + "print(\"our linear (drive 0):\"); display(player(cl_ours[0.0]))\n", + "print(\"our swing (drive 2.2):\"); display(player(cl_ours[2.2]))" + ] + }, + { + "cell_type": "markdown", + "id": "afe57549", + "metadata": {}, + "source": [ + "### Cowbell (CB) — currently linear (two square oscillators through the swing VCA)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e136317d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:06:00.802314Z", + "iopub.status.busy": "2026-07-19T02:06:00.802078Z", + "iopub.status.idle": "2026-07-19T02:06:02.666268Z", + "shell.execute_reply": "2026-07-19T02:06:02.665125Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cowbell: 808 HF ratio=0.002 | ours d0=0.001 d1=0.001 d2.2=0.001 d4=0.001\n", + "cowbell: spectral dist d0=1.181 d1=1.179 d2.2=1.189 d4=1.233\n", + "cowbell: spectral-closest drive=1; HF-match drive=4\n", + "real 808 (CB):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our linear (drive 0):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "our swing (drive 2.2):\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cb_ref = onset_trim(resample(*read_wav(ref_files[\"CB\"])))\n", + "cb_ours = {d: render_ours(\"cowbell\", [(\"drive\", d)]) for d in tdr}\n", + "cb_dist, cb_hf, cb_hfref = compare_tonal(\"cowbell\", cb_ref, cb_ours, tdr, twin_ms=120, fname=\"cowbell.png\")\n", + "print(\"real 808 (CB):\"); display(player(cb_ref))\n", + "print(\"our linear (drive 0):\"); display(player(cb_ours[0.0]))\n", + "print(\"our swing (drive 2.2):\"); display(player(cb_ours[2.2]))" + ] + }, + { + "cell_type": "markdown", + "id": "b3957695", + "metadata": {}, + "source": [ + "### Tonal read-out\n", + "\n", + "Two questions per voice: does the **HF-energy ratio** (dashed = real 808, red squares = ours) move\n", + "toward the hardware as drive rises, and does the **spectral distance** (blue) fall? When both point\n", + "to the same nonzero drive, swing earns a fidelity default on that voice." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2986cd28", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-19T02:06:02.668846Z", + "iopub.status.busy": "2026-07-19T02:06:02.668541Z", + "iopub.status.idle": "2026-07-19T02:06:02.676048Z", + "shell.execute_reply": "2026-07-19T02:06:02.674734Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rimshot : 808 HF 0.013, linear HF 0.000 | spec 1.36->0.47 (best d4, mono) -> SWING WARRANTED — distance falls 1.36->0.47 monotonically with drive\n", + "claves : 808 HF 0.000, linear HF 0.000 | spec 1.25->1.08 (best d1, non-mono) -> keep linear — only a small/non-monotonic wiggle (best d1), not a real improvement\n", + "cowbell : 808 HF 0.002, linear HF 0.001 | spec 1.18->1.18 (best d1, non-mono) -> keep linear — drive barely moves the fit; the mismatch is elsewhere (tuning/mix)\n" + ] + } + ], + "source": [ + "def tverdict(name, dist, hf, hf_ref):\n", + " # Primary metric: log-magnitude spectral distance to the real 808 (captures added harmonics\n", + " # wherever they land). HF ratio is informational only — its fixed 4 kHz cutoff misses the\n", + " # rimshot's lower harmonics. A real fidelity win is a LARGE, MONOTONIC fall in distance as\n", + " # drive rises; a tiny or non-monotonic wiggle is coincidental.\n", + " spec_best = tdr[int(np.argmin(dist))]; spec_gain = dist[0] - min(dist)\n", + " monotonic = all(dist[i] >= dist[i + 1] - 1e-9 for i in range(len(dist) - 1))\n", + " if spec_gain > 0.3 and monotonic and spec_best > 0:\n", + " call = f\"SWING WARRANTED — distance falls {dist[0]:.2f}->{min(dist):.2f} monotonically with drive\"\n", + " elif spec_gain < 0.05:\n", + " call = \"keep linear — drive barely moves the fit; the mismatch is elsewhere (tuning/mix)\"\n", + " else:\n", + " call = f\"keep linear — only a small/non-monotonic wiggle (best d{spec_best:g}), not a real improvement\"\n", + " print(f\"{name:8s}: 808 HF {hf_ref:.3f}, linear HF {hf[0]:.3f} | spec {dist[0]:.2f}->{min(dist):.2f} \"\n", + " f\"(best d{spec_best:g}, {'mono' if monotonic else 'non-mono'}) -> {call}\")\n", + "\n", + "tverdict(\"rimshot\", rs_dist, rs_hf, rs_hfref)\n", + "tverdict(\"claves\", cl_dist, cl_hf, cl_hfref)\n", + "tverdict(\"cowbell\", cb_dist, cb_hf, cb_hfref)" + ] + }, + { + "cell_type": "markdown", + "id": "250a07b2", + "metadata": {}, + "source": [ + "### Tonal conclusion (from this run)\n", + "\n", + "**Swing earns its keep on exactly one tonal voice — the rimshot — and that voice already ships it.**\n", + "Adding the swing saturation collapses the rimshot's spectral distance to the real RS (≈1.36 → 0.47),\n", + "confirming the pre-existing `k_rs_drive = 2.2`. The **claves** is a near-pure ~2.5 kHz tone (real HF\n", + "ratio ≈ 0), so a symmetric shaper only adds harmonics the hardware *doesn't* have — it moves away.\n", + "The **cowbell**'s distance to the real CB is large and essentially flat across drive, so its mismatch\n", + "lives in the oscillator tuning/mix, not the VCA — drive doesn't fix it.\n", + "\n", + "**Net across the whole family:** the swing VCA is a *fidelity* feature only where it was already\n", + "applied (the rimshot). Everywhere else — the noise voices (§6) and the other tonal voices — the\n", + "honest call is **linear by default**, with `drive` retained as an opt-in creative bend. The\n", + "rimshot's inline saturator is now unified onto the shared `vca.h` shaper (bit-identical), which is\n", + "the real durable win here: one swing-VCA implementation across `tap.303~`, `tap.vca~`, and every 808\n", + "voice that wants it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 09b3b74..452701c 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -28,6 +28,7 @@ add_executable(taptools_kernel_tests tr808_tom_test.cpp tr808_snare_test.cpp tb303_voice_test.cpp + vca_test.cpp vco_test.cpp vocoder_test.cpp conv_engine_test.cpp diff --git a/tests/tr808_snare_test.cpp b/tests/tr808_snare_test.cpp index 4375c68..57d562c 100644 --- a/tests/tr808_snare_test.cpp +++ b/tests/tr808_snare_test.cpp @@ -174,6 +174,40 @@ SCENARIO("snare rendering is deterministic for a fixed seed") { CHECK_FALSE(same); } +SCENARIO("the swing-VCA drive: off is bit-identical, on saturates the snappy crack") { + GIVEN("two snares with a hot snappy hit") { + THEN("drive 0 (default) is bit-identical to an explicit set_drive(0)") { + auto a = make(0.5, 1.0); // default: no set_drive call + auto b = make(0.5, 1.0); + b.set_drive(0.0); // explicit linear + auto ya = render(a, 0.3, 1.0); + auto yb = render(b, 0.3, 1.0); + bool same = true; + for (size_t i = 0; i < ya.size(); ++i) + same = same && ya[i] == yb[i]; // exact equality — the linear path is untouched + REQUIRE(same); + } + THEN("drive > 0 changes the signal, compresses the transient peak, and stays bounded") { + auto clean = make(0.5, 1.0); + auto warm = make(0.5, 1.0); + warm.set_drive(6.0); // hard swing-VCA saturation + auto yc = render(clean, 0.3, 1.0); + auto yw = render(warm, 0.3, 1.0); + + double diff = 0.0; + bool finite = true; + for (size_t i = 0; i < yc.size(); ++i) { + diff += std::abs(yc[i] - yw[i]); + finite = finite && std::isfinite(yw[i]); + } + REQUIRE(diff > 0.0); // the saturator is engaged + REQUIRE(finite); + REQUIRE(peak(yw) < peak(yc)); // compression softens the crack + REQUIRE(peak(yw) > 0.3 * peak(yc)); // but does not gut the hit + } + } +} + SCENARIO("the snare is silent at rest and its tail reaches true silence") { auto s = make(); std::vector quiet(static_cast(0.1 * k_sr)); diff --git a/tests/vca_test.cpp b/tests/vca_test.cpp new file mode 100644 index 0000000..d056643 --- /dev/null +++ b/tests/vca_test.cpp @@ -0,0 +1,195 @@ +/// @file +/// @brief Unit tests for the VCA kernel (taptools::vca). +/// @details Pins the two-circuit contract: `clean` is an exact linear multiply; `warm` is the +/// 303's slope-normalized biased-tanh transistor stage — unity slope through zero +/// (quiet signals near-clean), asymmetric even-harmonic saturation and compression on +/// hot signals, the operating-point DC removed by construction, and the optional +/// output-coupling DC block on AC material. Also pins the shared-implementation +/// invariant: vca::shape() with the stock constants reproduces the exact saturator the +/// TB-303 voice uses, so the extraction left tap.303~ bit-identical. +// SPDX-License-Identifier: BSD-3-Clause +// Copyright 2026 Timothy Place. + +#include +#include + +#include +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + constexpr double k_pi = 3.14159265358979323846; + + // The reference saturator, written longhand exactly as the 303 voice used to inline it. + double reference_shape(double v, double d, double b) { + const double off = std::tanh(b); + const double norm = 1.0 / (d * (1.0 - off * off)); + return (std::tanh(d * v + b) - off) * norm; + } + + double rms(const std::vector& x) { + double s = 0.0; + for (double v : x) + s += v * v; + return std::sqrt(s / x.size()); + } + + double mean(const std::vector& x) { + double s = 0.0; + for (double v : x) + s += v; + return s / x.size(); + } + +} // namespace + +SCENARIO("the clean circuit is an exact linear multiply") { + taptools::vca a; + a.prepare(k_sr); + REQUIRE(a.circuit() == taptools::vca::mode_clean); // default + + THEN("process(x, gain) == x * gain to the bit, for any gain incl. negative and > 1") { + for (double g : {0.0, 0.5, 1.0, 2.5, -0.75}) { + for (double x : {-1.0, -0.3, 0.0, 0.42, 0.9}) { + REQUIRE(a.process(x, g) == x * g); + } + } + } + THEN("shape() is the identity in clean mode") { + REQUIRE(a.shape(0.37) == 0.37); + REQUIRE(a.shape(-1.5) == -1.5); + } +} + +SCENARIO("the warm circuit reproduces the 303 transistor saturator exactly") { + taptools::vca a; + a.prepare(k_sr); + a.set_mode(taptools::vca::mode_warm); + REQUIRE(a.drive() == taptools::vca::k_default_drive); // stock 303 constants + REQUIRE(a.bias() == taptools::vca::k_default_bias); + + THEN("shape(v) matches the closed-form reference at the stock constants, bit for bit") { + for (double v : {-1.2, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 1.7}) { + REQUIRE(a.shape(v) == reference_shape(v, a.drive(), a.bias())); + } + } + THEN("unity slope through zero: tiny signals pass essentially clean") { + REQUIRE(a.shape(0.0) == 0.0); // operating-point DC removed + REQUIRE(std::abs(a.shape(1e-4) - 1e-4) < 1e-7); // slope 1 at the origin + } + THEN("hot signals compress (|out| < |in|) and stay monotonic") { + double prev = a.shape(-2.0); + for (double v = -2.0 + 0.05; v <= 2.0; v += 0.05) { + const double y = a.shape(v); + REQUIRE(y > prev); // strictly increasing + prev = y; + } + REQUIRE(std::abs(a.shape(1.5)) < 1.5); // compression at the top + } +} + +SCENARIO("the extraction left the TB-303 voice routed through the shared stage") { + namespace tb = taptools::tb303; + + auto play = [](int mode) { + tb::voice v; + v.prepare(k_sr); + v.set_vca(mode); + v.note_on(45.0, 1.0); // hot accented A1 so the warm stage bites + std::vector out(static_cast(0.2 * k_sr)); + v.process(out.data(), out.size()); + return out; + }; + + WHEN("the warm voice runs") { + auto warm = play(tb::vca_warm); + auto clean = play(tb::vca_clean); + THEN("it differs from clean (the saturator is engaged) and stays finite") { + double d = 0.0; + for (size_t i = 0; i < warm.size(); ++i) { + d += std::abs(warm[i] - clean[i]); + REQUIRE(std::isfinite(warm[i])); + } + REQUIRE(d > 0.0); + } + } +} + +SCENARIO("the warm circuit's output DC block sheds signal-dependent DC on AC material") { + auto run = [](bool dc_block) { + taptools::vca a; + a.prepare(k_sr); + a.set_mode(taptools::vca::mode_warm); + a.set_dc_block(dc_block); + std::vector out; + out.reserve(static_cast(k_sr)); + const double f = 220.0; + for (size_t i = 0; i < static_cast(k_sr); ++i) + out.push_back(a.process(std::sin(2.0 * k_pi * f * static_cast(i) / k_sr), 1.0)); + return out; + }; + + THEN("with the block on the mean is ~0; with it off a DC offset remains; energy is preserved") { + auto on = run(true); + auto off = run(false); + std::vector on_ss(on.begin() + on.size() / 2, on.end()); // skip settling + std::vector off_ss(off.begin() + off.size() / 2, off.end()); + REQUIRE(std::abs(mean(on_ss)) < 1e-3); + REQUIRE(std::abs(mean(off_ss)) > 10.0 * std::abs(mean(on_ss))); // off carries real DC + REQUIRE(std::abs(mean(off_ss)) > 1e-3); + REQUIRE(rms(on_ss) > 0.5 * rms(off_ss)); // DC-only: signal not gutted + } +} + +SCENARIO("the swing circuit is the TR-808 symmetric harmonic saturator") { + THEN("swing_shape is the exact linear passthru at drive 0 (calibrated voices stay bit-identical)") { + for (double v : {-1.3, -0.4, 0.0, 0.25, 0.9, 1.6}) + REQUIRE(taptools::vca::swing_shape(v, 0.0) == v); + } + THEN("with drive > 0 it is an odd function — symmetric, no even harmonics, no DC") { + for (double d : {0.5, 2.0, 6.0}) + for (double v : {0.15, 0.6, 1.2}) + REQUIRE(std::abs(taptools::vca::swing_shape(v, d) + taptools::vca::swing_shape(-v, d)) < 1e-12); + } + THEN("unity slope through zero (quiet signals near-clean) and compression on hot signals") { + const double d = 2.0; + REQUIRE(std::abs(taptools::vca::swing_shape(1e-4, d) - 1e-4) < 1e-7); + REQUIRE(std::abs(taptools::vca::swing_shape(1.5, d)) < 1.5); + } + GIVEN("a vca in swing mode") { + taptools::vca a; + a.prepare(k_sr); + a.set_mode(taptools::vca::mode_swing); + a.set_drive(2.0); + THEN("shape() routes through the shared swing_shape and needs no DC block (symmetric)") { + REQUIRE(a.shape(0.7) == taptools::vca::swing_shape(0.7, a.drive())); + // a symmetric shaper on a symmetric sweep has zero mean either way + double mean_on = 0.0; + int n = 0; + for (double ph = 0.0; ph < 2.0 * k_pi; ph += 0.001, ++n) + mean_on += a.process(std::sin(ph), 1.0); + REQUIRE(std::abs(mean_on / n) < 1e-3); + } + } +} + +SCENARIO("drive and bias are live and reshape the curve") { + taptools::vca a; + a.prepare(k_sr); + a.set_mode(taptools::vca::mode_warm); + + THEN("more drive means more compression on a hot signal") { + a.set_drive(1.0); + const double soft = a.shape(1.0); + a.set_drive(4.0); + const double hard = a.shape(1.0); + REQUIRE(hard < soft); + } + THEN("zero bias is an odd function (no even harmonics, no DC term)") { + a.set_bias(0.0); + for (double v : {0.2, 0.6, 1.1}) + REQUIRE(std::abs(a.shape(v) + a.shape(-v)) < 1e-12); + } +} diff --git a/tools/render/tr808_render.cpp b/tools/render/tr808_render.cpp index 515f5bc..715935e 100644 --- a/tools/render/tr808_render.cpp +++ b/tools/render/tr808_render.cpp @@ -139,6 +139,7 @@ namespace { {{"tone", [](snare& o, double x) { o.set_tone(x); }}, {"snappy", [](snare& o, double x) { o.set_snappy(x); }}, {"tuning", [](snare& o, double x) { o.set_tuning(x); }}, + {"drive", [](snare& o, double x) { o.set_drive(x); }}, {"seed", [](snare& o, double x) { o.set_seed(static_cast(x)); }}, {"level", [](snare& o, double x) { o.set_level(x); }}}); return take(0.6, [&] { v.trigger(accent); }, [&] { return v.process(); }); @@ -149,6 +150,7 @@ namespace { v.set_model(name == "maracas" ? clap::model_maracas : clap::model_clap); apply_knobs(v, knobs, {{"tail", [](clap& o, double x) { o.set_tail(x); }}, + {"drive", [](clap& o, double x) { o.set_drive(x); }}, {"seed", [](clap& o, double x) { o.set_seed(static_cast(x)); }}, {"level", [](clap& o, double x) { o.set_level(x); }}}); return take(0.6, [&] { v.trigger(accent); }, [&] { return v.process(); }); @@ -193,6 +195,7 @@ namespace { apply_knobs(v, knobs, {{"tuning", [](cowbell& o, double x) { o.set_tuning(x); }}, {"tolerance", [](cowbell& o, double x) { o.set_tolerance(x); }}, + {"drive", [](cowbell& o, double x) { o.set_drive(x); }}, {"seed", [](cowbell& o, double x) { o.set_seed(static_cast(x)); }}, {"level", [](cowbell& o, double x) { o.set_level(x); }}}); return take(0.6, [&] { v.trigger(accent); }, [&] { return v.process(); }); @@ -205,6 +208,7 @@ namespace { apply_knobs(v, knobs, {{"size", [](tom& o, double x) { o.set_size(static_cast(x)); }}, {"tuning", [](tom& o, double x) { o.set_tuning(x); }}, + {"drive", [](tom& o, double x) { o.set_drive(x); }}, {"seed", [](tom& o, double x) { o.set_seed(static_cast(x)); }}, {"level", [](tom& o, double x) { o.set_level(x); }}}); return take(0.8, [&] { v.trigger(accent); }, [&] { return v.process(); }); @@ -213,7 +217,9 @@ namespace { rim v; v.prepare(k_g_sr); v.set_model(name == "claves" ? rim::model_claves : rim::model_rimshot); - apply_knobs(v, knobs, {{"level", [](rim& o, double x) { o.set_level(x); }}}); + apply_knobs(v, knobs, {{"drive", [](rim& o, double x) { o.set_drive(x); }}, {"level", [](rim& o, double x) { + o.set_level(x); + }}}); return take(0.4, [&] { v.trigger(accent); }, [&] { return v.process(); }); } return {};