From 936187e535ff9ea915385eb462ee47ff38ebd2f9 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 18 Jul 2026 17:46:33 +0000 Subject: [PATCH 1/7] step_seq.h: the shared step-sequencer engine behind tap.808.seq~ / tap.303.seq~ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The plans/tap.seq.md kernel (author-approved 2026-07-18): a phase-clocked step engine — floor(phase * length) with swing warping the odd-step boundaries, sample-accurate entries, stateless against phase (jump, scrub, reverse all follow) — plus the two emitters speaking the shipped voice contracts verbatim: trigger_row (amplitude-as-accent impulses on the 4-14 V bus mapping; plain 0.01 = the un-accented 4 V base, accented 0.5 = VR3 at noon) and note_row (pitch + gate at 1.0/2.0 with gate-hold slide; gate duty 0.5 per Open303's AcidPattern stepLength, the same reference the voice's calibrated constants came from; slide flag on the target step per the package note-message convention, divergence from the hardware's source-note storage documented in the header). 16 pattern slots with store/recall quantized to cycle|step|now (the armed swap re-derives the step against the new grid on the boundary sample). No bench entry: the engine is a handful of arithmetic ops per sample, below the bench harness's noise floor. 19 test scenarios: the analytic grid, polymeter off one ramp, swing offsets (and swing-0 bit-identity), velocity amplitudes with re-arming gaps, pulse widening, reverse phase, live length changes, gate duty, accent levels, gate-hold slide (chained, and across the pattern wrap), slide-after-rest, quantized recall at the wrap sample, determinism, and the tb303 voice pairing (slid steps glide with no retrigger). Suite 129/129 green. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01JZivyxyBdHYd8sVf8AdUbN --- include/taptools/step_seq.h | 326 +++++++++++++++++++++++++ tests/CMakeLists.txt | 1 + tests/step_seq_test.cpp | 457 ++++++++++++++++++++++++++++++++++++ 3 files changed, 784 insertions(+) create mode 100644 include/taptools/step_seq.h create mode 100644 tests/step_seq_test.cpp diff --git a/include/taptools/step_seq.h b/include/taptools/step_seq.h new file mode 100644 index 0000000..68e43cb --- /dev/null +++ b/include/taptools/step_seq.h @@ -0,0 +1,326 @@ +/// @file +/// @brief The shared step-sequencer engine behind tap.808.seq~ and tap.303.seq~. +/// @details One phase-clocked step engine plus two thin emitters — the design of record is +/// plans/tap.seq.md in the Max package repo (author-approved 2026-07-18), resolving +/// the phase-3 sections of the tap.808 and tap.303 plans with one shared kernel. +/// +/// The clocking idiom (the load-bearing decision): the caller feeds a phase ramp, +/// 0..1 per pattern cycle (phasor~ in Max). The engine derives the current step as +/// floor(phase * length) with swing warping the odd-step boundaries, and reports +/// sample-accurate step entries. The engine is stateless against phase — no +/// run/stop of its own; jump, scrub, or reverse the phase and the step derivation +/// follows. Rows driven from one phasor stay phase-coherent forever, and different +/// `length` values off the same ramp are polymeter (which subsumes the TR-808's +/// triplet pre-scale). +/// +/// The two emitters speak the shipped voice contracts verbatim: +/// - `trigger_row` (tap.808.seq~): impulses at step starts whose amplitude is the +/// step's velocity 0..1 — the tap.808.* accent bus (amplitude maps onto the +/// hardware's 4-14 V common trigger bus; TR-808 Service Notes, and see +/// tr808_kick.h k_bd_vtrig_min/max). Pinned levels: k_trig_plain = 0.01, the +/// un-accented 4 V base trigger (accent ~= 0, held just above the voices' 1e-3 +/// edge threshold so the edge always registers); k_trig_accented = 0.5, the +/// accent level VR3 at noon (1.0 = the full 14 V bus). +/// - `note_row` (tap.303.seq~): a pitch output (MIDI note number, held between +/// notes) and a gate output at 1.0 plain / 2.0 accented (the tap.303~ inlet +/// contract: accent depth = amplitude - 1). The gate opens at the step start and +/// closes at k_gate_duty = 0.5 of the step — Open303's AcidPattern +/// (stepLength = 0.5, "the time while gate is open ... in units of one step"), +/// the same reference the voice's calibrated constants came from. A step whose +/// `slide` flag is set is approached legato: the gate does NOT fall during the +/// step before it — it holds through the boundary while the pitch steps, and the +/// voice's legato detection does the ~60 ms glide without retriggering. (The +/// hardware stores the flag on the source note, "slide to next"; the package +/// convention puts it on the target step, matching tap.303~'s +/// `note [accent] [slide]` message — the data models convert trivially.) +/// An accented slid step keeps the held gate level: the voice samples accent at +/// the rising edge only (the shipped contract), so accent does not re-arm +/// without a retrigger. +/// +/// Swing: 0..1, delaying each odd-numbered step's start by up to half a step +/// (0 = straight, 2/3 = the classic triplet shuffle: the off-16th lands at 1/3 of +/// the pair). Beyond-hardware (neither machine had swing), so it defaults to 0 — +/// the house "documented bends, stock defaults" posture. Gate duty is measured +/// against the swung span, so gates never collide. +/// +/// Patterns: up to 64 steps (default 16), 16 storage slots with store/recall; +/// recall arms and applies at the next cycle boundary by default (quantize +/// cycle|step|now) — which is the TR-808's A/B-half and basic/fill switching as +/// one message. No randomness anywhere: bit-exact by construction, and pinned by +/// test anyway. +/// +/// Plain C++17, stdlib only, header-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 { + namespace seq { + + constexpr int k_max_steps = 64; + constexpr int k_num_slots = 16; + constexpr int k_default_length = 16; + + // The 303 gate opens for half the step (Open303 AcidPattern stepLength = 0.5). + constexpr double k_gate_duty = 0.5; + + // tap.808.* trigger amplitudes (the 4-14 V bus mapped to 0..1, see header note). + constexpr double k_trig_plain = 0.01; + constexpr double k_trig_accented = 0.5; + + // tap.303~ gate amplitudes (accent depth = amplitude - 1). + constexpr double k_gate_plain = 1.0; + constexpr double k_gate_accent = 2.0; + + enum quantize_mode { + quantize_cycle = 0, // armed recall applies when step 0 is entered (default) + quantize_step = 1, // ... when any step is entered + quantize_now = 2 // ... immediately + }; + + /// One step of the union payload: `velocity` serves trigger rows (0 = rest); + /// `pitch`/`gate`/`accent`/`slide` serve note rows. + struct step { + double velocity{0.0}; + double pitch{45.0}; // A2, the 303's home note + bool gate{false}; + bool accent{false}; + bool slide{false}; + }; + + struct pattern { + int length{k_default_length}; + step steps[k_max_steps]; + + void set_length(int n) { length = std::clamp(n, 1, k_max_steps); } + + void clear() { + for (auto& s : steps) + s = step{}; + } + }; + + /// The phase->step engine: boundary detection with swing warp, plus the slot store. + /// Feed `process()` one phase sample (any real number; wrapped into [0,1)) and read + /// back which step the sample is in, whether it just entered it, and how far through + /// the step's actual (swung) span it is. + class engine { + public: + struct tick { + bool entered{false}; + int index{0}; + double pos{0.0}; // position within the step's swung span, 0..1 + }; + + pattern& data() { return m_pattern; } + const pattern& data() const { return m_pattern; } + + void set_swing(double s) { m_swing = std::clamp(s, 0.0, 1.0); } + double swing() const { return m_swing; } + + void set_quantize(int m) { m_quantize = std::clamp(m, 0, 2); } + int quantize() const { return m_quantize; } + + void store(int slot) { + if (slot >= 0 && slot < k_num_slots) + m_slots[slot] = m_pattern; + } + + /// Arm (or, with quantize_now, immediately apply) a stored pattern. + void recall(int slot) { + if (slot < 0 || slot >= k_num_slots) + return; + if (m_quantize == quantize_now) { + m_pattern = m_slots[slot]; + m_armed = -1; + } + else { + m_armed = slot; + } + } + + int armed() const { return m_armed; } + + /// Forget the previous step: the next processed sample re-enters whatever step + /// its phase lands in (so a transport start fires its downbeat). + void reset() { m_prev = -1; } + + tick process(double phase) { + int k = derive(phase); + + tick t; + t.entered = (k != m_prev); + + // An armed recall applies on the quantize boundary; the step grid may change + // with the new pattern, so re-derive this sample against it. + if (t.entered && m_armed >= 0 && (m_quantize == quantize_step || k == 0)) { + m_pattern = m_slots[m_armed]; + m_armed = -1; + k = derive(phase); + } + + m_prev = k; + t.index = k; + t.pos = position(phase, k); + return t; + } + + private: + double wrap(double p) const { + p -= std::floor(p); + return (p < 0.0 || p >= 1.0) ? 0.0 : p; // guard float edge cases + } + + /// Swung start of step k, in phase units. Odd steps start late by swing/2 steps. + double start(int k) const { + const int length = m_pattern.length; + const double late = (k & 1) ? m_swing * 0.5 : 0.0; + return (static_cast(k) + late) / static_cast(length); + } + + int derive(double phase) const { + const int length = m_pattern.length; + const double u = wrap(phase) * static_cast(length); + int k = std::min(static_cast(u), length - 1); + // An odd step's start is delayed: its first swing/2 belongs to the step before. + if ((k & 1) && (u - static_cast(k)) < m_swing * 0.5) + --k; + return k; + } + + double position(double phase, int k) const { + const double b0 = start(k); + const double b1 = (k + 1 < m_pattern.length) ? start(k + 1) : 1.0; + const double span = b1 - b0; + if (span <= 0.0) + return 0.0; + return std::clamp((wrap(phase) - b0) / span, 0.0, 1.0); + } + + pattern m_pattern; + pattern m_slots[k_num_slots]; + double m_swing{0.0}; + int m_quantize{quantize_cycle}; + int m_armed{-1}; + int m_prev{-1}; + }; + + /// The tap.808.seq~ emitter: one drum row. Impulses at step starts, amplitude = + /// the step's velocity (the family's amplitude-as-accent trigger contract). With + /// `pulse_ms` above 0 the impulse widens into a held gate for envelope consumers — + /// keep it shorter than a step at your clock rate, or back-to-back steps merge and + /// downstream edge detectors (which re-arm below 1e-3) will miss the second edge. + class trigger_row { + public: + void prepare(double sample_rate) { + m_sr = std::max(sample_rate, 1.0); + set_pulse_ms(m_pulse_ms); + reset(); + } + + engine& clock() { return m_engine; } + const engine& clock() const { return m_engine; } + + void set_pulse_ms(double ms) { + m_pulse_ms = std::max(ms, 0.0); + m_pulse_samples = std::max(1, static_cast(std::lround(m_pulse_ms * 0.001 * m_sr))); + } + + void reset() { + m_engine.reset(); + m_hold = 0; + m_level = 0.0; + } + + double process(double phase) { + const engine::tick t = m_engine.process(phase); + if (t.entered) { + const step& st = m_engine.data().steps[t.index]; + if (st.velocity > 0.0) { + m_level = std::clamp(st.velocity, 0.0, 1.0); + m_hold = m_pulse_samples; + } + } + if (m_hold > 0) { + --m_hold; + return m_level; + } + return 0.0; + } + + private: + engine m_engine; + double m_sr{48000.0}; + double m_pulse_ms{0.0}; + int m_pulse_samples{1}; + int m_hold{0}; + double m_level{0.0}; + }; + + /// The tap.303.seq~ emitter: one bass line. Emits the tap.303~ inlet pair — pitch + /// (MIDI note number, held between notes) and gate (0 / 1.0 plain / 2.0 accented), + /// with gate-hold slide (see the header note for the full semantics). + class note_row { + public: + struct out { + double pitch{45.0}; + double gate{0.0}; + }; + + void prepare(double) { reset(); } // nothing rate-dependent; kept for house shape + + engine& clock() { return m_engine; } + const engine& clock() const { return m_engine; } + + void set_transpose(double semitones) { m_transpose = semitones; } + double transpose() const { return m_transpose; } + + void reset() { + m_engine.reset(); + m_gate = 0.0; + } + + out process(double phase) { + const engine::tick t = m_engine.process(phase); + const pattern& pn = m_engine.data(); + const step& st = pn.steps[t.index]; + + if (t.entered) { + if (st.gate) { + m_pitch = st.pitch + m_transpose; + // Legato only if a note is sounding to slide from; a slide flag on a + // step after a rest is a plain trigger (the voice does the same). + if (!(st.slide && m_gate > 0.0)) + m_gate = st.accent ? k_gate_accent : k_gate_plain; + } + else { + m_gate = 0.0; + } + } + else if (m_gate > 0.0 && st.gate && t.pos >= k_gate_duty) { + // Close at the duty point — unless the next step slides in, which holds + // the gate through the boundary. Read live so pattern edits apply now. + const step& nx = pn.steps[(t.index + 1) % pn.length]; + if (!(nx.gate && nx.slide)) + m_gate = 0.0; + } + + out o; + o.pitch = m_pitch; + o.gate = m_gate; + return o; + } + + private: + engine m_engine; + double m_pitch{45.0}; + double m_gate{0.0}; + double m_transpose{0.0}; + }; + + } // namespace seq +} // namespace taptools diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 1cc8e5a..09b3b74 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -18,6 +18,7 @@ add_executable(taptools_kernel_tests grm_comb_test.cpp nr_test.cpp spectra_test.cpp + step_seq_test.cpp tr808_clap_test.cpp tr808_cymbal_test.cpp tr808_hat_test.cpp diff --git a/tests/step_seq_test.cpp b/tests/step_seq_test.cpp new file mode 100644 index 0000000..c897707 --- /dev/null +++ b/tests/step_seq_test.cpp @@ -0,0 +1,457 @@ +/// @file +/// @brief Unit tests for the shared step-sequencer engine (taptools::seq). +/// @details Pins the plans/tap.seq.md contract: sample-accurate step derivation from a +/// phase ramp, the swing warp, polymeter off one ramp, reverse phase, the +/// trigger row's amplitude-as-accent impulses with re-arming gaps, the note +/// row's gate duty / accent levels / gate-hold slide (including chained slides +/// and the slide across the pattern wrap), quantized slot recall, determinism, +/// and a smoke pairing with the tb303 voice. +// 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_freq = 2.0; // pattern cycles per second + constexpr int k_cycle = static_cast(k_sr / k_freq); + + using taptools::seq::engine; + using taptools::seq::note_row; + using taptools::seq::trigger_row; + + double phase_at(int n) { + const double p = static_cast(n) * (k_freq / k_sr); + return p - std::floor(p); + } + + /// Sample indices where the row emits a trigger edge (output rises from silence). + std::vector trigger_edges(trigger_row& row, int samples) { + std::vector edges; + double prev = 0.0; + for (int n = 0; n < samples; ++n) { + const double y = row.process(phase_at(n)); + if (prev <= 1e-3 && y > 1e-3) + edges.push_back(n); + prev = y; + } + return edges; + } + + bool near(int a, int b, int tol = 1) { + return std::abs(a - b) <= tol; + } + +} // namespace + +SCENARIO("steps land exactly on the analytic grid with no swing") { + trigger_row row; + row.prepare(k_sr); + for (auto& s : row.clock().data().steps) + s.velocity = 1.0; + + const auto edges = trigger_edges(row, 2 * k_cycle); + REQUIRE(edges.size() == 32); // 16 steps x 2 cycles + const int step_len = k_cycle / 16; + for (int i = 0; i < 32; ++i) { + INFO("edge " << i << " at " << edges[i]); + CHECK(near(edges[i], i * step_len)); + } +} + +SCENARIO("different lengths off one ramp are polymeter") { + trigger_row a, b; + a.prepare(k_sr); + b.prepare(k_sr); + a.clock().data().set_length(16); + b.clock().data().set_length(12); + for (auto& s : a.clock().data().steps) + s.velocity = 1.0; + for (auto& s : b.clock().data().steps) + s.velocity = 1.0; + + std::vector ea, eb; + double pa = 0.0, pb = 0.0; + for (int n = 0; n < k_cycle; ++n) { + const double ya = a.process(phase_at(n)); + const double yb = b.process(phase_at(n)); + if (pa <= 1e-3 && ya > 1e-3) + ea.push_back(n); + if (pb <= 1e-3 && yb > 1e-3) + eb.push_back(n); + pa = ya; + pb = yb; + } + CHECK(ea.size() == 16); + CHECK(eb.size() == 12); +} + +SCENARIO("swing delays the odd steps by swing/2 of a step") { + trigger_row row; + row.prepare(k_sr); + for (auto& s : row.clock().data().steps) + s.velocity = 1.0; + row.clock().set_swing(0.5); + + const auto edges = trigger_edges(row, k_cycle); + const int step_len = k_cycle / 16; + const int late = step_len / 4; // swing 0.5 -> 0.25 step + REQUIRE(edges.size() == 16); + for (int k = 0; k < 16; ++k) { + const int expect = k * step_len + ((k & 1) ? late : 0); + INFO("step " << k << " at " << edges[k] << " expected " << expect); + CHECK(near(edges[k], expect)); + } +} + +SCENARIO("swing 0 is bit-identical to the straight grid") { + trigger_row a, b; + a.prepare(k_sr); + b.prepare(k_sr); + for (auto& s : a.clock().data().steps) + s.velocity = 0.7; + for (auto& s : b.clock().data().steps) + s.velocity = 0.7; + b.clock().set_swing(0.0); + for (int n = 0; n < k_cycle; ++n) + REQUIRE(a.process(phase_at(n)) == b.process(phase_at(n))); +} + +SCENARIO("the trigger row emits velocities as amplitudes and rests as nothing") { + trigger_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + p.steps[0].velocity = taptools::seq::k_trig_plain; + p.steps[4].velocity = taptools::seq::k_trig_accented; + p.steps[8].velocity = 1.0; // full 14 V accent + + int fired = 0; + double prev = 0.0; + for (int n = 0; n < k_cycle; ++n) { + const double y = row.process(phase_at(n)); + if (prev <= 1e-3 && y > 1e-3) { + ++fired; + const int k = n / (k_cycle / 16); + CHECK(y == p.steps[k].velocity); + } + prev = y; + } + CHECK(fired == 3); +} + +SCENARIO("default impulses are single-sample with a re-arming gap between adjacent steps") { + trigger_row row; + row.prepare(k_sr); + row.clock().data().steps[2].velocity = 1.0; + row.clock().data().steps[3].velocity = 1.0; // back to back + + int high = 0, edges = 0; + double prev = 0.0; + for (int n = 0; n < k_cycle; ++n) { + const double y = row.process(phase_at(n)); + if (y > 1e-3) + ++high; + if (prev <= 1e-3 && y > 1e-3) + ++edges; + prev = y; + } + CHECK(high == 2); // one sample each + CHECK(edges == 2); // both edges register downstream +} + +SCENARIO("pulse_ms widens the impulse into a held gate") { + trigger_row row; + row.prepare(k_sr); + row.set_pulse_ms(10.0); + row.clock().data().steps[0].velocity = 0.8; + + int high = 0; + for (int n = 0; n < k_cycle; ++n) + if (row.process(phase_at(n)) > 1e-3) + ++high; + CHECK(near(high, static_cast(0.010 * k_sr), 2)); +} + +SCENARIO("a reversed phase still enters every step") { + engine e; + int entered = 0; + for (int n = 0; n < k_cycle; ++n) { + const double p = 1.0 - phase_at(n); // backwards ramp + if (e.process(p).entered) + ++entered; + } + CHECK(entered >= 16); + CHECK(entered <= 17); // the initial entry may add one +} + +SCENARIO("length changes while running keep indices in range") { + engine e; + for (int n = 0; n < 2 * k_cycle; ++n) { + if (n == k_cycle / 2) + e.data().set_length(12); + const auto t = e.process(phase_at(n)); + REQUIRE(t.index >= 0); + REQUIRE(t.index < e.data().length); + } +} + +SCENARIO("the note row opens at the step start and closes at the gate duty") { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + p.steps[0].gate = true; + p.steps[0].pitch = 45.0; + + const int step_len = k_cycle / 16; + int rise = -1, fall = -1; + double prev = 0.0; + for (int n = 0; n < k_cycle; ++n) { + const auto o = row.process(phase_at(n)); + if (prev <= 1e-3 && o.gate > 1e-3) + rise = n; + if (prev > 1e-3 && o.gate <= 1e-3) + fall = n; + prev = o.gate; + } + CHECK(near(rise, 0)); + CHECK(near(fall, static_cast(step_len * taptools::seq::k_gate_duty), 2)); +} + +SCENARIO("accented steps gate at 2.0, plain at 1.0") { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + p.steps[0].gate = true; + p.steps[2].gate = true; + p.steps[2].accent = true; + + double plain = 0.0, accented = 0.0; + for (int n = 0; n < k_cycle; ++n) { + const auto o = row.process(phase_at(n)); + const int k = n / (k_cycle / 16); + if (k == 0) + plain = std::max(plain, o.gate); + if (k == 2) + accented = std::max(accented, o.gate); + } + CHECK(plain == taptools::seq::k_gate_plain); + CHECK(accented == taptools::seq::k_gate_accent); +} + +SCENARIO("a slide step holds the gate through the boundary while the pitch steps") { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + p.steps[4].gate = true; + p.steps[4].pitch = 33.0; + p.steps[5].gate = true; + p.steps[5].slide = true; + p.steps[5].pitch = 45.0; + + const int step_len = k_cycle / 16; + const int boundary = 5 * step_len; + + int rises = 0, falls = 0; + int pitch_step_at = -1; + double prev_gate = 0.0, prev_pitch = 0.0; + for (int n = 4 * step_len; n < 6 * step_len; ++n) { + const auto o = row.process(phase_at(n)); + if (prev_gate <= 1e-3 && o.gate > 1e-3) + ++rises; + if (prev_gate > 1e-3 && o.gate <= 1e-3) + ++falls; + if (n > 4 * step_len && o.pitch != prev_pitch) + pitch_step_at = n; + prev_gate = o.gate; + prev_pitch = o.pitch; + } + CHECK(rises == 1); // one note-on for the pair: no retrigger + CHECK(falls == 1); // ... closing at step 5's own duty point + CHECK(near(pitch_step_at, boundary)); // the pitch steps exactly at the boundary +} + +SCENARIO("chained slides stay legato from the first note to the last duty point") { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + for (int k = 4; k <= 6; ++k) { + p.steps[k].gate = true; + p.steps[k].pitch = 30.0 + k; + p.steps[k].slide = (k > 4); + } + + int rises = 0; + double prev = 0.0; + for (int n = 0; n < k_cycle; ++n) { + const auto o = row.process(phase_at(n)); + if (prev <= 1e-3 && o.gate > 1e-3) + ++rises; + prev = o.gate; + } + CHECK(rises == 1); +} + +SCENARIO("a slide across the pattern wrap holds the gate through phase 1 -> 0") { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + p.steps[15].gate = true; + p.steps[15].pitch = 40.0; + p.steps[0].gate = true; + p.steps[0].slide = true; + p.steps[0].pitch = 52.0; + + // Second cycle: step 15 must hold into the wrapped step 0 without an edge. + int rises_near_wrap = 0; + bool held = true; + double prev = 0.0; + const int step_len = k_cycle / 16; + for (int n = 0; n < 2 * k_cycle; ++n) { + const auto o = row.process(phase_at(n)); + const bool near_wrap = n > k_cycle - step_len / 2 && n < k_cycle + step_len / 4; + if (near_wrap) { + if (prev <= 1e-3 && o.gate > 1e-3) + ++rises_near_wrap; + if (o.gate <= 1e-3) + held = false; + } + prev = o.gate; + } + CHECK(rises_near_wrap == 0); + CHECK(held); +} + +SCENARIO("a slide flag after a rest is a plain trigger") { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + p.steps[8].gate = true; + p.steps[8].slide = true; // nothing sounding before it + + int rises = 0; + double prev = 0.0; + for (int n = 0; n < k_cycle; ++n) { + const auto o = row.process(phase_at(n)); + if (prev <= 1e-3 && o.gate > 1e-3) + ++rises; + prev = o.gate; + } + CHECK(rises == 1); +} + +SCENARIO("recall quantized to the cycle swaps exactly at the wrap") { + trigger_row row; + row.prepare(k_sr); + auto& e = row.clock(); + for (auto& s : e.data().steps) + s.velocity = 0.25; + e.store(0); + for (auto& s : e.data().steps) + s.velocity = 1.0; + e.store(1); + + // Running pattern is slot 1 (all 1.0); arm slot 0 mid-cycle. + bool armed = false; + double prev = 0.0; + std::vector> edges; + for (int n = 0; n < 2 * k_cycle; ++n) { + if (n == k_cycle / 3 && !armed) { + e.recall(0); + armed = true; + } + const double y = row.process(phase_at(n)); + if (prev <= 1e-3 && y > 1e-3) + edges.emplace_back(n, y); + prev = y; + } + for (const auto& [n, y] : edges) { + INFO("edge at " << n << " amp " << y); + if (n < k_cycle) + CHECK(y == 1.0); // armed but not yet applied + else + CHECK(y == 0.25); // swapped at the wrap + } +} + +SCENARIO("recall quantize now applies immediately") { + engine e; + e.data().steps[0].velocity = 0.5; + e.store(0); + e.data().steps[0].velocity = 1.0; + e.set_quantize(taptools::seq::quantize_now); + e.recall(0); + CHECK(e.data().steps[0].velocity == 0.5); + CHECK(e.armed() == -1); +} + +SCENARIO("two identical runs are bit-exact") { + auto run = [] { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + for (int k = 0; k < 16; k += 2) { + p.steps[k].gate = true; + p.steps[k].pitch = 30.0 + k; + p.steps[k].accent = (k % 4) == 0; + } + row.clock().set_swing(0.61); + std::vector y; + y.reserve(2 * k_cycle); + for (int n = 0; n < 2 * k_cycle; ++n) { + const auto o = row.process(phase_at(n)); + y.push_back(o.gate + o.pitch); + } + return y; + }; + CHECK(run() == run()); +} + +SCENARIO("the note row drives the tb303 voice: slid steps glide, plain steps retrigger") { + note_row row; + row.prepare(k_sr); + auto& p = row.clock().data(); + p.steps[0].gate = true; + p.steps[0].pitch = 33.0; + p.steps[1].gate = true; + p.steps[1].slide = true; + p.steps[1].pitch = 45.0; + p.steps[4].gate = true; + p.steps[4].pitch = 33.0; + + taptools::tb303::voice v; + v.prepare(k_sr); + + // The tap.303~ wrapper loop, verbatim. + double note_ons = 0; + double prev_gate = 0.0; + bool gate_held_at_boundary = false; + double peak = 0.0; + const int step_len = k_cycle / 16; + for (int n = 0; n < k_cycle; ++n) { + const auto o = row.process(phase_at(n)); + if (prev_gate < 1e-3 && o.gate >= 1e-3) { + v.note_on(o.pitch, std::clamp(o.gate - 1.0, 0.0, 1.0)); + ++note_ons; + } + else if (prev_gate >= 1e-3 && o.gate < 1e-3) { + v.note_off(); + } + prev_gate = o.gate; + if (v.gate()) + v.set_pitch(o.pitch); + const double y = v.process(); + REQUIRE(std::isfinite(y)); + peak = std::max(peak, std::abs(y)); + if (n == step_len + 2) // just past the slid boundary + gate_held_at_boundary = v.gate(); + } + CHECK(note_ons == 2); // steps 0 and 4; step 1 arrived legato + CHECK(gate_held_at_boundary); // the voice never saw a note-off at the slide + CHECK(peak > 0.01); +} From c90f93a5ecaa3759e7b439592e4a92cbc4f76c88 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 18 Jul 2026 17:49:37 +0000 Subject: [PATCH 2/7] step_seq.h: expose engine::current_step() for the wrappers' UI outlet Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01JZivyxyBdHYd8sVf8AdUbN --- include/taptools/step_seq.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/include/taptools/step_seq.h b/include/taptools/step_seq.h index 68e43cb..f38d7ab 100644 --- a/include/taptools/step_seq.h +++ b/include/taptools/step_seq.h @@ -149,6 +149,9 @@ namespace taptools { /// its phase lands in (so a transport start fires its downbeat). void reset() { m_prev = -1; } + /// The step the engine is currently in (-1 before any processing) — for UI feedback. + int current_step() const { return m_prev; } + tick process(double phase) { int k = derive(phase); From 3698f9c4aec4ebc7041937a4b158019be95fede6 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 18 Jul 2026 18:03:10 +0000 Subject: [PATCH 3/7] step_seq: clang-format pass (house style gate) Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01JZivyxyBdHYd8sVf8AdUbN --- include/taptools/step_seq.h | 4 ++-- tests/step_seq_test.cpp | 46 ++++++++++++++++++------------------- 2 files changed, 25 insertions(+), 25 deletions(-) diff --git a/include/taptools/step_seq.h b/include/taptools/step_seq.h index f38d7ab..ad023ad 100644 --- a/include/taptools/step_seq.h +++ b/include/taptools/step_seq.h @@ -119,7 +119,7 @@ namespace taptools { pattern& data() { return m_pattern; } const pattern& data() const { return m_pattern; } - void set_swing(double s) { m_swing = std::clamp(s, 0.0, 1.0); } + void set_swing(double s) { m_swing = std::clamp(s, 0.0, 1.0); } double swing() const { return m_swing; } void set_quantize(int m) { m_quantize = std::clamp(m, 0, 2); } @@ -279,7 +279,7 @@ namespace taptools { engine& clock() { return m_engine; } const engine& clock() const { return m_engine; } - void set_transpose(double semitones) { m_transpose = semitones; } + void set_transpose(double semitones) { m_transpose = semitones; } double transpose() const { return m_transpose; } void reset() { diff --git a/tests/step_seq_test.cpp b/tests/step_seq_test.cpp index c897707..7df6e27 100644 --- a/tests/step_seq_test.cpp +++ b/tests/step_seq_test.cpp @@ -126,7 +126,7 @@ SCENARIO("swing 0 is bit-identical to the straight grid") { SCENARIO("the trigger row emits velocities as amplitudes and rests as nothing") { trigger_row row; row.prepare(k_sr); - auto& p = row.clock().data(); + auto& p = row.clock().data(); p.steps[0].velocity = taptools::seq::k_trig_plain; p.steps[4].velocity = taptools::seq::k_trig_accented; p.steps[8].velocity = 1.0; // full 14 V accent @@ -151,7 +151,7 @@ SCENARIO("default impulses are single-sample with a re-arming gap between adjace row.clock().data().steps[2].velocity = 1.0; row.clock().data().steps[3].velocity = 1.0; // back to back - int high = 0, edges = 0; + int high = 0, edges = 0; double prev = 0.0; for (int n = 0; n < k_cycle; ++n) { const double y = row.process(phase_at(n)); @@ -204,9 +204,9 @@ SCENARIO("length changes while running keep indices in range") { SCENARIO("the note row opens at the step start and closes at the gate duty") { note_row row; row.prepare(k_sr); - auto& p = row.clock().data(); - p.steps[0].gate = true; - p.steps[0].pitch = 45.0; + auto& p = row.clock().data(); + p.steps[0].gate = true; + p.steps[0].pitch = 45.0; const int step_len = k_cycle / 16; int rise = -1, fall = -1; @@ -226,9 +226,9 @@ SCENARIO("the note row opens at the step start and closes at the gate duty") { SCENARIO("accented steps gate at 2.0, plain at 1.0") { note_row row; row.prepare(k_sr); - auto& p = row.clock().data(); - p.steps[0].gate = true; - p.steps[2].gate = true; + auto& p = row.clock().data(); + p.steps[0].gate = true; + p.steps[2].gate = true; p.steps[2].accent = true; double plain = 0.0, accented = 0.0; @@ -308,12 +308,12 @@ SCENARIO("a slide across the pattern wrap holds the gate through phase 1 -> 0") p.steps[0].pitch = 52.0; // Second cycle: step 15 must hold into the wrapped step 0 without an edge. - int rises_near_wrap = 0; - bool held = true; - double prev = 0.0; - const int step_len = k_cycle / 16; + int rises_near_wrap = 0; + bool held = true; + double prev = 0.0; + const int step_len = k_cycle / 16; for (int n = 0; n < 2 * k_cycle; ++n) { - const auto o = row.process(phase_at(n)); + const auto o = row.process(phase_at(n)); const bool near_wrap = n > k_cycle - step_len / 2 && n < k_cycle + step_len / 4; if (near_wrap) { if (prev <= 1e-3 && o.gate > 1e-3) @@ -357,8 +357,8 @@ SCENARIO("recall quantized to the cycle swaps exactly at the wrap") { e.store(1); // Running pattern is slot 1 (all 1.0); arm slot 0 mid-cycle. - bool armed = false; - double prev = 0.0; + bool armed = false; + double prev = 0.0; std::vector> edges; for (int n = 0; n < 2 * k_cycle; ++n) { if (n == k_cycle / 3 && !armed) { @@ -415,7 +415,7 @@ SCENARIO("two identical runs are bit-exact") { SCENARIO("the note row drives the tb303 voice: slid steps glide, plain steps retrigger") { note_row row; row.prepare(k_sr); - auto& p = row.clock().data(); + auto& p = row.clock().data(); p.steps[0].gate = true; p.steps[0].pitch = 33.0; p.steps[1].gate = true; @@ -428,11 +428,11 @@ SCENARIO("the note row drives the tb303 voice: slid steps glide, plain steps ret v.prepare(k_sr); // The tap.303~ wrapper loop, verbatim. - double note_ons = 0; - double prev_gate = 0.0; - bool gate_held_at_boundary = false; - double peak = 0.0; - const int step_len = k_cycle / 16; + double note_ons = 0; + double prev_gate = 0.0; + bool gate_held_at_boundary = false; + double peak = 0.0; + const int step_len = k_cycle / 16; for (int n = 0; n < k_cycle; ++n) { const auto o = row.process(phase_at(n)); if (prev_gate < 1e-3 && o.gate >= 1e-3) { @@ -451,7 +451,7 @@ SCENARIO("the note row drives the tb303 voice: slid steps glide, plain steps ret if (n == step_len + 2) // just past the slid boundary gate_held_at_boundary = v.gate(); } - CHECK(note_ons == 2); // steps 0 and 4; step 1 arrived legato - CHECK(gate_held_at_boundary); // the voice never saw a note-off at the slide + CHECK(note_ons == 2); // steps 0 and 4; step 1 arrived legato + CHECK(gate_held_at_boundary); // the voice never saw a note-off at the slide CHECK(peak > 0.01); } From bb1084c110f5c6cef8cc96e4de5a8238304bc22f Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 18 Jul 2026 19:31:16 +0000 Subject: [PATCH 4/7] step_seq notebook: the sequencer verification notebook + C ABI surface MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit notebooks/step_seq.ipynb — executed, asserted, house pattern: the shipping step_seq.h driven through the C ABI. Six sections: the analytic grid (<=1 sample, + polymeter), the swing warp (odd delay = swing/2), the trigger-bus levels (0.01/0.5/1.0 on the 4-14 V mapping, pulse_ms), the 303 line signals (duty 0.5, accent 2.0, gate-hold slide — including the full-step hold on a slide SOURCE step, which the Catch2 suite's isolated step didn't exhibit), four bars of acid + kick rendered from the real tb303_voice.h / tr808_kick.h off one phasor ramp (embedded audio), and cycle-quantized recall swapping exactly at the wrap. C ABI: taptools_seqtrig / taptools_seqnote (rows) and a minimal taptools_kick (with the wrapper's signal-edge trigger logic) added to tools/capi; TriggerRow / NoteRow / Kick ctypes classes in taptools_py.py. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01JZivyxyBdHYd8sVf8AdUbN --- notebooks/step_seq.ipynb | 611 +++++++++++++++++++++++++++++++++++ notebooks/taptools_py.py | 192 ++++++++++- tools/capi/taptools_capi.cpp | 189 +++++++++++ tools/capi/taptools_capi.h | 56 ++++ 4 files changed, 1045 insertions(+), 3 deletions(-) create mode 100644 notebooks/step_seq.ipynb diff --git a/notebooks/step_seq.ipynb b/notebooks/step_seq.ipynb new file mode 100644 index 0000000..641292a --- /dev/null +++ b/notebooks/step_seq.ipynb @@ -0,0 +1,611 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3fb02502", + "metadata": {}, + "source": [ + "# `step_seq.h` — the shared step-sequencer engine, verified\n", + "\n", + "The verification notebook for **`tap.808.seq~` / `tap.303.seq~`** (design of record:\n", + "`plans/tap.seq.md` in the Max package repo, author-approved 2026-07-18). Every cell drives the\n", + "**shipping kernel** — `include/taptools/step_seq.h`, the same header the Max externals compile —\n", + "through the C ABI (`tools/capi`), so nothing here is a Python re-implementation. Sections are\n", + "asserted: a failed claim fails the notebook.\n", + "\n", + "What is pinned here, beyond the Catch2 suite (`tests/step_seq_test.cpp`, 19 scenarios):\n", + "\n", + "1. **The phase-clocked grid** — steps land on the analytic boundaries, sample-accurately; polymeter\n", + " falls out of `length`.\n", + "2. **Swing** — odd steps delayed by exactly swing/2 of a step across the whole range.\n", + "3. **The trigger bus** — amplitude-as-accent impulses at the pinned levels (plain 0.01 = the 4 V\n", + " base, accented 0.5 = accent knob at noon; TR-808 Service Notes 4–14 V mapping via\n", + " `tr808_kick.h`), and `pulse_ms` widening.\n", + "4. **The 303 line signals** — gate duty 0.5 (Open303 `AcidPattern::stepLength`), accent at 2.0,\n", + " and **slide as gate-hold**: no edge across a slid boundary while the pitch steps.\n", + "5. **The pair, audibly** — the acid pattern rendered through the real `tb303_voice.h` via the\n", + " package's wrapper loop, plus a `tr808_kick.h` line clocked from the same phasor ramp.\n", + "6. **Quantized recall** — an armed slot swaps exactly at the cycle wrap." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "573db4ac", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T19:30:27.642649Z", + "iopub.status.busy": "2026-07-18T19:30:27.642352Z", + "iopub.status.idle": "2026-07-18T19:30:28.057761Z", + "shell.execute_reply": "2026-07-18T19:30:28.056501Z" + } + }, + "outputs": [], + "source": [ + "import sys, pathlib\n", + "sys.path.insert(0, str(pathlib.Path.cwd()))\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import Audio, display\n", + "\n", + "import taptools_py as tp\n", + "from taptools_py import PALETTE, TriggerRow, NoteRow, Kick, TB303\n", + "\n", + "SR = 48000.0\n", + "CYCLE_HZ = 2.0 # pattern cycles per second (a 120 BPM bar of 16ths)\n", + "CYCLE = int(SR / CYCLE_HZ) # samples per cycle\n", + "STEP = CYCLE // 16 # samples per 16th at length 16\n", + "plt.rcParams[\"figure.figsize\"] = (10, 3.2)\n", + "plt.rcParams[\"axes.grid\"] = True\n", + "plt.rcParams[\"grid.alpha\"] = 0.25\n", + "\n", + "def edges(y, thresh=1e-3):\n", + " \"\"\"Sample indices where a signal rises from at-or-below thresh to above it.\"\"\"\n", + " y = np.asarray(y)\n", + " rising = (y[1:] > thresh) & (y[:-1] <= thresh)\n", + " idx = np.flatnonzero(rising) + 1\n", + " if y[0] > thresh:\n", + " idx = np.insert(idx, 0, 0)\n", + " return idx" + ] + }, + { + "cell_type": "markdown", + "id": "4adf8712", + "metadata": {}, + "source": [ + "## 1. The phase-clocked grid\n", + "\n", + "The engine derives the current step as `floor(phase × length)` from a phasor~-style ramp and\n", + "fires each sounding step on the sample its boundary crosses. Reference boundaries are computed\n", + "independently from the ramp; the measured trigger edges must land on them within one sample\n", + "(float rounding at the boundary sample is the only slack)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1f0bee12", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T19:30:28.060069Z", + "iopub.status.busy": "2026-07-18T19:30:28.059766Z", + "iopub.status.idle": "2026-07-18T19:30:28.234039Z", + "shell.execute_reply": "2026-07-18T19:30:28.232860Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "32 triggers; max deviation from the analytic grid: 0 sample(s)\n", + "length 12 off the same ramp: 12 triggers per cycle — the triplet pre-scale, generalized\n" + ] + } + ], + "source": [ + "row = TriggerRow(sr=SR)\n", + "row.steps([1.0] * 16)\n", + "y = row.process(row.phase(cycles=2, cycle_hz=CYCLE_HZ))\n", + "measured = edges(y)\n", + "analytic = np.array([round(c * CYCLE + k * CYCLE / 16) for c in range(2) for k in range(16)])\n", + "err = measured - analytic\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.vlines(measured / SR, 0, 1, color=PALETTE[0], label=\"measured triggers\")\n", + "ax.plot(analytic / SR, np.full_like(analytic, 1.02, dtype=float), \"v\", color=PALETTE[2],\n", + " ms=5, label=\"analytic boundaries\")\n", + "ax.set(xlabel=\"time (s)\", ylabel=\"amplitude\", title=\"two cycles, length 16: triggers on the analytic grid\")\n", + "ax.legend(loc=\"center right\")\n", + "plt.show()\n", + "\n", + "print(f\"{len(measured)} triggers; max deviation from the analytic grid: {np.abs(err).max()} sample(s)\")\n", + "assert len(measured) == 32\n", + "assert np.abs(err).max() <= 1\n", + "\n", + "# polymeter: a length-12 row off the SAME ramp\n", + "tri = TriggerRow(sr=SR, length=12)\n", + "tri.steps([1.0] * 12)\n", + "y12 = tri.process(tri.phase(cycles=1, cycle_hz=CYCLE_HZ))\n", + "assert len(edges(y12)) == 12\n", + "print(\"length 12 off the same ramp: 12 triggers per cycle — the triplet pre-scale, generalized\")" + ] + }, + { + "cell_type": "markdown", + "id": "1d345b6b", + "metadata": {}, + "source": [ + "## 2. Swing\n", + "\n", + "Swing 0..1 delays each odd-numbered step's start by up to half a step (0 = straight, 2/3 = the\n", + "classic triplet shuffle, where the off-16th lands at 1/3 of the pair). Beyond-hardware — neither\n", + "machine had swing — so the engine's default is 0, and swing 0 is bit-identical to the straight\n", + "grid (pinned in the Catch2 suite). Here: the measured odd-step delay tracks swing/2 exactly." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "60b2b300", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T19:30:28.236244Z", + "iopub.status.busy": "2026-07-18T19:30:28.236030Z", + "iopub.status.idle": "2026-07-18T19:30:28.421853Z", + "shell.execute_reply": "2026-07-18T19:30:28.420568Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "worst |odd-step delay − swing/2|: 6.67e-04 steps\n" + ] + } + ], + "source": [ + "swings = [0.0, 0.25, 0.5, 2/3, 1.0]\n", + "fig, ax = plt.subplots()\n", + "worst = 0.0\n", + "for i, s in enumerate(swings):\n", + " r = TriggerRow(sr=SR, swing=s)\n", + " r.steps([1.0] * 16)\n", + " e = edges(r.process(r.phase(cycles=1, cycle_hz=CYCLE_HZ)))\n", + " delay = (e - np.arange(16) * CYCLE / 16) / (CYCLE / 16) # in steps\n", + " odd = delay[1::2]\n", + " worst = max(worst, np.abs(odd - s / 2).max())\n", + " ax.plot(np.arange(16), delay, \"o-\", ms=4, color=PALETTE[i], label=f\"swing {s:.2f}\")\n", + "ax.set(xlabel=\"step\", ylabel=\"start delay (steps)\", title=\"odd steps start late by exactly swing/2\")\n", + "ax.legend(ncols=5, loc=\"upper center\")\n", + "plt.show()\n", + "\n", + "print(f\"worst |odd-step delay − swing/2|: {worst:.2e} steps\")\n", + "assert worst < 2 / STEP # within a sample of exact" + ] + }, + { + "cell_type": "markdown", + "id": "69adda42", + "metadata": {}, + "source": [ + "## 3. The trigger bus\n", + "\n", + "The row's impulses are the `tap.808.*` accent-bus contract verbatim: the edge amplitude 0..1\n", + "maps onto the hardware's common 4–14 V trigger bus (`tr808_kick.h` `k_bd_vtrig_min/max`).\n", + "The pinned convenience levels: **plain = 0.01** — the un-accented 4 V base trigger, accent ≈ 0,\n", + "held just above the voices' 1e-3 edge threshold so the edge always registers — and\n", + "**accented = 0.5**, the accent level knob (VR3) at noon; 1.0 is the full 14 V bus. Impulses are\n", + "single-sample by default (every trigger is a clean re-arming edge); `pulse_ms` widens them into\n", + "held gates for envelope consumers." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7296a822", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T19:30:28.423961Z", + "iopub.status.busy": "2026-07-18T19:30:28.423748Z", + "iopub.status.idle": "2026-07-18T19:30:28.653876Z", + "shell.execute_reply": "2026-07-18T19:30:28.652699Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "amplitudes [np.float64(0.01), np.float64(0.5), np.float64(1.0), np.float64(0.5)]; pulse width 10.00 ms\n" + ] + } + ], + "source": [ + "from taptools_py import _LIB # the pinned constants live in the kernel header; mirror them here\n", + "K_PLAIN, K_ACCENTED = 0.01, 0.5\n", + "\n", + "r = TriggerRow(sr=SR)\n", + "r.steps([K_PLAIN, 0, 0, 0, K_ACCENTED, 0, 0, 0, 1.0, 0, 0, 0, K_ACCENTED, 0, 0, 0])\n", + "y = r.process(r.phase(cycles=1, cycle_hz=CYCLE_HZ))\n", + "e = edges(y)\n", + "\n", + "fig, (a1, a2) = plt.subplots(1, 2, width_ratios=[2, 1], figsize=(10, 3.2))\n", + "a1.vlines(e / SR, 0, y[e], color=PALETTE[0])\n", + "for n, v in zip(e, y[e]):\n", + " a1.annotate(f\"{v:g}\", (n / SR, v), textcoords=\"offset points\", xytext=(0, 4), ha=\"center\")\n", + "a1.set(xlabel=\"time (s)\", ylabel=\"amplitude\", ylim=(0, 1.15),\n", + " title=\"one cycle: plain (4 V), accented (VR3 noon), full accent (14 V)\")\n", + "\n", + "r2 = TriggerRow(sr=SR).set(pulse_ms=10.0)\n", + "r2.steps([0.8] + [0] * 15)\n", + "y2 = r2.process(r2.phase(cycles=1, cycle_hz=CYCLE_HZ))\n", + "a2.plot(np.arange(len(y2))[:2 * STEP] / SR * 1000, y2[:2 * STEP], color=PALETTE[3])\n", + "a2.set(xlabel=\"time (ms)\", title=\"pulse_ms 10: a held gate\")\n", + "plt.tight_layout(); plt.show()\n", + "\n", + "assert list(y[e]) == [K_PLAIN, K_ACCENTED, 1.0, K_ACCENTED]\n", + "high = int(np.sum(y2 > 1e-3))\n", + "assert abs(high - 0.010 * SR) <= 2\n", + "print(f\"amplitudes {list(y[e])}; pulse width {high / SR * 1000:.2f} ms\")" + ] + }, + { + "cell_type": "markdown", + "id": "250d9338", + "metadata": {}, + "source": [ + "## 4. The 303 line signals\n", + "\n", + "`note_row` emits exactly the `tap.303~` inlet pair: a pitch signal (MIDI note number, held\n", + "between notes) and a gate at **1.0 plain / 2.0 accented** (the voice reads accent depth =\n", + "amplitude − 1; the accent *amount* stays on the voice's knob, like the hardware). The gate opens\n", + "at the step start and closes at **duty 0.5** of the step — Open303's `AcidPattern`\n", + "(`stepLength = 0.5`), the same reference the voice's calibrated constants came from.\n", + "\n", + "**Slide is gate-hold.** A step with the slide flag is approached legato: the gate does *not*\n", + "fall during the step before it — it holds through the boundary while the pitch steps, and the\n", + "voice's ~60 ms RC glide does the rest. (Package convention: the flag lives on the *target* step,\n", + "matching `tap.303~`'s `note [accent] [slide]` message; the hardware stores it on the\n", + "source note — the data models convert trivially.) The pattern below is the demo line from\n", + "`help/tap.303~-pattern.maxpat`, the phase-3 interface dry run." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ad594950", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T19:30:28.656062Z", + "iopub.status.busy": "2026-07-18T19:30:28.655860Z", + "iopub.status.idle": "2026-07-18T19:30:28.895699Z", + "shell.execute_reply": "2026-07-18T19:30:28.894505Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13 note-ons for 16 gated steps (3 slid); step-3 duty 0.500, slide-source step-1 hold 1.000\n" + ] + } + ], + "source": [ + "PITCHES = [33, 33, 45, 33, 33, 36, 33, 40, 38, 33, 33, 45, 33, 36, 35, 31]\n", + "ACCENTS = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]\n", + "SLIDES = [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0]\n", + "\n", + "line = NoteRow(sr=SR)\n", + "line.steps(list(zip(PITCHES, [1] * 16, ACCENTS, SLIDES)))\n", + "pitch, gate = line.process(line.phase(cycles=1, cycle_hz=CYCLE_HZ))\n", + "t = np.arange(CYCLE) / SR\n", + "\n", + "fig, (a1, a2) = plt.subplots(2, 1, sharex=True, figsize=(10, 4.6))\n", + "a1.plot(t, pitch, color=PALETTE[0], drawstyle=\"steps-post\")\n", + "a1.set(ylabel=\"pitch (MIDI note)\", title=\"the acid line: pitch steps, gate duty, accent levels, gate-hold slide\")\n", + "a2.plot(t, gate, color=PALETTE[1], drawstyle=\"steps-post\")\n", + "for k, s in enumerate(SLIDES):\n", + " if s:\n", + " a2.axvspan((k - 0.5) * STEP / SR, (k + 0.5) * STEP / SR, color=PALETTE[2], alpha=0.18)\n", + "a2.set(xlabel=\"time (s)\", ylabel=\"gate\", yticks=[0, 1, 2])\n", + "a2.text(0.995, 0.92, \"shaded: gate held across a slid boundary\", transform=a2.transAxes,\n", + " ha=\"right\", va=\"top\", color=PALETTE[2])\n", + "plt.tight_layout(); plt.show()\n", + "\n", + "rises = edges(gate)\n", + "falls = np.flatnonzero((gate[1:] <= 1e-3) & (gate[:-1] > 1e-3)) + 1\n", + "n_slides = sum(SLIDES)\n", + "assert len(rises) == 16 - n_slides, \"each slid step must arrive without a new edge\"\n", + "# every slid boundary: gate continuously high, pitch steps exactly there\n", + "for k, s in enumerate(SLIDES):\n", + " if s:\n", + " b = round(k * CYCLE / 16)\n", + " assert gate[b - 8 : b + 8].min() > 0.9\n", + " assert pitch[b - 2] != pitch[b + 2]\n", + "# accent level; duty on step 3 (plain, not followed by a slide); full hold on step 1 (a\n", + "# slide SOURCE: step 2 carries the flag, so step 1's gate must span its whole step)\n", + "assert gate[rises[0]] == 2.0 and ACCENTS[0] == 1\n", + "step3 = gate[3 * STEP : 4 * STEP]\n", + "duty = np.sum(step3 > 1e-3) / STEP\n", + "hold = np.sum(gate[STEP : 2 * STEP] > 1e-3) / STEP\n", + "print(f\"{len(rises)} note-ons for 16 gated steps ({n_slides} slid); \"\n", + " f\"step-3 duty {duty:.3f}, slide-source step-1 hold {hold:.3f}\")\n", + "assert abs(duty - 0.5) < 0.01\n", + "assert hold > 0.999" + ] + }, + { + "cell_type": "markdown", + "id": "56f142cf", + "metadata": {}, + "source": [ + "## 5. The pair, audibly\n", + "\n", + "The row's outputs drive the real voices. The `tap.303~` wrapper loop (edge → `note_on` with\n", + "accent = amplitude − 1, fall → `note_off`, pitch followed while the gate is held) is reproduced\n", + "verbatim on `tb303_voice.h`; a second phasor-locked `trigger_row` feeds `tr808_kick.h` through\n", + "the `tap.808.kick~` wrapper's edge logic (the ABI's `trig` input). One ramp, one rhythm\n", + "section — the plan's headline demo." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c7e85f85", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T19:30:28.897928Z", + "iopub.status.busy": "2026-07-18T19:30:28.897727Z", + "iopub.status.idle": "2026-07-18T19:30:29.680812Z", + "shell.execute_reply": "2026-07-18T19:30:29.679266Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "voice note-ons: 52 (4 bars × 13); kick hits/bar: 4; mix RMS 0.325\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def render_303(pitch, gate, **params):\n", + " \"\"\"The tap.303~ wrapper loop over the row's signals, segmented at the events.\"\"\"\n", + " v = TB303(sr=SR, **params)\n", + " g = gate > 1e-3\n", + " events = np.flatnonzero(g[1:] != g[:-1]) + 1 # gate edges\n", + " events = np.union1d(events, np.flatnonzero(np.diff(pitch) != 0) + 1) # pitch steps (slides)\n", + " events = np.concatenate([[0], events, [len(gate)]])\n", + " out = np.empty(len(gate))\n", + " held = False\n", + " for a, b in zip(events[:-1], events[1:]):\n", + " if g[a] and not held:\n", + " v.note_on(pitch[a], accent=float(np.clip(gate[a] - 1.0, 0.0, 1.0)))\n", + " held = True\n", + " elif not g[a] and held:\n", + " v.note_off()\n", + " held = False\n", + " elif held:\n", + " v.set_pitch(pitch[a]) # held pitch motion = slide (legato, ~60 ms RC)\n", + " out[a:b] = v.process(int(b - a))\n", + " return out\n", + "\n", + "BARS = 4\n", + "ramp = line.phase(cycles=BARS, cycle_hz=CYCLE_HZ)\n", + "pitch, gate = NoteRow(sr=SR).steps(list(zip(PITCHES, [1] * 16, ACCENTS, SLIDES))).process(ramp)\n", + "acid = render_303(pitch, gate, cutoff=500, resonance=0.95, envmod=0.65, decay=300, accent=0.9)\n", + "\n", + "kick_row = TriggerRow(sr=SR)\n", + "kick_row.steps([1.0, 0, 0, 0, 0.6, 0, 0, 0, 0.6, 0, 0, 0, 0.6, 0, 0, 0])\n", + "kick = Kick(sr=SR, decay=0.55).process(trig=kick_row.process(ramp))\n", + "\n", + "mix = 0.85 * acid + 0.9 * kick\n", + "mix /= np.abs(mix).max() * 1.2\n", + "assert np.all(np.isfinite(mix))\n", + "\n", + "fig, (a1, a2) = plt.subplots(2, 1, figsize=(10, 5), sharex=True)\n", + "a1.plot(np.arange(len(mix)) / SR, mix, lw=0.4, color=PALETTE[0])\n", + "a1.set(ylabel=\"amplitude\", title=f\"{BARS} bars: tap.303.seq~ → tap.303~ over tap.808.seq~ → tap.808.kick~, one phasor\")\n", + "a2.specgram(mix, NFFT=1024, Fs=SR, noverlap=768, cmap=\"viridis\", vmin=-120)\n", + "a2.set(xlabel=\"time (s)\", ylabel=\"Hz\", ylim=(0, 5000))\n", + "plt.tight_layout(); plt.show()\n", + "\n", + "onsets_303 = len(edges(gate))\n", + "onsets_kick = len(edges(kick_row.process(kick_row.phase(cycles=1, cycle_hz=CYCLE_HZ))))\n", + "print(f\"voice note-ons: {onsets_303} ({BARS} bars × 13); kick hits/bar: {onsets_kick}; \"\n", + " f\"mix RMS {np.sqrt(np.mean(mix**2)):.3f}\")\n", + "assert onsets_303 == BARS * (16 - sum(SLIDES))\n", + "assert onsets_kick == 4\n", + "assert np.sqrt(np.mean(mix**2)) > 0.05\n", + "display(Audio(mix, rate=int(SR)))" + ] + }, + { + "cell_type": "markdown", + "id": "02e8cdad", + "metadata": {}, + "source": [ + "## 6. Quantized recall\n", + "\n", + "Patterns live in 16 slots; `recall` arms and the swap applies at the quantize boundary —\n", + "`cycle` by default, which is the TR-808's A/B-half and basic/fill switching as one message.\n", + "Armed mid-cycle, the running pattern must finish its bar; the first trigger of the next cycle\n", + "carries the recalled pattern's amplitudes, and the swap lands exactly on the wrap sample." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b5536412", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-18T19:30:29.684257Z", + "iopub.status.busy": "2026-07-18T19:30:29.684042Z", + "iopub.status.idle": "2026-07-18T19:30:29.808266Z", + "shell.execute_reply": "2026-07-18T19:30:29.806990Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cycle 1 stayed at 1.0 after arming; cycle 2 swapped to 0.25 on its first sample\n" + ] + } + ], + "source": [ + "r = TriggerRow(sr=SR)\n", + "r.steps([0.25] * 16); r.store(0)\n", + "r.steps([1.0] * 16); r.store(1)\n", + "\n", + "ramp2 = r.phase(cycles=2, cycle_hz=CYCLE_HZ)\n", + "out = np.empty(len(ramp2))\n", + "armed_at = CYCLE // 3\n", + "out[:armed_at] = r.process(ramp2[:armed_at])\n", + "r.recall(0) # armed mid-cycle...\n", + "out[armed_at:] = r.process(ramp2[armed_at:])\n", + "e = edges(out)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.vlines(e / SR, 0, out[e], color=PALETTE[0])\n", + "ax.axvline(armed_at / SR, color=PALETTE[2], ls=\"--\", label=\"recall 0 armed\")\n", + "ax.axvline(CYCLE / SR, color=PALETTE[4], ls=\"--\", label=\"cycle boundary: swap\")\n", + "ax.set(xlabel=\"time (s)\", ylabel=\"amplitude\", title=\"quantize cycle: the armed pattern takes over at the wrap\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "first, second = out[e[e < CYCLE]], out[e[e >= CYCLE]]\n", + "assert np.all(first == 1.0) and np.all(second == 0.25)\n", + "print(f\"cycle 1 stayed at 1.0 after arming; cycle 2 swapped to 0.25 on its first sample\")" + ] + }, + { + "cell_type": "markdown", + "id": "28a13efd", + "metadata": {}, + "source": [ + "## Summary — pinned\n", + "\n", + "| Claim | Result |\n", + "|---|---|\n", + "| Step boundaries on the analytic grid | ≤ 1 sample deviation, 32/32 triggers |\n", + "| Polymeter off one ramp | length 12 + 16 rows coexist, per-cycle counts exact |\n", + "| Swing warp | odd-step delay = swing/2 to sub-sample accuracy, swing 0 = straight |\n", + "| Trigger levels | plain 0.01 / accented 0.5 / full 1.0 emitted exactly |\n", + "| `pulse_ms` | 10 ms request → 10 ms gate (±2 samples) |\n", + "| Gate duty | 0.5 of the step (Open303 `AcidPattern::stepLength`) |\n", + "| Accent gates | 2.0 vs 1.0, read by the voice as depth = amplitude − 1 |\n", + "| Slide | gate held across every slid boundary; 13 note-ons for 16 gated steps with 3 slides |\n", + "| The pair | 4 bars of acid + kick rendered from the shipping voices, one phasor ramp |\n", + "| Quantized recall | armed slot swaps exactly at the cycle wrap |\n", + "\n", + "Remaining beyond this notebook: runtime validation in Max (the `*.maxtest.maxpat` starters +\n", + "help patchers, on a licensed install), per the package-wide gate." + ] + } + ], + "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/notebooks/taptools_py.py b/notebooks/taptools_py.py index c906c65..2304d45 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -10,9 +10,11 @@ The C ABI (kernel/tools/capi/) wraps the *same* portable DSP headers the Max externals compile — so the notebooks exercise the real shipping code, not a Python re-implementation. Exposed kernels: tap.convolve~'s conv_engine -(`Convolver`), tap.svf~ (`Svf`), tap.ladder~ (`Ladder`), tap.vco~ (`Vco`), -and tap.autowah~ (`Wah`). Parameter names on the kernel classes mirror each -kernel header's param_index enum. +(`Convolver`), tap.svf~ (`Svf`), tap.ladder~ (`Ladder`), tap.diode~ +(`Diode`), tap.303~ (`TB303`), tap.vco~ (`Vco`), tap.autowah~ (`Wah`), the +step-sequencer rows behind tap.808.seq~ / tap.303.seq~ (`TriggerRow`, +`NoteRow`), and tap.808.kick~ (`Kick`). Parameter names on the kernel +classes mirror each kernel header's param_index enum. Copyright 2003-2026 Timothy Place. New BSD License. """ @@ -144,6 +146,40 @@ def load() -> ctypes.CDLL: "taptools_wah_recall": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), "taptools_wah_clear": ([vp], ctypes.c_int), "taptools_wah_process": ([vp, f64p, f64p, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_seqtrig_create": ([], vp), + "taptools_seqtrig_destroy": ([vp], None), + "taptools_seqtrig_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_seqtrig_set_length": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqtrig_set_swing": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_seqtrig_set_quantize": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqtrig_set_pulse_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_seqtrig_set_step": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_seqtrig_store": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqtrig_recall": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqtrig_reset": ([vp], ctypes.c_int), + "taptools_seqtrig_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_seqnote_create": ([], vp), + "taptools_seqnote_destroy": ([vp], None), + "taptools_seqnote_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_seqnote_set_length": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqnote_set_swing": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_seqnote_set_quantize": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqnote_set_transpose": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_seqnote_set_step": ([vp, ctypes.c_int, ctypes.c_double, ctypes.c_int, ctypes.c_int, + ctypes.c_int], ctypes.c_int), + "taptools_seqnote_store": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqnote_recall": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_seqnote_reset": ([vp], ctypes.c_int), + "taptools_seqnote_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_kick_create": ([], vp), + "taptools_kick_destroy": ([vp], None), + "taptools_kick_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_kick_set_decay": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_kick_set_tone": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_kick_set_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_kick_trigger": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_kick_reset": ([vp], ctypes.c_int), + "taptools_kick_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), } for name, (argtypes, restype) in sigs.items(): fn = getattr(lib, name) @@ -481,3 +517,153 @@ def recall(self, slot: int, seconds: float = 0.0) -> "Wah": """Morph to a preset slot (0-based; 0-3 = factory guitar/bass/swell/cocked).""" _check(_LIB.taptools_wah_recall(self._h, int(slot), float(seconds)), "recall") return self + + +class _SeqRow: + """Base for the step-sequencer rows (the step_seq.h engine behind tap.808.seq~ / + tap.303.seq~): a live C-ABI handle plus the shared clock surface. `phase(cycles)` builds + the phasor~-style ramp the rows are clocked from.""" + + PREFIX: str = "" + CYCLE, STEP, NOW = 0, 1, 2 # quantize modes + + def __init__(self, sr: float = 48000.0, length: int = 16, swing: float = 0.0): + self._c = {name: getattr(_LIB, f"{self.PREFIX}_{name}") + for name in ("create", "destroy", "prepare", "set_length", "set_swing", + "set_quantize", "store", "recall", "reset")} + self._h = self._c["create"]() + if not self._h: + raise RuntimeError(f"{self.PREFIX}_create failed") + _check(self._c["prepare"](self._h, float(sr)), "prepare") + self.sr = float(sr) + self.length = int(length) + _check(self._c["set_length"](self._h, int(length)), "set_length") + _check(self._c["set_swing"](self._h, float(swing)), "set_swing") + + def set(self, *, length=None, swing=None, quantize=None) -> "_SeqRow": + if length is not None: + self.length = int(length) + _check(self._c["set_length"](self._h, int(length)), "set_length") + if swing is not None: + _check(self._c["set_swing"](self._h, float(swing)), "set_swing") + if quantize is not None: + _check(self._c["set_quantize"](self._h, int(quantize)), "set_quantize") + return self + + def store(self, slot: int) -> None: + _check(self._c["store"](self._h, int(slot)), "store") + + def recall(self, slot: int) -> None: + _check(self._c["recall"](self._h, int(slot)), "recall") + + def reset(self) -> None: + _check(self._c["reset"](self._h), "reset") + + def phase(self, cycles: float, cycle_hz: float = 2.0) -> np.ndarray: + """A phasor~-style ramp: `cycles` pattern cycles at `cycle_hz` cycles/second.""" + n = int(round(cycles * self.sr / cycle_hz)) + return (np.arange(n) * (cycle_hz / self.sr)) % 1.0 + + def __del__(self): + h = getattr(self, "_h", None) + if h: + self._c["destroy"](h) + self._h = None + + +class TriggerRow(_SeqRow): + """One tap.808.seq~ drum row: velocities in, amplitude-as-accent impulses out. + + >>> row = TriggerRow() + >>> row.steps([1.0, 0, 0, 0, 0.5, 0, 0, 0] * 2) + >>> y = row.process(row.phase(cycles=2)) + """ + + PREFIX = "taptools_seqtrig" + + def steps(self, velocities) -> "TriggerRow": + for k, v in enumerate(velocities): + _check(_LIB.taptools_seqtrig_set_step(self._h, k, float(v)), "set_step") + return self + + def set(self, *, pulse_ms=None, **kw) -> "TriggerRow": + if pulse_ms is not None: + _check(_LIB.taptools_seqtrig_set_pulse_ms(self._h, float(pulse_ms)), "set_pulse_ms") + super().set(**kw) + return self + + def process(self, phase) -> np.ndarray: + phase = _f64(phase) + out = np.empty(len(phase)) + _check(_LIB.taptools_seqtrig_process(self._h, _p64(phase), _p64(out), len(phase)), "process") + return out + + +class NoteRow(_SeqRow): + """One tap.303.seq~ line: per-step pitch/gate/accent/slide in, the tap.303~ inlet pair out. + + >>> row = NoteRow() + >>> row.steps([(33, 1, 1, 0), (33, 1, 0, 0), (45, 1, 0, 1), ...]) # (pitch, gate, accent, slide) + >>> pitch, gate = row.process(row.phase(cycles=2)) + """ + + PREFIX = "taptools_seqnote" + + def steps(self, steps) -> "NoteRow": + for k, s in enumerate(steps): + pitch, gate, accent, slide = s + _check(_LIB.taptools_seqnote_set_step(self._h, k, float(pitch), int(gate), int(accent), + int(slide)), "set_step") + return self + + def set(self, *, transpose=None, **kw) -> "NoteRow": + if transpose is not None: + _check(_LIB.taptools_seqnote_set_transpose(self._h, float(transpose)), "set_transpose") + super().set(**kw) + return self + + def process(self, phase) -> tuple[np.ndarray, np.ndarray]: + phase = _f64(phase) + pitch = np.empty(len(phase)) + gate = np.empty(len(phase)) + _check(_LIB.taptools_seqnote_process(self._h, _p64(phase), _p64(pitch), _p64(gate), + len(phase)), "process") + return pitch, gate + + +class Kick: + """The tap.808.kick~ voice (tr808_kick.h) with the wrapper's signal-edge trigger logic — + wire a TriggerRow's output straight into `process(trig=...)`.""" + + def __init__(self, sr: float = 48000.0, decay: float = 0.5, tone: float = 0.5, + level: float = 1.0): + self._h = _LIB.taptools_kick_create() + if not self._h: + raise RuntimeError("taptools_kick_create failed") + _check(_LIB.taptools_kick_prepare(self._h, float(sr)), "prepare") + self.sr = float(sr) + self.set(decay=decay, tone=tone, level=level) + + def set(self, *, decay=None, tone=None, level=None) -> "Kick": + for name, v in (("decay", decay), ("tone", tone), ("level", level)): + if v is not None: + _check(getattr(_LIB, f"taptools_kick_set_{name}")(self._h, float(v)), name) + return self + + def trigger(self, accent: float = 1.0) -> None: + _check(_LIB.taptools_kick_trigger(self._h, float(accent)), "trigger") + + def process(self, n: int | None = None, trig=None) -> np.ndarray: + if trig is not None: + trig = _f64(trig) + n = len(trig) + out = np.empty(int(n)) + _check(_LIB.taptools_kick_process(self._h, _p64(trig) if trig is not None else None, + _p64(out), int(n)), "process") + return out + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_kick_destroy(h) + self._h = None diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 4560713..091ad99 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -10,8 +10,10 @@ #include #include #include +#include #include #include +#include #include using taptools::conv_engine; @@ -444,4 +446,191 @@ int taptools_wah_process(taptools_wah h, const double* in, const double* key, do }); } +// ---- tap.808.seq~ ------------------------------------------------------------------------------ + +using seq_trigger = taptools::seq::trigger_row; + +taptools_seqtrig taptools_seqtrig_create(void) { + return static_cast(new seq_trigger()); +} + +void taptools_seqtrig_destroy(taptools_seqtrig h) { + delete static_cast(h); +} + +int taptools_seqtrig_prepare(taptools_seqtrig h, double sr) { + return with(h, [&](seq_trigger& r) { r.prepare(sr); }); +} + +int taptools_seqtrig_set_length(taptools_seqtrig h, int steps) { + return with(h, [&](seq_trigger& r) { r.clock().data().set_length(steps); }); +} + +int taptools_seqtrig_set_swing(taptools_seqtrig h, double swing) { + return with(h, [&](seq_trigger& r) { r.clock().set_swing(swing); }); +} + +int taptools_seqtrig_set_quantize(taptools_seqtrig h, int mode) { + return with(h, [&](seq_trigger& r) { r.clock().set_quantize(mode); }); +} + +int taptools_seqtrig_set_pulse_ms(taptools_seqtrig h, double ms) { + return with(h, [&](seq_trigger& r) { r.set_pulse_ms(ms); }); +} + +int taptools_seqtrig_set_step(taptools_seqtrig h, int step, double velocity) { + if (step < 0 || step >= taptools::seq::k_max_steps) { + return -1; + } + return with(h, [&](seq_trigger& r) { r.clock().data().steps[step].velocity = velocity; }); +} + +int taptools_seqtrig_store(taptools_seqtrig h, int slot) { + return with(h, [&](seq_trigger& r) { r.clock().store(slot); }); +} + +int taptools_seqtrig_recall(taptools_seqtrig h, int slot) { + return with(h, [&](seq_trigger& r) { r.clock().recall(slot); }); +} + +int taptools_seqtrig_reset(taptools_seqtrig h) { + return with(h, [&](seq_trigger& r) { r.reset(); }); +} + +int taptools_seqtrig_process(taptools_seqtrig h, const double* phase, double* out, int n) { + if (!phase || !out || n < 0) { + return -1; + } + return with(h, [&](seq_trigger& r) { + for (int i = 0; i < n; ++i) { + out[i] = r.process(phase[i]); + } + }); +} + +// ---- tap.303.seq~ ------------------------------------------------------------------------------ + +using seq_note = taptools::seq::note_row; + +taptools_seqnote taptools_seqnote_create(void) { + return static_cast(new seq_note()); +} + +void taptools_seqnote_destroy(taptools_seqnote h) { + delete static_cast(h); +} + +int taptools_seqnote_prepare(taptools_seqnote h, double sr) { + return with(h, [&](seq_note& r) { r.prepare(sr); }); +} + +int taptools_seqnote_set_length(taptools_seqnote h, int steps) { + return with(h, [&](seq_note& r) { r.clock().data().set_length(steps); }); +} + +int taptools_seqnote_set_swing(taptools_seqnote h, double swing) { + return with(h, [&](seq_note& r) { r.clock().set_swing(swing); }); +} + +int taptools_seqnote_set_quantize(taptools_seqnote h, int mode) { + return with(h, [&](seq_note& r) { r.clock().set_quantize(mode); }); +} + +int taptools_seqnote_set_transpose(taptools_seqnote h, double semitones) { + return with(h, [&](seq_note& r) { r.set_transpose(semitones); }); +} + +int taptools_seqnote_set_step(taptools_seqnote h, int step, double pitch, int gate, int accent, int slide) { + if (step < 0 || step >= taptools::seq::k_max_steps) { + return -1; + } + return with(h, [&](seq_note& r) { + auto& st = r.clock().data().steps[step]; + st.pitch = pitch; + st.gate = gate != 0; + st.accent = accent != 0; + st.slide = slide != 0; + }); +} + +int taptools_seqnote_store(taptools_seqnote h, int slot) { + return with(h, [&](seq_note& r) { r.clock().store(slot); }); +} + +int taptools_seqnote_recall(taptools_seqnote h, int slot) { + return with(h, [&](seq_note& r) { r.clock().recall(slot); }); +} + +int taptools_seqnote_reset(taptools_seqnote h) { + return with(h, [&](seq_note& r) { r.reset(); }); +} + +int taptools_seqnote_process(taptools_seqnote h, const double* phase, double* pitch_out, double* gate_out, int n) { + if (!phase || !pitch_out || !gate_out || n < 0) { + return -1; + } + return with(h, [&](seq_note& r) { + for (int i = 0; i < n; ++i) { + const auto o = r.process(phase[i]); + pitch_out[i] = o.pitch; + gate_out[i] = o.gate; + } + }); +} + +// ---- tap.808.kick~ ----------------------------------------------------------------------------- + +using tr808_kick = taptools::tr808::kick; + +taptools_kick taptools_kick_create(void) { + return static_cast(new tr808_kick()); +} + +void taptools_kick_destroy(taptools_kick h) { + delete static_cast(h); +} + +int taptools_kick_prepare(taptools_kick h, double sr) { + return with(h, [&](tr808_kick& k) { k.prepare(sr); }); +} + +int taptools_kick_set_decay(taptools_kick h, double v) { + return with(h, [&](tr808_kick& k) { k.set_decay(v); }); +} + +int taptools_kick_set_tone(taptools_kick h, double v) { + return with(h, [&](tr808_kick& k) { k.set_tone(v); }); +} + +int taptools_kick_set_level(taptools_kick h, double v) { + return with(h, [&](tr808_kick& k) { k.set_level(v); }); +} + +int taptools_kick_trigger(taptools_kick h, double accent) { + return with(h, [&](tr808_kick& k) { k.trigger(accent); }); +} + +int taptools_kick_reset(taptools_kick h) { + return with(h, [&](tr808_kick& k) { k.reset(); }); +} + +int taptools_kick_process(taptools_kick h, const double* trig, double* out, int n) { + if (!out || n < 0) { + return -1; + } + return with(h, [&](tr808_kick& k) { + double prev = 0.0; + for (int i = 0; i < n; ++i) { + if (trig) { + const double x = trig[i]; + if (x > 1e-3 && prev <= 1e-3) { + k.trigger(x < 0.0 ? 0.0 : (x > 1.0 ? 1.0 : x)); + } + prev = x; + } + out[i] = k.process(); + } + }); +} + } // extern "C" diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index ae3d551..d30d442 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -163,6 +163,62 @@ TAPTOOLS_API int taptools_wah_clear(taptools_wah h); TAPTOOLS_API int taptools_wah_process(taptools_wah h, const double* in, const double* key, double* out, double* env_out, double* cutoff_out, int n); +// ---- tap.808.seq~ (taptools::seq::trigger_row) ------------------------------------------------- + +typedef void* taptools_seqtrig; + +TAPTOOLS_API taptools_seqtrig taptools_seqtrig_create(void); +TAPTOOLS_API void taptools_seqtrig_destroy(taptools_seqtrig h); +TAPTOOLS_API int taptools_seqtrig_prepare(taptools_seqtrig h, double sr); +TAPTOOLS_API int taptools_seqtrig_set_length(taptools_seqtrig h, int steps); +TAPTOOLS_API int taptools_seqtrig_set_swing(taptools_seqtrig h, double swing); +TAPTOOLS_API int taptools_seqtrig_set_quantize(taptools_seqtrig h, int mode); // seq::quantize_mode +TAPTOOLS_API int taptools_seqtrig_set_pulse_ms(taptools_seqtrig h, double ms); +/// Set one step's velocity (0 = rest); `step` is 0-based. +TAPTOOLS_API int taptools_seqtrig_set_step(taptools_seqtrig h, int step, double velocity); +TAPTOOLS_API int taptools_seqtrig_store(taptools_seqtrig h, int slot); +TAPTOOLS_API int taptools_seqtrig_recall(taptools_seqtrig h, int slot); +TAPTOOLS_API int taptools_seqtrig_reset(taptools_seqtrig h); +/// Run n samples of the phase ramp through the row; impulses land in `out`. +TAPTOOLS_API int taptools_seqtrig_process(taptools_seqtrig h, const double* phase, double* out, int n); + +// ---- tap.303.seq~ (taptools::seq::note_row) ---------------------------------------------------- + +typedef void* taptools_seqnote; + +TAPTOOLS_API taptools_seqnote taptools_seqnote_create(void); +TAPTOOLS_API void taptools_seqnote_destroy(taptools_seqnote h); +TAPTOOLS_API int taptools_seqnote_prepare(taptools_seqnote h, double sr); +TAPTOOLS_API int taptools_seqnote_set_length(taptools_seqnote h, int steps); +TAPTOOLS_API int taptools_seqnote_set_swing(taptools_seqnote h, double swing); +TAPTOOLS_API int taptools_seqnote_set_quantize(taptools_seqnote h, int mode); // seq::quantize_mode +TAPTOOLS_API int taptools_seqnote_set_transpose(taptools_seqnote h, double semitones); +/// Set one step (0-based): pitch as MIDI note, gate/accent/slide as 0/1 flags. +TAPTOOLS_API int taptools_seqnote_set_step(taptools_seqnote h, int step, double pitch, int gate, int accent, int slide); +TAPTOOLS_API int taptools_seqnote_store(taptools_seqnote h, int slot); +TAPTOOLS_API int taptools_seqnote_recall(taptools_seqnote h, int slot); +TAPTOOLS_API int taptools_seqnote_reset(taptools_seqnote h); +/// Run n samples of the phase ramp through the row; the tap.303~ inlet pair lands in +/// `pitch_out` (MIDI note) and `gate_out` (0 / 1.0 plain / 2.0 accented). +TAPTOOLS_API int taptools_seqnote_process(taptools_seqnote h, const double* phase, double* pitch_out, double* gate_out, + int n); + +// ---- tap.808.kick~ (taptools::tr808::kick) ----------------------------------------------------- + +typedef void* taptools_kick; + +TAPTOOLS_API taptools_kick taptools_kick_create(void); +TAPTOOLS_API void taptools_kick_destroy(taptools_kick h); +TAPTOOLS_API int taptools_kick_prepare(taptools_kick h, double sr); +TAPTOOLS_API int taptools_kick_set_decay(taptools_kick h, double v); // 0..1 (panel VR6) +TAPTOOLS_API int taptools_kick_set_tone(taptools_kick h, double v); // 0..1 (panel VR5) +TAPTOOLS_API int taptools_kick_set_level(taptools_kick h, double v); // 0..1 (panel VR4) +TAPTOOLS_API int taptools_kick_trigger(taptools_kick h, double accent); // 0..1 -> the 4-14 V bus +TAPTOOLS_API int taptools_kick_reset(taptools_kick h); +/// Process n samples; `trig` may be NULL (free-run) or a signal whose rising edges above 1e-3 +/// fire the voice with the edge value as accent — exactly the tap.808.kick~ wrapper's edge logic. +TAPTOOLS_API int taptools_kick_process(taptools_kick h, const double* trig, double* out, int n); + #ifdef __cplusplus } #endif From b4e6b92c428e55518d7dd57d256610721ffd199d Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 18 Jul 2026 19:43:24 +0000 Subject: [PATCH 5/7] =?UTF-8?q?book:=20Part=20V=20=E2=80=94=20The=20rhythm?= =?UTF-8?q?=20section=20(the=20acid=20machine,=20the=20drum=20machine)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two field-guide chapters for the Roland recreations, in the house voice and with every number sourced from the executed notebooks or the kernel suite: acid.md (tap.diode~ / tap.303~ / tap.303.seq~ — the Stinchcombe 0.028 dB match, the never-self-oscillates trait, the measured envmod law and knob travels, the x1.94 wow, the warm VCA's 5.4%/11.5% envelope- tracking distortion, slide as gate-hold, the 13-note-ons measurement) and drums.md (the eight tap.808.* channels — the kick's two distinct attack/ sigh mechanisms and 2.4% calibration, the metal bank's ~20% unit spread as seed/tolerance, the hardware choke, the per-knob-cell calibration pass and its honest lesson, and the tap.808.seq~ row with the pinned bus levels). The machine deep-dives move to Part VI; introduction updated. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01JZivyxyBdHYd8sVf8AdUbN --- book/src/SUMMARY.md | 7 +- book/src/acid.md | 160 +++++++++++++++++++++++++++++++++++++++ book/src/drums.md | 145 +++++++++++++++++++++++++++++++++++ book/src/introduction.md | 6 +- 4 files changed, 316 insertions(+), 2 deletions(-) create mode 100644 book/src/acid.md create mode 100644 book/src/drums.md diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index 7f58bb7..e6cdf09 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -24,7 +24,12 @@ - [A gate for every bin](nr.md) - [The spectrum, re-plumbed](spectra.md) -# Part V — The machine, file by file +# Part V — The rhythm section + +- [The acid machine](acid.md) +- [The drum machine](drums.md) + +# Part VI — The machine, file by file - [Solving the filter on paper: svf.h](machine/svf.md) - [The nonlinear loop: ladder.h](machine/ladder.md) diff --git a/book/src/acid.md b/book/src/acid.md new file mode 100644 index 0000000..a062e7f --- /dev/null +++ b/book/src/acid.md @@ -0,0 +1,160 @@ +# The acid machine + +The Roland TB-303 was designed to imitate a bass guitar, failed completely, +and accidentally defined thirty years of dance music. What makes it +unmistakable is not any one block — a saw into a lowpass is every synth ever +made — but the *coupling*: accent drives the filter and the amplifier through +shared circuitry with memory across notes, slide is a gate that refuses to +let go, and the envelopes are fixed RC discharge curves with exactly one knob +between them. `tap.303~` is a circuit-informed model of that whole tangle; +`tap.diode~` is its filter as a standalone object; `tap.303.seq~` is the +other half of the instrument. This chapter is what each control trades, and +what the measurements say the model actually delivers. + +Companion material: the reference pages and help patchers in the TapTools-Max +package, and two executed verification notebooks — +[`tb303.ipynb`](https://github.com/tap/TapTools/blob/main/notebooks/tb303.ipynb) +for the voice and +[`step_seq.ipynb`](https://github.com/tap/TapTools/blob/main/notebooks/step_seq.ipynb) +for the sequencer — every number below is a measurement from one of them or +from the kernel test suite. Provenance runs through Tim Stinchcombe's filter +analysis, Robin Whittle's Devil Fish documentation, the x0xb0x schematics, +and Robin Schmidt's Open303, whose measured calibrations several constants +adopt verbatim. + +## What the hardware is, in one paragraph + +One saw-core oscillator (the "square" is the saw through a transistor +shaper, not a clean pulse), into a four-stage **diode**-ladder filter — not +the Moog transistor ladder; the diode ladder's stages load each other, which +is why its resonance is broader, less pure, and entirely its own — then a +one-transistor amplifier. Two envelopes, both decay-only RC discharges: the +Main Envelope sweeps the cutoff (the `envmod` knob decides how much), the +VCA envelope is fixed. Accent makes the Main Envelope hotter *and* faster, +routes it into the VCA, and charges a capacitor (C13) through the resonance +pot — and because C13 doesn't fully discharge between closely spaced accents, +**runs of accented notes bloom**, the famous wow. Slide holds the gate across +the step boundary while the pitch CV glides through a ~60 ms RC. Everything +about a note — pitch, gate, accent, slide — comes from the sequencer, not +the panel. That is why this is three objects, not one. + +## The filter first: `tap.diode~` + +The panel says "18 dB/oct"; the circuit is four poles whose asymptotic slope +is 24 dB/oct with a shallower region near cutoff — Stinchcombe untangled +this, and the kernel reproduces his published transfer function to +**0.028 dB**. Two behaviors are load-bearing and easy to get wrong: + +- **The resonance feedback runs through a 150 Hz high-pass**, so resonance + thins as the cutoff drops — low notes squelch, they don't ring. Pinned by + test: the ring-down Q falls with cutoff. +- **A stock 303 never quite self-oscillates**, and neither does this filter + at stock settings. That emerged from the modeled feedback high-pass rather + than being programmed in, and it's documented as a trait, not a defect. + (Push `resonance` past 1.0 — the bend range runs to 1.5 — and it will sing + for you anyway.) + +Like `tap.ladder~` it has a `solver` choice: `fast` (default) or `exact` +Newton iteration on the true nonlinear loop. Measured across a matrix out to +resonance 1.4 and +24 dB drive — beyond anything the hardware can reach — +the two differ by at most **−44.9 dBr**, at 1.6–3.3× the CPU. The exact +solver is there for the suspicious; the fast one is there for the patch. +`oversample` (1/2/4, default 2) and a signal-rate cutoff in the right inlet +round out the `tap.ladder~` surface. + +## The voice: `tap.303~`, knob by knob + +The attributes mirror the seven-knob panel; the calibrations are Open303's +measured laws. + +- **`waveform`** — `saw` or `square`. The square is the hardware's shaped + saw: `−tanh(10^(36.9/20)·saw + 4.37)`, Open303's measured constants + verbatim — rounded and notched, audibly not a 50 % pulse. +- **`cutoff`** — the knob in Hz. Stock travel is the measured 302–2394 Hz; + the attribute range (100–5000) is a flagged bend beyond the panel. +- **`resonance`** — 0..1 is stock; up to 1.5 is the bend. +- **`envmod`** — how much Main Envelope reaches the cutoff, with the + hardware's measured law: 2/3 of the sweep goes above the knob position, + 1/3 below, and the "gimmick" offset shifts the resting point down as you + turn it up. The knobs *feel* right because the interaction is modeled, not + just the ranges. +- **`decay`** — Main Envelope decay, 200 ms–2 s. On an accented note the + hardware ignores this knob and runs at ~200 ms; so does the model + (adjustable via the `accdecay` bend, 50–2000 ms). +- **`accent`** — how hard accented notes hit: louder *and* punchier (the + envelope routing), and quackier (the C13 sweep, scaled by the resonance + knob). The wow is measured: over a run of closely spaced accents the + cutoff peak builds by **×1.94**, and decays back within ×0.998 once the + accents stop. Consecutive accents at high resonance are the entire genre. +- **`tuning`**, **`gain`** — cents and dB. Plumbing. + +The envelopes carry the schematic's fixed interrelations: MEG attack ~3 ms, +VCA attack ~0 with a ~1.23 s decay chopped at gate-off, 50 ms when accented. +None of these have knobs on the hardware, so none of them have knobs here — +except through the documented Devil-Fish-style bends (`slide` 10–500 ms, +`attack` 0.3–30 ms, `accdecay`, and `drive` ±24 dB into the ladder, where +the diodes compress: +24 dB of gain buys only 9.2× of RMS). All stock at +their defaults. + +Phase 2 added **`vca clean|warm`**: the one-transistor class-A stage as a +slope-normalized biased saturator, in the hardware's signal order. The +distortion tracks the envelope — measured 5.4 % difference signal on quiet +notes, 11.5 % on hot accents — so `warm` thickens exactly where the hardware +does. `clean` (default) is bit-identical to phase 1. + +House machinery throughout: `seed`/`tolerance` per-unit component spread (an +`mc.` stack of 303s with different seeds detunes and drifts like a wall of +real units), 16 preset-morph slots with factory acid in 1–8 +(squelch, sub, screamer, rubber, knock, bloom, overdriven, glass), and +per-sample ramps on every parameter. + +## The note interface, and why slide is free + +`tap.303~` is TapTools' first pitched instrument, and its inlets are the +package-wide melodic contract: **pitch as a MIDI note number signal** in the +left inlet, **gate with amplitude-as-accent** in the right — 1.0 is a plain +note, 2.0 fully accented (depth = amplitude − 1). Slide needs no input at +all: *a pitch change while the gate is held is a slide* — legato, no +envelope retrigger, the ~60 ms RC glide — which is exactly the hardware's +own definition. A `note [accent] [slide]` message covers patching +without signals. + +## The other half: `tap.303.seq~` + +Half the 303's sound is sequencer behavior, so the sequencer emits the +voice's contract verbatim: a pitch signal and a gate signal, clocked by a +phase ramp (0..1 per pattern, a `phasor~`). Per step: pitch, gate/rest, +accent, slide. The measured facts, from the sequencer notebook: + +- Steps land on the analytic grid within **one sample**; the gate opens at + the step start and closes at **0.5** of the step (Open303's + `stepLength`). +- A slid step is approached with the gate *held*: 16 gated steps with 3 + slide flags produce exactly **13 note-ons** — the other three arrive + legato, pitch stepping on the boundary sample, and the voice glides. +- Accented steps gate at 2.0; `transpose` shifts live, like the hardware's + transpose mode without the mode; `swing` and pattern slots with + cycle-quantized `recall` are shared with the drum rows (next chapter). + +The 1981 pitch-mode/time-mode data entry is deliberately not recreated. You +keep the data model; you lose the part everyone hated. + +## When it is not the right tool + +- **You want a generic bass synth.** `tap.vco~` + `tap.svf~` + + `tap.adsr~` give you ADSRs, waveform variety, and a filter that behaves. + This object's value *is* its refusal to decouple. +- **You want the filter without the biography** — `tap.diode~` alone, or + `tap.ladder~` if you want the Moog character instead of the 303's. +- **You want polyphony.** It's a monosynth; `mc.` gives you many monosynths, + which is not the same thing as a polysynth and shouldn't be. + +## Checkpoint + +A diode ladder that matches the published analysis to 0.028 dB and won't +self-oscillate until you bend it; a voice whose envelopes, accent path, and +C13 memory come from the schematic, with the wow measured at ×1.94 across an +accent run; slide as pure gate-hold, so legato falls out of the note +contract; and a sequencer that emits that contract sample-accurately. The +coupling is the instrument — and every claim above has an executed notebook +cell behind it. diff --git a/book/src/drums.md b/book/src/drums.md new file mode 100644 index 0000000..cb068e7 --- /dev/null +++ b/book/src/drums.md @@ -0,0 +1,145 @@ +# The drum machine + +The Roland TR-808 is the most thoroughly analyzed drum machine in the +academic literature, and the reason is charming: the whole instrument is +analog synthesis. No samples anywhere — every sound is a small circuit, and +most of them are variations on about four ideas. The `tap.808.*` family +recreates the eight voice channels circuit block by circuit block, one +external per channel, and `tap.808.seq~` supplies the machine's other half +as one sequencer row per patch cord. This chapter is the family tour: the +shared trigger contract, each voice's character and knobs, and the +calibration pass against a real unit that the numbers come from. + +Companion material: each voice's reference page and help patcher, the family +overview patcher (`tap.808.maxhelp` — all eight voices sequenced off one +`phasor~`), the +[`tr808_calibration.ipynb`](https://github.com/tap/TapTools/blob/main/notebooks/tr808_calibration.ipynb) +notebook, and the +[`step_seq.ipynb`](https://github.com/tap/TapTools/blob/main/notebooks/step_seq.ipynb) +sequencer notebook. Provenance runs through the Werner–Abel–Smith papers +(DAFx-14 and companions) and the TR-808 Service Notes, read component by +component; every magic constant in the kernel headers carries its schematic +designator. + +## One trigger to rule them all + +On the hardware, every voice hangs off a common trigger bus: the CPU's 1 ms +pulse rides a voltage between 4 and 14 V depending on the accent circuit, +and a hotter pulse excites each circuit *harder* — more punch, slightly +different timbre — not merely louder. The family keeps that literally: +**every voice fires on a signal rising edge, and the edge's amplitude +(0..1) is the accent**, mapped onto the 4–14 V bus. `bang` and +`trigger 0.7` messages cover the scheduler side. Filter states persist +across triggers, so fast rolls interfere with the ringing tail like the +hardware — no machine-gun effect. And because the excitation is a voltage, +anything that makes an edge can play the kit: a `click~`, an envelope, a +`tap.303.seq~` gate, or the row object built for the job. + +## The voices + +### `tap.808.kick~` — the bridged-T with a biography + +The bass drum is a damped bridged-T resonator (~49.4 Hz from the modeled +component values; Roland's chart optimistically says 56, real units measure +as low as 48) with three behaviors that make it *the* kick, all emergent +from the modeled schematic: for the first ~6 ms the envelope saturates Q43 +and the resonator sits near ~129 Hz — the attack punch, which is a +*different mechanism* from the famous downward pitch "sigh" (leakage through +R161, the paper's fitted nonlinearity); and a retriggering pulse re-excites +the center node as the envelope collapses so the note doesn't step down. +Panel knobs: `decay` (seconds of ring at the top), `tone` (click at ~7 kHz +down to ~300 Hz), `level`. Paper-documented bends, stock by default: +`tuning`, `pulse`, `sigh`, `attack` — turn `sigh 0` and the pitch relaxation +disconnects, exactly as the bend does on the bench. + +Calibration: against a real unit's knob-gridded sample set, the fundamental +sat within **2.4 %** at every tone/decay position and the −40 dB decay +endpoints within 6 % (72 ms → 2.36 s measured, 69 ms → 2.42 s modeled) — +**no constant needed changing**. + +### `tap.808.snare~` and `tap.808.clap~` — resonators plus noise + +The snare is two bridged-Ts (the late-revision ~173/336 Hz pair) with a +trigger divider and the "snappy" path — enveloped noise, band-limited around +4 kHz to the measured unit. Fundamentals calibrated within 1.2 %, including +the mode flip at tone-max. The clap channel (`@model clap|maracas`) is the +Service Notes' Figure-13 circuit: band-passed noise near 2 kHz through a VCA +driven by a three-teeth sawtooth retrigger — the "multiple hands" transient — +plus the Q70 reverberation tail. The maracas mode is the same noise voiced +short and bright. + +### `tap.808.hat~` and `tap.808.cymbal~` — the metal bank + +Six Schmitt-trigger square oscillators (205.3, 369.6, 304.4, 522.7 Hz plus +the two trimmer-tuned at 800 and 540, duty 47.98 %) feed two bandpass +voicings near 3.4 and 7.1 kHz. Werner et al. measured that resistor variance +puts any given unit **up to ~20 % off** those frequencies — which is why no +two 808s' cymbals sound alike, and why `seed`/`tolerance` exists: every seed +is a different unit off the line, and an `mc.` stack of cymbals decorrelates +like real hardware. The hats are **one object with two trigger inlets** +because on hardware they are one circuit with two envelope paths and a +choke — closed chokes open (the Q23/R173 path), pinned by test, and +unimplementable as separate externals. Open-hat decay spans the chart's +90–600 ms; the cymbal's two separately enveloped bands cover its 350–1200 ms +"sizzle" span. `tap.808.cowbell~` taps just the 540/800 pair into the ~860 Hz +voicing with a two-slope envelope; more cowbell is a patching decision. + +### `tap.808.tom~` and `tap.808.rim~` — the resonator variations + +Six sounds on two objects, as the hardware switches them: `@size low|mid|high` +× `@model tom|conga`. Congas are the tom circuit without its noise layer, +tuned differently; the toms add the D80/D81 attack pitch fall and a pink +noise layer. The rim channel is `@model rimshot|claves`: the rimshot's +~1667 + 455 Hz crack with the swing-VCA's harmonics, versus the claves' pure +~2500 Hz tick. Tunings sit within ~4 % of the measured unit. + +## The calibration pass, honestly + +The §7.2 calibration ran against a real TR-808 (s/n 103852) recorded from +the individual outs with **knob positions encoded in the filenames** — a +0/2.5/5/7.5/10 dial grid, 116 samples — which upgraded "sounds right" to a +quantitative per-knob-cell comparison. Identical measurements (spectral-peak +fundamental, −40 dB decay, power centroid) ran on both sides. The pitches +were already right nearly everywhere; what the pass actually changed was +*time*: tom, conga, cowbell, and clap tails roughly doubled to match the +unit, the snappy was band-limited and re-enveloped, the rimshot re-voiced +low-dominant, the cymbal's decay span corrected. Each kernel header carries +its residuals. The lesson generalizes: schematics get you the frequencies; +recordings get you the envelopes. + +## The other half: `tap.808.seq~` + +One row of the 16-step sequencer, as an object: feed it a phase ramp (0..1 +per pattern, a `phasor~`) and it emits trigger impulses whose amplitude is +the step's accent — the family contract, straight into any voice. Twelve +rows off one phasor are the hardware's panel, sample-locked forever; the +accent row falls out of giving every row the same `accents` list. The +measured facts, from the sequencer notebook: steps land on the analytic grid +within one sample; the pinned levels are **plain 0.01** (the 4 V base — an +un-accented hit still strikes the circuit) and **accented 0.5** (the accent +knob at noon; 1.0 is the full 14 V); `swing` delays the off-16ths by exactly +swing/2 of a step; a `length 12` row against 16s is the triplet pre-scale +generalized to polymeter; and pattern slots with cycle-quantized `recall` +are the A/B-half and fill switching as one message. `pulse` widens the +impulse into a held gate when you'd rather drive `tap.adsr~` than a drum. + +## When it is not the right tool + +- **You want *a* kick, not *the* kick.** A sine with an envelope is cheaper + and takes EQ more politely. This family's value is the circuit behavior — + the attack jump, the choke, the accent-as-voltage. +- **You want your own drum sounds.** These circuits are what they are; + `seed`, the documented bends, and the panel knobs bend them, but a + sampler is a sampler. +- **You want 909 hats.** The 909's metal is sampled; this machine's is six + square waves. Different instrument, different chapter, maybe someday. + +## Checkpoint + +Eight channels, four circuit ideas — bridged-T resonators, a shared metal +bank, noise paths, swing-VCAs — under one amplitude-as-accent trigger bus, +calibrated per knob cell against a real unit and honest about what changed +(the tails) and what didn't (the tunings). The hats choke because they share +a circuit; the cymbals decorrelate because resistors do; and the sequencer +row emits the same voltage idea the voices drink, so the whole kit runs off +one phasor ramp. The machine's two halves, both measured. diff --git a/book/src/introduction.md b/book/src/introduction.md index aeea9f0..5f5b13c 100644 --- a/book/src/introduction.md +++ b/book/src/introduction.md @@ -31,7 +31,11 @@ The book is organized the way a patch is: (`tap.5comb~`) and the pitch-accumulating shimmer loop (`tap.pitchaccum~`). - **Part IV — The spectral set**: the 24-band vocoder (`tap.vocoder~`), the per-bin spectral gate (`tap.nr~`), and the bin remapper (`tap.spectra~`). -- **Part V — The machine, file by file**: the SampleRateTap-style deep dives — +- **Part V — The rhythm section**: the Roland recreations — the TB-303 voice, + its diode-ladder filter, and its sequencer (`tap.303~`, `tap.diode~`, + `tap.303.seq~`), and the eight TR-808 voice channels with their row + sequencer (`tap.808.*`, `tap.808.seq~`). +- **Part VI — The machine, file by file**: the SampleRateTap-style deep dives — one chapter per kernel header, deriving the math, reviewing the code, and recording *why* each algorithm is written the way it is, alternatives and all. Parts I–IV are for driving the objects; Part V is for trusting them — From efd6a02ac427f7ef75aa88fcba4333997caa7810 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 18 Jul 2026 19:51:17 +0000 Subject: [PATCH 6/7] book: Part VI machine chapters for the rhythm section MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Four deep dives in the appendix register: diode_ladder.h (the diffusion chain vs the buffered cascade, the Stinchcombe coefficients as 4*2^(3/4)/10*sqrt(2)/8*2^(1/4), the k=17 Routh-Hurwitz threshold and the derived never-self-oscillates trait, the bottom-up closed-form ZDF solve with secant gains, and the WDF no-go); tb303_voice.h (the per-sample couplings: slide as one coefficient, the C13 wow as three lines, the measured envmod law with its gimmick, the shaped square, the slope- normalized warm VCA, and the documented Open303-vs-Devil-Fish divergence); the tr808 headers (the bridged-T solved on its states so the kick's per-sample leg modulation costs nothing, the metal bank's measured 20% spread, the voices as compositions, and the calibration lesson: schematics get frequencies, recordings get envelopes); step_seq.h (time as a pure function of phase — the O(1) derivation, entry-as-inequality, gate-hold look-ahead, and the armed-recall re-derivation). SUMMARY updated; two fact fixes against the code (four saturating edges, 3 ms VCA attack). Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01JZivyxyBdHYd8sVf8AdUbN --- book/src/SUMMARY.md | 4 + book/src/acid.md | 2 +- book/src/machine/diode.md | 179 +++++++++++++++++++++++++++++++++++ book/src/machine/seq.md | 172 +++++++++++++++++++++++++++++++++ book/src/machine/tb303.md | 194 ++++++++++++++++++++++++++++++++++++++ book/src/machine/tr808.md | 194 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 744 insertions(+), 1 deletion(-) create mode 100644 book/src/machine/diode.md create mode 100644 book/src/machine/seq.md create mode 100644 book/src/machine/tb303.md create mode 100644 book/src/machine/tr808.md diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index e6cdf09..df9443f 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -40,3 +40,7 @@ - [Grains that sum to one: grm_pitchaccum.h](machine/pitchaccum.md) - [Two banks and a multiplier: vocoder.h](machine/vocoder.md) - [One STFT, three effects: fft.h, stft.h, nr.h, spectra.h](machine/spectral.md) +- [Seventeen, not four: diode_ladder.h](machine/diode.md) +- [The couplings are the instrument: tb303_voice.h](machine/tb303.md) +- [One network, eight voices: the tr808 headers](machine/tr808.md) +- [Time as a function of phase: step_seq.h](machine/seq.md) diff --git a/book/src/acid.md b/book/src/acid.md index a062e7f..dae0a87 100644 --- a/book/src/acid.md +++ b/book/src/acid.md @@ -89,7 +89,7 @@ measured laws. - **`tuning`**, **`gain`** — cents and dB. Plumbing. The envelopes carry the schematic's fixed interrelations: MEG attack ~3 ms, -VCA attack ~0 with a ~1.23 s decay chopped at gate-off, 50 ms when accented. +VCA attack ~3 ms with a measured ~1.23 s decay chopped at gate-off, 50 ms when accented. None of these have knobs on the hardware, so none of them have knobs here — except through the documented Devil-Fish-style bends (`slide` 10–500 ms, `attack` 0.3–30 ms, `accdecay`, and `drive` ±24 dB into the ladder, where diff --git a/book/src/machine/diode.md b/book/src/machine/diode.md new file mode 100644 index 0000000..4f30a5c --- /dev/null +++ b/book/src/machine/diode.md @@ -0,0 +1,179 @@ +# Seventeen, not four: `diode_ladder.h` + +The transistor-ladder appendix derived why the Moog loop oscillates at +`k = 4`. The 303's filter looks like the same idea — four capacitors, one +feedback path — and behaves like a different species, because the diode +ladder deletes the one luxury the Moog circuit has: buffering. Every diode +pair both charges the next capacitor and *loads* the previous one. This +appendix derives what that coupling does to the poles, why the oscillation +threshold lands at exactly 17, why the shipping filter still refuses to +self-oscillate at stock settings, and how the coupled nonlinear system is +solved in closed form every sample. + +Everything here is verified against Tim Stinchcombe's published TB-303 +circuit analysis and the executed +[`tb303.ipynb`](https://github.com/tap/TapTools/blob/main/notebooks/tb303.ipynb) +notebook, which matches the kernel's linearized response to his transfer +function to **0.028 dB**. + +## The chain: a diffusion line, not a cascade + +With the diode conduction curve linearized (identity for now), the four node +voltages obey a coupled chain: + +```text +v1' = ω·(S(u − v1) − S(v1 − v2)) +v2' = ω·(S(v1 − v2) − S(v2 − v3)) +v3' = ω·(S(v2 − v3) − S(v3 − v4)) +v4' = 2ω·S(v3 − v4) [the top capacitor is halved on the schematic] +``` + +Each middle equation has *two* terms — charge in from the left, charge +stolen by the right. That is the loading, and it is the whole story: this is +a discrete diffusion line, not four independent one-poles. Its normalized +transfer function works out to exactly Stinchcombe's measured TB-303 +response, + +```text +H(s) = 1 / (s⁴ + 6.727·s³ + 14.142·s² + 9.514·s + 1) +``` + +and the coefficients are not arbitrary — they are `4·2^(3/4)`, `10·√2`, +`8·2^(1/4)`: the equal-component chain with the top cap halved, which is +also why Stinchcombe finds that changing that one cap shifts cutoff by +`2^0.25`. The poles are all real and spread ~25:1 (−0.13, −1.04, −2.33, +−3.24 normalized). Compare the Moog ladder: four *coincident* poles. +Consequences you can hear: + +- Asymptotically the slope is 24 dB/oct, but only ~14 dB falls in the first + octave above cutoff — the honest version of the panel's "18 dB" claim. +- At resonance 0 the −3 dB point sits ~3.2 octaves *below* the resonance + frequency. The kernel's `frequency` parameter names the resonance peak, + and the wide skirt below it is the real filter, not a tuning bug. + +## Seventeen: the closed loop's threshold + +Feedback enters as `u = drive·x − k·hp(v4)`. Ignore the high-pass for a +moment and run Routh–Hurwitz on the closed loop: the stability boundary +lands at exactly **k = 17**, with the marginal oscillation at **√2×** the +stage rate. (Open303 normalizes its feedback by the same 1/17.) So +`resonance` maps `k = 17·resonance`, putting 1.0 at the ideal chain's +threshold — and the prewarp is chosen so that the √2 factor lands the +oscillation *on* the labeled frequency: + +```text +g = tan(π·fc / fs_os) / √2 per stage (2g on the top stage) +``` + +## Why a stock 303 never quite sings + +Now put the high-pass back. The hardware's resonance feedback runs through a +~150 Hz one-pole high-pass (Open303's calibrated value, the `fbhp` default), +and its phase *lead* pushes the would-be oscillation frequency up — to where +the ladder attenuates more. Measured on the shipping kernel: the closed loop +needs `k ≈ 17.5` even at 8 kHz, ≈ 19 at 2 kHz, ≈ 25 at 500 Hz. The knob +stops at 17. The emergent result — not programmed, *derived* — is the famous +trait: **a stock TB-303 never quite self-oscillates**, and neither does this +filter until you take the documented bend (`resonance` runs to 1.5, i.e. +k = 25.5; past ~1.1 it sings at high cutoffs, slightly sharp of `fc` for the +same phase-lead reason). + +The high-pass buys two more behaviors for free: + +- **Resonance thins as cutoff falls** — low notes squelch instead of + ringing, which is why a 303 keeps its bass at high resonance. +- **Closed-loop DC gain is exactly 1** regardless of resonance. The + transistor ladder needed a `comp` parameter to buy its passband back; the + 303's own circuit *is* the compensation, so this kernel has none. + +Set `fbhp 0` and the ideal analysis becomes exact: threshold at 1.0, +oscillation at `fc`, drifting flat by ~0.7× the resonance excess past +threshold — an amplitude effect (the growing swing saturates the edges +unevenly), identical at every cutoff, and pinned by test. + +## The nonlinearity lives on the edges + +In the circuit the *coupling elements* saturate — there are no buffer amps +between stages to saturate instead. So the kernel puts `tanh` on every +`S(·)` above: four saturators, one per diode-pair edge, slope 1 at the +origin so small signals see exactly the linearized Stinchcombe response. +There is no `asym` parameter here, deliberately: the diode pairs are +complementary, so the transistor ladder's operating-point-mismatch story +does not apply. + +## Solving the coupled system in closed form + +The ZDF discretization (trapezoidal, as everywhere in the house) turns each +sample into a *system*: five unknowns (`v1..v4` and the loop input `u`) +that all depend on each other through the couplings and the feedback. The +kernel linearizes each edge with a **secant gain** `γ = tanh(e)/e` at an +operating point, and then — this is the part worth reading in the code — +eliminates the linear system bottom-up to closed form: `v4` in terms of +`v3`, then `v3 = p30 + p32·v2`, `v2 = q20 + q21·v1`, back-substituted until +one division yields `v1` and everything else follows. No matrix, no pivots, +and unconditionally stable: every divisor is ≥ 1 for `g > 0`, `γ ∈ (0, 1]`. +The feedback high-pass's state enters the same solve (its instantaneous +gain `1 − G` multiplies `k`), so the loop is closed exactly, high-pass +included. + +The two solvers differ only in how the secant gains chase the operating +point: + +- **`solver_fast`** (default): solve at the *previous* sample's gains, + refresh the gains at that solution, solve once more, commit. +- **`solver_exact`**: repeat the refresh-and-solve until the node voltages + move by less than 1e-12 (capped at 32 iterations). + +Measured across a settings matrix out to resonance 1.4 and +24 dB drive — +beyond hardware reach — the worst-case difference is **−44.9 dBr**, at +1.6–3.3× the CPU. The fast path's one correction is almost always enough +because `tanh` is smooth and the operating point moves slowly at audio rate; +the exact path exists so that claim never has to be taken on faith. + +After the solve, the states advance trapezoidally using the **true** diode +currents (`tanh` at the solved voltages, not the secant approximations) — +the same "linearize to solve, commit with the real nonlinearity" pattern as +`ladder.h`'s one-pass commit. + +## Oversampling and the rest of the housekeeping + +`tanh` generates harmonics; harmonics alias. The kernel runs 1×/2×/4× +(default 2×) with zero-stuffing and matched 4th-order Butterworth +anti-image/anti-alias cascades — the `ladder.h` pattern, self-contained here +per the house rule against shared lookup tables. Every parameter rides a +per-sample linear ramp; 16 preset slots morph through the same ramps; the +right-inlet path recomputes the coefficient per sample for signal-rate +cutoff. All state clears to zero, and all-zero state is a fixed point — a +self-oscillating patch needs a ping, exactly like the transistor ladder. + +## The engineering ledger + +- **Coupled solve vs. buffered shortcut.** A "diode ladder" built from four + buffered one-poles with new constants would miss the pole spread — the + defining character. The 2×-larger algebra of the coupled solve is the + price of the topology, paid once in closed form. +- **Secant linearization vs. Newton.** Newton needs the derivative of five + `tanh` terms through the elimination; secant gains reuse the same + elimination unchanged and converge fast enough that `solver_exact` rarely + iterates more than a few times. Same accuracy target, simpler code. +- **WDF: the documented no-go.** A wave-digital rebuild of the same network + was evaluated and declined (author-approved, 2026-07-18): `solver_exact` + already converges the circuit's nonlinear equations, and a WDF would + re-solve the same network differing only through the Shockley-vs-tanh + diode curve, with no measured reference showing an audible delta to + chase. The evidence lives in the notebook's solver A/B matrix. +- **No `asym`, no `comp`.** Both absences are circuit facts, not omissions: + complementary diode pairs, and a high-pass that is its own passband + compensation. + +## Checkpoint + +A diffusion chain whose transfer function matches the published analysis to +0.028 dB, with the oscillation threshold derived at k = 17 and then — +because the feedback high-pass is modeled rather than idealized away — +never reached at stock settings, exactly like the hardware. The nonlinearity +sits on the coupling edges where the circuit puts it; the coupled ZDF system +is eliminated to closed form and solved once or iterated to convergence, +with −44.9 dBr between the two answers at settings the hardware can't reach. +The character is the coupling, and the coupling is solved, not approximated +away. diff --git a/book/src/machine/seq.md b/book/src/machine/seq.md new file mode 100644 index 0000000..a68a820 --- /dev/null +++ b/book/src/machine/seq.md @@ -0,0 +1,172 @@ +# Time as a function of phase: `step_seq.h` + +The sequencer header is the smallest DSP file in the kernel and the one +whose central decision does the most work per line: **the engine owns no +clock**. It is handed a phase — a number in [0, 1) meaning "here is where we +are in the pattern" — and everything else (the current step, whether this +sample is a boundary, how far through the step we are) is *derived* from it, +statelessly, every sample. This appendix explains why that one decision +buys sample accuracy, polymeter, scrubbing, and drift-free multi-row lock +for free, and then walks the three pieces built on it: the swing warp, the +two emitters, and quantized recall. + +Verification lives in two places: +[`tests/step_seq_test.cpp`](https://github.com/tap/TapTools/blob/main/tests/step_seq_test.cpp) +(19 Catch2 scenarios, including a pairing test against the real +`tb303_voice.h`) and the executed +[`step_seq.ipynb`](https://github.com/tap/TapTools/blob/main/notebooks/step_seq.ipynb). +The design of record is `plans/tap.seq.md` in the Max package repo. + +## Deriving the step, in O(1) + +Ignore swing for a moment and the whole clock is one line: + +```text +k = floor( wrap(phase) · length ) +``` + +Swing delays each odd-numbered step's start by `swing/2` of a step, so the +start of step k is + +```text +start(k) = ( k + (k odd ? swing/2 : 0) ) / length +``` + +and the derivation gains one correction: compute the naive `k`, and if it is +odd but the fractional position hasn't yet reached `swing/2`, the sample +still belongs to the (even) step before it. Two comparisons, no search — +the boundaries are monotone, so the correction is exact. + +A **step entry** is simply `k != k_previous`. That definition, rather than +"the clock ticked," is what makes the engine indifferent to how the phase +moves: run it backwards and entries still fire (pinned by test); jump it +and the landing step fires once; feed it a constant and nothing happens +after the first sample. `reset()` just forgets `k_previous`, so a transport +start fires its downbeat. + +## Why phase, not a pulse clock + +The alternative — count incoming clock pulses — is how most step sequencers +are built, and every one of them then grows a reset input, a position +protocol, and a drift story. Deriving from phase dissolves all three: + +- **Sample accuracy** is inherited from the phase source. The notebook + measures trigger edges landing within one sample of the analytically + computed boundaries — the one sample being float rounding at the boundary + itself, not accumulated error. +- **Multi-row lock is structural.** Two rows fed the same ramp *cannot* + drift, because neither owns any timing state that could drift. Mute one + for an hour; it re-enters in place. +- **Polymeter is arithmetic.** A `length 12` row against `length 16` rows + off one ramp divides the same cycle differently — 12 and 16 entries per + cycle, measured. The TR-808's triplet "pre-scale" falls out as a special + case. +- **Position is explicit.** Scrubbing, reversing, and jumping are the + *caller's* choices about the ramp, not features the engine implements. + +The cost is honest too: the engine cannot free-run. That is deliberate — +`phasor~` (transport-locked or not) already exists, and a sequencer that +owns tempo is a sequencer that fights the transport. + +## Position within the step, and the gate duty + +The tick also reports `pos` — the fraction of the current step's *actual* +(swung) span elapsed — computed from the same `start()` function. Gate +timing hangs off it: the note row closes its gate at `pos ≥ 0.5`, the +pinned Open303 duty. Measuring duty against the swung span rather than the +nominal step means gates never collide however hard the swing is pushed. + +## The trigger row: an impulse and a re-arming gap + +`trigger_row` is the small emitter: on entry to a sounding step, emit the +step's velocity for one sample (or `pulse_ms` worth, for envelope +consumers), else zero. The single-sample default is a contract, not a +simplification: every downstream `tap.808.*` voice re-arms its edge +detector below 1e-3, and the test suite pins that two *adjacent* sounding +steps produce two clean detectable edges. The header documents the one way +to defeat this — a `pulse_ms` longer than a step merges back-to-back +triggers — rather than silently preventing it. + +## The note row: a five-state sentence + +`note_row` implements the tap.303~ contract, and its entire behavior fits +in one paragraph of code. On entering step k: if the step is gated and its +**slide** flag is set *and a note is already sounding*, change the pitch +output and leave the gate level alone — that is legato, and the voice's RC +does the glide. If gated without that condition, set the gate to 1.0 (2.0 +if accented) — a fresh edge. If not gated, drop the gate. Between entries: +close the gate at the duty point *unless the next step is gated and +slid* — that look-ahead read is the gate-hold, and it is read live from the +pattern each sample so an edit lands immediately. + +Three edge cases are worth naming because the tests pin them: + +- **Slide from a rest is a plain trigger** — there is nothing sounding to + slide from, so the flag degrades gracefully (the voice's `note` message + behaves identically). +- **Chained slides chain** — each held boundary defers the duty close to + the next step, so a run of slid steps is one unbroken gate. Sixteen gated + steps with three slide flags produce exactly thirteen note-ons, measured. +- **The wrap is a boundary like any other** — a slide from step 15 into + step 0 holds across phase 1→0, because nothing in the derivation treats + the wrap specially. + +One convention deserves its provenance note: the slide flag sits on the +*target* step (the note being slid into), matching the package's +`note [accent] [slide]` message and the original interface dry-run. +The hardware stores the flag on the *source* note ("slide to next"). The +data models convert trivially — shift the flag column by one — and the +divergence is documented in the header rather than discovered by a user. + +## Quantized recall: swap on the boundary sample + +Patterns live in 16 slots. `recall` **arms** rather than acts (unless +`quantize now`): the armed slot is applied on the next cycle entry (step 0) +or step entry, and — the detail that keeps it exact — the engine then +*re-derives the current step against the new pattern's grid* on that same +sample, since the new pattern may have a different length. The notebook +pins the semantics end to end: armed mid-cycle, the running pattern +finishes its bar at its own amplitudes, and the first trigger after the +wrap carries the recalled pattern's. That one message is the TR-808's +A/B-half and basic/fill switching. + +## What is deliberately absent + +No randomness (bit-exact by construction, still pinned by test, because +invariants that aren't tested rot). No allocation after `prepare()` — the +pattern store is a fixed 64-step array times 16 slots. No run/stop, no +direction modes, no ratchets: the first two belong to the phase source, and +the last is a future emitter, which is the point of the next paragraph. + +## The engineering ledger + +- **Engine/emitter split.** The clock math lives once; `trigger_row` and + `note_row` are each a screenful. A future row flavor — CV, probability, + ratchet — is another emitter, not another clock. This is also why the + Max-side question "one generic object or two family objects?" could be + answered by product taste rather than by implementation cost. +- **Look-ahead vs. cached hold.** The gate-hold could cache "next step + slides" at entry; reading it live costs one array access per sample and + makes pattern edits take effect mid-step. Cheap beats stale. +- **Sample-resolution boundaries.** Sub-sample trigger placement (fractional + edge amplitudes à la BLEP) was considered and declined: the consuming + voices detect edges at sample resolution, so sub-sample machinery would + add complexity no consumer can observe. If a future voice interpolates + its trigger time, the `tick` already carries the information needed to + add it. +- **The armed-recall re-derivation.** The subtle bug in naive quantized + recall is applying the swap *after* deriving the step, leaving one sample + computed against the old grid. Applying, then re-deriving within the same + call, is two extra lines and the difference between "exact on the wrap + sample" (measured) and "usually fine." + +## Checkpoint + +A sequencer that is a pure function of phase plus a pattern: one line of +derivation, one comparison for swing, entry as inequality — and from that, +sample accuracy, polymeter, reversibility, and drift-free lock without a +clock to maintain. The rows translate steps into the two shipped voice +contracts, with slide as a held gate and a live look-ahead; recall swaps +patterns on the exact boundary sample. Nineteen scenarios and an executed +notebook agree, and the most satisfying number in either is small: thirteen +note-ons, for sixteen steps, three of which arrived without knocking. diff --git a/book/src/machine/tb303.md b/book/src/machine/tb303.md new file mode 100644 index 0000000..d0b5b26 --- /dev/null +++ b/book/src/machine/tb303.md @@ -0,0 +1,194 @@ +# The couplings are the instrument: `tb303_voice.h` + +The field-guide chapter argued that the 303 is unmistakable because its +blocks are *coupled* — accent reaches the filter and the amplifier through +shared circuitry with memory, slide is gate behavior, the envelopes have +fixed interrelations. This appendix walks the per-sample code that +implements those couplings: the measured envmod law, the C13 accent-sweep +capacitor, the slide one-pole, the square shaper, and the phase-2 VCA. The +filter itself is the [previous appendix](diode.md); this file composes it. + +Sources, and the division of labor between them: **Open303** (Robin +Schmidt) supplies the *measured* constants — knob travels, envelope times, +the envmod mapping, the square-shaper curve; the **Devil Fish** +documentation (Robin Whittle) supplies the *circuit behavior* of the +envelope/accent path, including the one place this kernel deliberately +diverges from Open303. Every constant in the header carries its source. + +## One sample, in order + +`process()` reads top to bottom as the signal path: pitch (with slide) → +envelopes → the C13 update → the cutoff sum → oscillator and shaper → +coupling high-pass → diode ladder → VCA → output coupling. Each stanza +below is one of those steps. + +## Slide: one coefficient, no special case + +```text +m_pitch += (m_pitch_target − m_pitch) · m_slide_coef +``` + +That is the entire slide implementation: a true RC lag (τ = the `slide` +parameter, stock 60 ms — Open303's `slideTime`) on the pitch target. The +gate logic makes it behave like the hardware: `note_on` with the gate *low* +snaps `m_pitch` to the target before retriggering (a fresh note starts in +tune); `set_pitch` with the gate *held* moves only the target, so the lag +glides and neither envelope retriggers. Legato **is** slide — which is why +the sequencer's gate-hold trick (see [`step_seq.h`](seq.md)) needs no slide +wire of its own. + +## Two envelopes, both RC discharges + +The Main Envelope Generator and the VCA envelope are the same primitive — +one-pole rise, exponential decay — with different constants and one +coupling each: + +- **MEG**: 3 ms attack; decay = the `decay` knob (200 ms–2 s)… *unless the + note is accented*, in which case the hardware bypasses the pot and runs at + ~200 ms (`accdecay`, a bend, adjusts this clock). Faster *and* hotter is + half of what "accent" means. +- **VCA env**: fixed — ~3 ms attack (the Devil Fish "Soft Attack" bend + widens it to 0.3–30 ms), a measured 1.23 s decay with no sustain, chopped + by a 2 ms release at gate-off (Open303 measures ~1 ms; 2 is click-free). + No knobs on the hardware, so no knobs here. + +## C13: the wow, as three lines of code + +The accent sweep circuit is a diode feeding a capacitor through the +resonance pot. The kernel's model is exactly that sentence: + +```text +drive = accent_knob · note_accent · meg +if (drive > c13) c13 += (drive − c13) · charge // diode conducts: τ = 47 ms (47k·1µF) +c13 −= c13 · drain // always draining: τ ≈ 150 ms +``` + +The diode gating (`if drive > c13`) is the memory: between closely spaced +accents the drain doesn't finish, so the next accent starts from residual +charge and peaks higher — the build-up. The notebook measures the cutoff +peak growing **×1.94** across a run of accents and returning within ×0.998 +once they stop. The cutoff contribution combines the capacitor voltage with +a direct MEG term reduced by it (Devil Fish: "~100/147 of the MEG minus the +capacitor voltage" — what rounds the *first* accent's curve): + +```text +res_mix = 0.3 + 0.7·min(resonance, 1) // the pot is ganged with resonance +acc_oct = 2.0 · res_mix · (0.4·max(drive − c13, 0) + c13) +``` + +Two things to note honestly. The RC time constants are component-derived; +the sweep span (2 octaves) and the 0.4 direct weight are informed +approximations, flagged as such in the header. And this is the kernel's one +deliberate divergence from Open303, which models its accent path as a plain +15 ms leaky integrator with **no across-notes memory**. The A/B was done for +real — Open303 built and rendered side by side — and the Devil Fish circuit +description won because the memory is documented hardware behavior. The +divergence is recorded in the header, not buried. + +## The cutoff sum: a measured law, not a mixer + +`envmod` is not "envelope amount into a summing node." Open303 measured the +hardware's actual mapping (`calculateEnvModScalerAndOffset`), and the kernel +uses those regression lines verbatim. With `c` the knob's log-position +between the measured travel endpoints (302…2394 Hz): + +```text +scaler = (1−c)·(3.774·e + 0.737) + c·(4.195·e + 0.864) +offset = 0.0483·c + 0.2944 +fc_eff = cutoff · 2^( scaler·(meg − offset) + acc_oct ) +``` + +The `offset` term is the hardware's "gimmick": turning envmod up also +injects a counteracting DC shift, so the sweep's resting point moves *down* +as its depth grows — roughly 2/3 of the sweep lands above the knob position +and 1/3 below. That interaction is why the knobs feel like a 303 rather +than like a synth with the same ranges. Note `acc_oct` adds *outside* the +envmod scaling: in the circuit the accent sweep injects directly into the +cutoff sum, so accents quack even with envmod at zero. + +## The square that isn't + +The 303's square is its saw pushed through a transistor shaper, and Open303 +measured the resulting curve. The kernel takes the polyBLEP saw +(`vco.h`'s machinery), makes a half-cycle-shifted copy, and applies the +measured shaper: + +```text +square = −tanh( 10^(36.9/20) · shifted + 4.37 ) +``` + +That ~70× gain and the 4.37 bias produce the rounded, notched pulse whose +spectrum audibly differs from an ideal 50 % square. The `waveform` +parameter is a ramped blend between saw and shaped square, so switching +glides click-free. + +## The couplings at the edges: two high-passes + +Two one-pole high-passes bracket the filter — 44.5 Hz before it, 24.2 Hz +after (both Open303-calibrated coupling corners). The post-filter one earns +its keep twice: it is the output coupling, *and* in `vca warm` mode it +absorbs the saturator's signal-dependent DC, which is exactly what the +hardware's coupling capacitor does. + +## The phase-2 VCA: distortion that tracks the envelope + +`vca clean` is a multiply — bit-identical to phase 1. `vca warm` models the +one-transistor class-A stage as a slope-normalized biased saturator applied +*after* the envelope gain and *before* the output coupling (the hardware +order): + +```text +S(v) = ( tanh(d·v + b) − tanh(b) ) / ( d·sech²(b) ), d = 2.0, b = 0.3 +``` + +Unity slope at zero means quiet notes pass essentially clean; the bias +means hot signals pick up *even* harmonics and compression. Because the +envelope sits inside `v`, the distortion tracks it: measured 5.4 % +difference-signal on quiet notes, 11.5 % on full accents, ~11 % second +harmonic on a full-scale sine with ~−4 dB of compression. `d` and `b` are +probe-calibrated informed constants — the header flags schematic-derived +values as an audition-time refinement, which is the honest state of things. + +## Per-unit spread: `seed`/`tolerance` + +The house `vco.h` convention, applied to a whole voice: tuning trim, cutoff +scale, envelope times, slide and C13 RCs each take a deterministic per-seed +offset scaled by `tolerance`, and the oscillator receives the seed plus a +proportional `imperfect` amount. `tolerance 0` is the nominal schematic, +bit-identical to an unseeded voice (pinned by test); an `mc.` stack with +different seeds drifts apart the way a wall of real units does. + +## The engineering ledger + +- **One object, not a modular kit.** The C13 path touches the MEG, the + resonance knob, and the cutoff sum; accent touches the MEG clock, the VCA + gain, and the sweep. Decomposed into osc + filter + env externals, every + one of those wires would be the user's problem and most patches would + omit them. The couplings live between the blocks, so the object boundary + goes around them. +- **Measured constants over derived ones, where measurements exist.** + Open303's envmod law and shaper curve are adopted verbatim rather than + re-derived from the schematic — they were measured against hardware, and + re-derivation would add error, not rigor. Where Open303 *simplifies* + (the accent memory), the circuit description wins instead. Each choice is + sourced at the constant. +- **The wow's parameters are honest approximations.** Sweep span and the + direct weight await a hardware-calibration pass; the *shape* (diode + gating, two RCs, resonance ganging) is circuit-derived and pinned by the + ×1.94 measurement. Flagged, isolated, waiting — the autowah pattern. +- **`process_at()` per sample.** Pitch (note + tuning + slide) can change + every sample, so the oscillator is driven at signal rate rather than + through a control-rate frequency parameter. The slide RC would be + audibly steppy any other way. + +## Checkpoint + +A voice whose per-sample loop *is* the schematic's block diagram: slide as +one RC coefficient plus gate logic, envelopes as discharge curves with the +hardware's fixed interrelations, accent as a hotter-and-faster MEG plus a +diode-gated capacitor whose leftover charge is the wow, a cutoff law +measured off real hardware complete with its gimmick, a square that is a +shaped saw because that's what a 303's square is, and a VCA whose warmth +tracks the envelope because the envelope sits inside the saturator. Every +constant carries its source, and the one divergence from the reference +implementation is documented with its reason. diff --git a/book/src/machine/tr808.md b/book/src/machine/tr808.md new file mode 100644 index 0000000..7cee02c --- /dev/null +++ b/book/src/machine/tr808.md @@ -0,0 +1,194 @@ +# One network, eight voices: the `tr808_*` headers + +Roland built an entire drum machine out of about four circuit ideas, so the +kernel does too: a bridged-T resonator class, a six-oscillator metal bank, +a noise/VCA toolkit, and eight thin per-voice headers that compose them. +This appendix covers the shared blocks' math — the bridged-T's trapezoidal +solve and why the bass drum needs it solved *that* way, the metal bank's +tolerance model — and the per-voice compositions, ending with the +calibration pass that re-fit the family's envelopes against a real unit. + +Provenance: the Werner–Abel–Smith papers (the DAFx-14 bass-drum analysis +and the cymbal/cowbell companions) and the TR-808 Service Notes, read +component by component. Every constant in these headers carries a schematic +designator or a paper section; the calibration numbers live in +[`tr808_calibration.ipynb`](https://github.com/tap/TapTools/blob/main/notebooks/tr808_calibration.ipynb). + +## `bridged_t.h`: the universal voice circuit + +An op-amp with a bridged-T network in its feedback path — capacitive arms +`C_a`, `C_b`, a resistive bridge, a resistive leg to ground — rings when +kicked, as a decaying pseudo-sinusoid at + +```text +fc = 1 / ( 2π · sqrt(R_leg_eff · R_bridge · C_a · C_b) ) +``` + +where `R_leg_eff` is the leg in parallel with every resistive injection +into the center node. Roland used this network in *every* voice: as the +resonator of the kick, snare, toms/congas, rimshot, and claves, and as the +band-pass of the clap, cowbell, cymbal, and hats. One class, one family. + +Two implementation decisions matter: + +- **The topology is reproduced, not summarized.** With injections grounded, + the class's transfer function matches the DAFx-14 paper's printed + Eqn. (5) coefficient by coefficient (β₂ = α₂ = R_eff·R167·C41·C42, and so + on); the injected paths match their Hbt2/Hbt3, interchanged by injection + resistor; and the center node the paper calls `Vcomm` is exposed, because + the bass drum's pitch-sigh nonlinearity reads it. The whole thing was + re-derived by nodal analysis and pinned by unit test — the paper is + trusted, then verified. +- **Trapezoidal on the states, not bilinear on the coefficients.** The + discretization uses capacitor companion models — a 2×2 linear solve per + sample — which is algebraically the bilinear transform the paper uses, + but solved on the network states directly. The reason is the bass drum: + its leg resistance is *modulated per sample* (the attack shift shorts a + resistor through Q43; the pitch sigh shrinks the effective leg through a + fitted nonlinearity). With a coefficient-form biquad that would mean a + full redesign every sample; with the companion-model solve, a + time-varying resistor is just a changed matrix entry. Same ZDF family as + the house `svf.h`. + +### The kick, since it exercises everything + +`tr808_kick.h` composes the resonator with the paper's full block diagram: +pulse shaper → retrigger network → bridged-T with a feedback buffer closing +a regeneration loop → tone → level. The three signature behaviors are all +emergent from the modeled schematic: for ~6 ms the envelope saturates Q43 +and the ring sits near ~129 Hz (the attack punch); as the envelope +collapses, C39/R161/D52 kick the center node again (the retrigger, so the +note doesn't step down); and leakage lifts Q43's base when the center node +swings below a diode drop — the paper's fitted memoryless nonlinearity +(α = 14.315, V₀ = −0.556, m = 1.4765e-5) converts `Vcomm` to a collector +current that shrinks the leg, so big early swings ring sharp and relax down +as the note decays. That is the sigh, and it is a *different mechanism* +from the attack jump — the paper's central untangling, preserved here. One +erratum survives in the header: the paper's Eqn. (9) as printed is garbled, +so the leg formula was re-derived from KCL at Q43's collector and matches +their stated limits. + +Accent is the trigger *voltage* — 4–14 V on the bus, mapped from the 0..1 +edge amplitude — exciting the network harder, not scaling the output. And +filter states persist across triggers, so rolls interfere with the ringing +tail: no machine-gun effect, by construction rather than by crossfade. + +## `swing_vca.h`: the small shared parts + +The 808 shapes its percussive gains with one-transistor "swing type" VCAs +driven by RC discharges, not ADSRs. The header holds the three primitives +the noise voices share: `decay_env` (one-pole rise to a level, exponential +decay — retriggering re-aims the rise, no reset click), the linear +`swing_vca` gain (the hardware's "many high harmonics" are a flagged +refinement), and `white_noise` — a seeded xorshift64*, because the 808 has +exactly one noise generator feeding the snare's snappy, the clap, the +maracas, and the toms' noise layer, and because determinism-per-seed is a +house invariant: renders reproduce, tests pin, `mc.` instances decorrelate. + +## `metal_bank.h`: six squares and a spread + +The metallic voices all draw on one bank of six Schmitt-trigger relaxation +oscillators: nominal 205.3, 369.6, 304.4, 522.7 Hz plus the two +trimmer-tuned at 800 and 540 (the pair the cowbell taps), duty 47.98 % per +the paper's HD14584 analysis. Three modeling calls: + +- **Naive squares are faithful.** The fundamentals sit below 1.2 kHz and + the hash above them is immediately band-passed; the residual aliasing + folds into the same inharmonic wash the circuit itself produces. PolyBLEP + would be cost without benefit — a rare sentence in this repo, so it's + documented. +- **Tolerance is part of the instrument.** The RC parts put any given + unit's oscillators up to ~20 % off nominal — the paper's measurement, and + the reason no two 808s' cymbals sound alike. `tolerance` scales a + deterministic per-seed spread of exactly that width. This is not + "analog warmth" seasoning; it is a measured production statistic. +- The two band-pass voicings (~3440 and ~7100 Hz, Q fit to the paper's + published skirts) and the Q19 attack smoother (τ = 102.44 µs less a + 0.7258 V base-emitter drop, their least-squares fit) live here too, + because cymbal, hats, and cowbell all share them. + +## The voices, as compositions + +Each `tr808_*.h` is a thin arrangement of the blocks above, with its own +schematic constants: + +- **Snare**: two bridged-Ts at the late-revision ~173/336 Hz (the design + change is documented in the header), a trigger divider, and the snappy + path — `decay_env`-shaped noise, band-limited near 4 kHz. +- **Clap** (`clap|maracas`): ~2 kHz dual band-pass noise through a VCA + driven by the Service Notes' Figure-13 three-teeth sawtooth — the + "multiple hands" transient — plus the Q70 reverberation tail. +- **Hats**: one circuit, two envelope paths, and the hardware choke + (Q23/R173): a closed-hat trigger terminates a sounding open hat, pinned + by test. This is why `tap.808.hat~` is one object with two inlets — the + choke is unimplementable across separate externals. +- **Cymbal**: the bank through both voicings with two separately enveloped + bands (strike/ring/body), decay spanning the chart's 350–1200 ms. +- **Cowbell**: just the 540/800 pair into the ~860 Hz voicing, two-slope + envelope. +- **Toms/congas** (`@size` × `@model`): the resonator at the chart tunings + with the D80/D81 attack pitch fall; toms add a pink-noise layer (pinned + by seed-sensitivity, since the diode bend's own harmonics defeat spectral + separation); congas are the same circuit, no noise. +- **Rim/claves**: the ~1667 + 455 Hz crack with the swing-VCA's tanh + harmonics, versus the pure ~2500 Hz tick. + +The family also carries per-channel summing gains (`k_tomc_mix`, +`k_cl_mix` — the hardware's summing resistors into the mix bus): the +bridged-T's impulse gain grows with fc·Q, and before the balance pass the +high conga peaked at ~5.3 while other voices sat far lower. Every voice's +full-accent peak now lands in a consistent ~0.3–1.0 band, pinned by test. + +## The calibration pass: what measurement actually changed + +The family was calibrated against a real unit (s/n 103852) recorded from +the individual outs with knob positions encoded in the filenames — a +0/2.5/5/7.5/10 dial grid, 116 samples — so the comparison ran per knob +cell, with identical measurements (spectral-peak fundamental, −40 dB decay, +power centroid) on both sides. The result is a clean split: + +- **Frequencies: the schematics were right.** Kick within 2.4 %, snare + within 1.2 % (including the tone-max mode flip), toms/congas/cowbell/ + claves within ~4 %. The kick needed *no constant changed*. +- **Time: the recordings won.** Tom, conga, cowbell, and clap tails roughly + doubled; the snappy was band-limited and re-enveloped; the rimshot + re-voiced low-dominant; the cymbal's decay span and brightness corrected; + the closed hat's brightness residual later resolved by the hats' sizzle + blend. + +Each header carries its calibration note with numbers and residuals. The +lesson is worth stating as a rule: **schematics get you the frequencies; +recordings get you the envelopes** — decay behavior hides in pot tapers, +electrolytic tolerances, and aging that no schematic states. + +## The engineering ledger + +- **One resonator class vs. per-voice filters.** Eight voices reduce to + ~4 blocks plus thin compositions only because the bridged-T class keeps + the injected-path structure of the real network instead of collapsing to + a generic biquad. The generality was free once the nodal analysis was + done — and the kick's per-sample leg modulation *required* it. +- **Behavioral envelope generators.** The kick's EG is modeled as fast + rise / ~1.1 ms release rather than as its own transistor network — the + paper's own simplification, adopted with its citation. Fidelity effort + went where the analysis said it matters (the leg, the retrigger, the + sigh), not uniformly everywhere. +- **The WDF door, left closed but unlocked.** The flagged `@circuit` + upgrade path (wave digital, the `svf.h` two-circuit pattern) remains + gated on an A/B showing an audible delta the informed model misses. The + DAFx-14 paper's own finding — device nonlinearity matters less than + folklore claims — suggests the gate may never open, which would itself be + a documented result. +- **Determinism everywhere.** Seeded noise and seeded tolerance mean every + render, test, and calibration measurement is reproducible bit-for-bit. + The calibration pass would have been guesswork without it. + +## Checkpoint + +One network class matching the published transfer functions exactly and +solved on its states so a time-varying resistor costs nothing; a metal bank +whose ±20 % spread is a measurement, not a vibe; voices that are thin +compositions with schematic-designated constants; and a per-knob-cell +calibration pass that confirmed the frequencies, corrected the envelopes, +and wrote its residuals into the headers it changed. Four ideas, eight +voices, every number traceable. From e2e97a0dada5b155ce4869f95de86bce3c867796 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 18 Jul 2026 19:51:31 +0000 Subject: [PATCH 7/7] =?UTF-8?q?book:=20acid.md=20=E2=80=94=20the=20exact?= =?UTF-8?q?=20solver=20is=20secant=20re-linearization,=20not=20Newton?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01JZivyxyBdHYd8sVf8AdUbN --- book/src/acid.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/book/src/acid.md b/book/src/acid.md index dae0a87..2c8f04c 100644 --- a/book/src/acid.md +++ b/book/src/acid.md @@ -54,8 +54,9 @@ this, and the kernel reproduces his published transfer function to (Push `resonance` past 1.0 — the bend range runs to 1.5 — and it will sing for you anyway.) -Like `tap.ladder~` it has a `solver` choice: `fast` (default) or `exact` -Newton iteration on the true nonlinear loop. Measured across a matrix out to +Like `tap.ladder~` it has a `solver` choice: `fast` (default) or `exact`, +which iterates the re-linearized solve to convergence on the true nonlinear +loop. Measured across a matrix out to resonance 1.4 and +24 dB drive — beyond anything the hardware can reach — the two differ by at most **−44.9 dBr**, at 1.6–3.3× the CPU. The exact solver is there for the suspicious; the fast one is there for the patch.