From 9155b4f0aad03743336dbe69f05b424f82265405 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 15 Aug 2026 21:27:18 +0000 Subject: [PATCH 01/22] Plan the Radiohead family Drafting record for a family of performed-electronics kernels: the multi-head tape echo, the live stutter rig, the Ondes Martenot and its diffuseurs, the ShredMaster-school fuzz, and the Kaoss-school scrub. Surveyed 2026-08-15 and amended the same day against the Eno components wave before any code: the echo becomes composition over tape_loop.h, the diffuseurs inherit the garden's modal idiom, and the family adopts the components-first delivery template, the seeded-randomness convention, and the Bloom -> garden trademark posture from the start. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 222 ++++++++++++++++++++++++++++++++++ 1 file changed, 222 insertions(+) create mode 100644 book/PLAN-radiohead-family.md diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md new file mode 100644 index 0000000..1e7a3c0 --- /dev/null +++ b/book/PLAN-radiohead-family.md @@ -0,0 +1,222 @@ +# Plan — the Radiohead family + +> **Status: plan.** Nothing here is implemented. This is the drafting record of the +> 2026-08-15 survey ("are there Radiohead-inspired objects we should consider?"), amended +> the same day against the Eno components wave (`d4cf28a`) before any code was written. +> It stays after the objects ship, the plans-directory way; per-chapter drafting records +> will follow separately when the book chapters are drafted. + +Planning document for a family of kernels drawn from Radiohead's performed electronics: +the Ondes Martenot, the live Max/MSP mangling rigs, the tape echoes, the Kaoss-pad vocal +scrubbing, the ShredMaster-era fuzz. Kernel-first in this repo, Max wrappers and pin bumps +in TapTools-Max afterward, per the release flow. + +The family's single thesis, the Eno-family way — one sentence every object serves: +**these are instruments, not processes.** Radiohead's electronics are played on stage in +real time — Jonny Greenwood performs the Ondes and his own Max patches live; the Kaoss pad +scrubs Thom's voice mid-song; the echo's regeneration is ridden like a fader. So in this +family the *performance surface* is the point: every parameter is a hand on the machine, +which makes the house no-zipper rule (per-sample ramps, allocation-free setters, safe while +audio runs) not just hygiene here but the actual feature. Where the Eno family's spine was +"degradation is the stability mechanism," this family's spine is "the control is the +instrument." + +There is also a lineage claim that makes this family belong in a Max package specifically: +Greenwood's stutter rigs *are* Max patches — the band's documented live setup runs +Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. + +## The family at a glance + +| Object | Kernel | Recreates | Standing on | +|--------|--------|-----------|-------------| +| `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | +| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | +| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | +| `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | +| `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | + +Parked (surveyed, deliberately not planned): a spectral freeze on the `stft.h` scaffold +(`tap.sustain~` and `tap.discreet~` now cover most of that ground between them), a Klatt +formant synthesizer (complete published spec — Klatt 1980, JASA — but a project of its +own), and a signal-rate bitcrush (trivial; nothing blocks it, nothing urgent about it). + +## What the Eno wave changed (the amendments this plan bakes in) + +The survey predated the Eno components wave by hours. Five amendments, now assumptions: + +1. **`tap.tapecho~` is composition, not construction.** `tape_loop.h` already ships the + reel (delay-line topology explicitly supported), the periodic wow/flutter transport + citing the same tape-echo literature the survey cited, and `wear` (darken → bounded + saturation → DC block) as an in-loop stage. The echo is a multi-head sibling of + `discreet.h`, not a new machine. +2. **The Ondes diffuseurs inherit the garden's modal pattern.** Mode banks with published + ratio tables (Fletcher & Rossing), doublet splitting, per-index deterministic scatter, + per-mode decay — the scary half of `tap.ondes~` now has a shipped house idiom and a + standalone component (`tap.chime~`) to model the shape on. +3. **Components from day one.** The Eno components chapter's lesson — "the monoliths were + monoliths by accident" — is prospective here: every kernel below is planned as parts + with a thin composition, and the parts get C ABI + wrapper reachability from the start. +4. **The family randomness convention.** Anything stochastic (the stammer's dice, scrub + jitter if any) draws from the seeded xorshift64* idiom so renders and tests reproduce + bit-exactly and instances decorrelate by seed. The stammer inherits this wholesale. +5. **The delivery template exists.** Shared-machinery header where earned, kernels + C ABI + + ctypes + executed notebooks, a `tools/render` listening binary (`radiohead_render`, + the `eno_render` shape), book chapters with drafting records, full Max vertical slices. + This plan mirrors that template rather than inventing one. + +## Per-object plans + +### 1. `tap.tapecho~` — the multi-head tape echo *(first; small)* + +The Watkins Copicat sits in Ed O'Brien's rig; the Space Echo school is all over the +catalog. The house delay family (`delay.h`, multitap, procrastinate) is clean digital; +this is the dirty one, and nearly all of it exists: + +- One `tape::reel` in delay-line topology: advancing record head, **N read heads** at + settable spacings (per-head level and pan, the multitap law). Motor speed is the master + delay control, and a speed change glides as varispeed — the `discreet.h` contract: + moving the head IS the doppler, no crossfading "digital" mode. +- `tape::wow_flutter` on the transport — periodic-only and deterministic, inherited as a + *decision*, not an accident: the family keeps bit-exact renders; stochastic capstan + drift stays a documented non-goal unless listening says otherwise. +- `tape::wear` in the regeneration path. The self-oscillation story must be stated in the + header, `discreet.h`-style: with drive engaged, `swing_shape`'s 1/drive bound holds the + loop absolutely bounded, so regeneration is *allowed* past unity into controlled + sound-on-sound howl — the dub move, made safe by the same inversion `discreet.h` runs + on. At drive 0 the fb cap falls back to the `delay.h` rule. + +Head layout: default to a fixed three-head Copicat-style spacing preset with heads freely +settable underneath (open question below). Tests, house patterns: an oracle measurement of +wow — drive a sine through one head and read the pitch deviation with `tap::dsp::yin` +against the analytic transport excursion; and a null test — wow 0, wear at the band +ceiling (the `airport.h` bypass), drive 0 should collapse the echo to a plain multitap +delay (bitwise if the interpolators align — both are the family Hermite — otherwise pinned +to a measured error bound, honestly stated). + +### 2. `tap.stammer~` — the live stutter rig *(second; the most "us")* + +The disintegrating guitar at the end of *Go To Sleep* and the mangling in *The Gloaming* +come from Greenwood's own Max patches: capture the live input, re-fire randomized slices +of it. An **original design** in the brassage tradition (Roads, *Microsound*) — no port, +no IP entanglement; the published record of the band's rig (interviews, the *From the +Basement* films) is behavioral reference only, nothing copied. + +Two components and a thin composition: + +- **capture** — a `tape::reel` recording the live input (shared shape with `tap.scrub~` + below; whether it is literally one shared class is an open question). +- **slicer** — the dice and the playback: fire probability per quantum, quantized slice + lengths (musical divisions of a settable base), repeat-count distribution, reverse + probability, per-slice equal-power envelope width. Every continuous parameter rides a + ramp; every random draw comes from the seeded xorshift64* so a seed is a performance you + can replay. Dry/slice balance is the performance fader. + +Tests: determinism per seed (bit-exact renders), the envelope's constant-power promise, +and a material contract stated in the header — the object is *for* transient material +(drums, struck guitar); on static pads it is just a tremolo, and the header says so. + +### 3. `tap.ondes~` — the Ondes Martenot *(the flagship; gated)* + +*How to Disappear Completely*, *The National Anthem*, *Where I End and You Begin*. The +instrument decomposes on exactly the family's seams, and the decomposition is the plan: + +- **The voice**: a continuous-pitch oscillator (`vco.h` groundwork) with the waveform mix + registers, driven by two performance signals — pitch (the ribbon; continuous, no + quantization, glide is the playing technique not a parameter) and the **touche + d'intensité**, the pressure key: a fast nonlinear-taper VCA whose response curve is the + expressive heart of the instrument and must come from published measurement, not vibes. +- **The diffuseurs**, as standalone resonator components usable on *any* input — the + killer feature is running a guitar through the Palme: **Métallique** (gong plate) as a + modal bank per Fletcher & Rossing's plates/gongs chapters in the `garden.h` doublet + idiom; **Palme** (sympathetic strings) as a bank of tuned string resonators + (comb/waveguide school, `grm_comb.h` experience). Principal is the dry path. + +**Gate: source collection before implementation.** The provenance rule is the whole +ballgame here. Candidate sources to verify and pin: the published organological studies of +the instrument (there is published work specifically measuring the touche d'intensité's +response — locate and verify it), Fletcher & Rossing for both diffuseurs, and period +technical descriptions of the waveform registers. If a needed number has no published +source, the honest fallback is a *recreation* voiced by ear against published recordings +and documented as such — decided per-number, in the header, when we get there. + +### 4. `tap.fuzz~` — the ShredMaster school *(small, parallel-friendly)* + +The OK Computer-era dirt (*Paranoid Android*, *My Iron Lung*). A circuit-informed +recreation from the widely published schematic — cascaded clipping stages plus its +characteristic tone stack — with the diode-clipper modeling literature (the Yeh/Abel/Smith +DAFx line) behind the solver choices. Direct sibling of `overdrive.h`; the TR-808 kernels +are the house precedent for schematic-based recreation. **Naming is an open question** +(below): the garden precedent (Bloom → garden) says don't ship a live trademark; +"ShredMaster" is Marshall's mark, and the header will cite it as provenance either way. + +### 5. `tap.scrub~` — the Kaoss school *(after stammer; shares its capture)* + +Live *Everything In Its Right Place*: the voice sampled on the fly and scrubbed, reversed, +smeared from a pad. A continuously recording `tape::reel` with a **performable granular +playhead**: position and speed as signals (the pad is two axes — that is the Max-side +mapping story), Hermite grains from the `grm_pitchaccum.h` engine, overlap and grain size +exposed. Distinct from `tap.reel~` (free-running loop, no performable head) and from +`tap.pitchaccum~` (transposition, not scrubbing); shares machinery with both, and the plan +is to make that sharing literal, not copied. + +## Cross-cutting commitments + +- **Kernel-first, components-first.** Every object lands as kernel parts + composition in + this repo with C ABI and ctypes bindings extended alongside (`tools/capi`, + `notebooks/taptools_py.py`), executed notebooks for every measured claim, then the Max + vertical slices (wrapper, `docs/` maxref, `help/` patcher, runtime maxtest) and the + submodule pin bump in TapTools-Max. +- **`radiohead_render`** in `tools/render`: minutes-long listening checks per object, the + `eno_render` shape — the echo into self-oscillation and back, a seeded stammer + performance, the diffuseurs rung by a struck string. +- **Oracle-based measurement** where a promise is audible: yin on the echo's wow, yin on + the ondes ribbon glide, envelope-power measurement on the stammer slices. +- **Book**: a family part (working titles — *The machine as a band member*; per-object + chapters like *The tape with three heads*, *The patch that stutters*, *Waves and + wire*) plus machine appendices, each with its own PLAN drafting record when drafted, + every number citing an executed cell or pinned test. + +## Provenance and naming (the IP posture, applied) + +- **Published-literature-only for new DSP**, per the house policy: the echo stands on the + tape-echo modeling literature already cited in `tape_loop.h`; the fuzz on a published + schematic plus the clipper-modeling literature; the diffuseurs on Fletcher & Rossing; + the ondes voice is gated on locating its published measurements. The stammer and scrub + are original designs in the granular literature's tradition. +- **Nothing is copied from anyone's patch, preset, or firmware.** Greenwood's Max rigs + are known from published interviews and broadcast films; they inform *what the object + is for*, never what the code says. Same posture as `garden.h` toward Bloom. +- **Trademark care in names**, the Bloom → garden precedent: no `kaoss` (Korg), no + `shredmaster` (Marshall), no song-title names that read as endorsement. "Ondes" is the + generic French word and the instrument's common name; "tapecho", "stammer", "scrub", + "fuzz" are generic English. + +## Order, and why + +1. **`tap.tapecho~`** — smallest distance from shipped code, and it stress-tests + `tape_loop.h` as the library the components chapter claims it is. +2. **`tap.stammer~`** — original design (no sourcing gate), highest Max-lineage + resonance, establishes the family's capture + seeded-performance conventions. +3. **`tap.ondes~`** — the flagship; source collection starts immediately (it + parallelizes with 1–2), implementation begins when the gate clears. +4. **`tap.fuzz~`** — small and independent; slots into any gap. +5. **`tap.scrub~`** — after the stammer, so the capture component is designed once with + both consumers in view. + +## Open questions + +- **The fuzz's name.** `tap.fuzz~` (generic, safe, dull) vs `tap.shred~` (generic English + word, but adjacent to the mark) vs something from the family's own metaphor. Decide + before the vertical slice; the kernel header name can follow. +- **Echo head layout.** Fixed Copicat-style preset spacings with free placement + underneath, or free placement only with presets as Max-side messages? Leaning preset + + free, so the default sounds like *a* machine out of the box. +- **One capture component or two.** Stammer and scrub both record the live input into a + reel; whether that is one shared class with two heads of use, or two thin wrappers over + `tape::reel`, is a design call to make when the stammer lands. +- **Diffuseur delivery.** Ship the resonators inside `tap.ondes~` only, or as standalone + externals (`tap.palme~` / `tap.metallique~`) from day one? The components chapter's + lesson leans standalone-from-day-one. +- **Stochastic transport, ever?** The family inherits periodic-only wow/flutter. If the + echo's listening checks say the grot is missing, the amendment is a *family* decision + (it breaks bit-exact renders) — flagged now so it is never a quiet local hack. From 9e19122d611a89190d798ec6b178951abf24c4a2 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 15 Aug 2026 22:32:03 +0000 Subject: [PATCH 02/22] Add the multi-head tape echo: tap.tapecho~ The first kernel of the Radiohead family, and the plan's prediction tested: tapecho.h is composition over tape_loop.h, not a new machine. One reel in delay-line topology, one transport, one wear stage, and up to four playback heads at settable positions along the path -- span_ms is the motor (the delay of a ratio-1.0 head) so a speed change moves every head together, as varispeed does. Where discreet.h lets regeneration reach exactly 1.0 because the wear path is the stabilizer, this one goes past unity into deliberate sound-on-sound howl, bounded by the saturator's 1/drive ceiling rather than a feedback cap -- and capped back to 1.0 per sample whenever drive is 0, since that is the only thing holding the past-unity regime. The head layout is a nominal even spacing, freely settable; no spacings are claimed as measured from any unit. The null test is the load-bearing one: with the tape path neutral, a one-head echo is bitwise delay.h's multitap, pinned in the kernel tests and again across the C ABI in the notebook. Also measured: per-pass generation loss within 0.2% of the analytic wear transfer, wow at 10.91 cents against 10.88 predicted, and every past-unity drive setting plateauing under its ceiling. Ships the layer the family template asks for: 11 Catch2 scenarios, the C ABI plus ctypes surface (TapEcho), the executed tapecho.ipynb, and radiohead_render with four performed scenarios. The Max wrapper and the book chapter are still to come. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 65 ++-- include/taptools/tapecho.h | 422 +++++++++++++++++++++++++ include/taptools/taptools.h | 1 + notebooks/tapecho.ipynb | 506 ++++++++++++++++++++++++++++++ notebooks/taptools_py.py | 102 +++++- tests/CMakeLists.txt | 1 + tests/tapecho_test.cpp | 406 ++++++++++++++++++++++++ tools/capi/taptools_capi.cpp | 83 +++++ tools/capi/taptools_capi.h | 27 ++ tools/render/CMakeLists.txt | 2 +- tools/render/radiohead_render.cpp | 258 +++++++++++++++ 11 files changed, 1847 insertions(+), 26 deletions(-) create mode 100644 include/taptools/tapecho.h create mode 100644 notebooks/tapecho.ipynb create mode 100644 tests/tapecho_test.cpp create mode 100644 tools/render/radiohead_render.cpp diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 1e7a3c0..9e02904 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,10 +1,11 @@ # Plan — the Radiohead family -> **Status: plan.** Nothing here is implemented. This is the drafting record of the -> 2026-08-15 survey ("are there Radiohead-inspired objects we should consider?"), amended -> the same day against the Eno components wave (`d4cf28a`) before any code was written. -> It stays after the objects ship, the plans-directory way; per-chapter drafting records -> will follow separately when the book chapters are drafted. +> **Status: in progress — `tap.tapecho~`'s kernel has landed (2026-08-15); the rest is +> plan.** This is the drafting record of the 2026-08-15 survey ("are there +> Radiohead-inspired objects we should consider?"), amended the same day against the Eno +> components wave (`d4cf28a`) before any code was written. It stays after the objects ship, +> the plans-directory way; per-chapter drafting records will follow separately when the book +> chapters are drafted. Per-object status lives in the table below. Planning document for a family of kernels drawn from Radiohead's performed electronics: the Ondes Martenot, the live Max/MSP mangling rigs, the tape echoes, the Kaoss-pad vocal @@ -27,13 +28,13 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. ## The family at a glance -| Object | Kernel | Recreates | Standing on | -|--------|--------|-----------|-------------| -| `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | -| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | -| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | -| `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | -| `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | +| Object | Kernel | Recreates | Standing on | Status | +|--------|--------|-----------|-------------|--------| +| `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ kernel shipped 2026-08-15; Max wrapper + chapter pending | +| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | planned | +| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | planned — gated on source collection | +| `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | planned | +| `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | Parked (surveyed, deliberately not planned): a spectral freeze on the `stft.h` scaffold (`tap.sustain~` and `tap.discreet~` now cover most of that ground between them), a Klatt @@ -66,7 +67,20 @@ The survey predated the Eno components wave by hours. Five amendments, now assum ## Per-object plans -### 1. `tap.tapecho~` — the multi-head tape echo *(first; small)* +### 1. `tap.tapecho~` — the multi-head tape echo *(first; small)* — ✅ kernel shipped + +> **Shipped 2026-08-15**: `include/taptools/tapecho.h`, `tests/tapecho_test.cpp` (11 +> scenarios), the C ABI + ctypes surface (`TapEcho`), the executed `notebooks/tapecho.ipynb`, +> and `tools/render/radiohead_render.cpp` with four performed scenarios. What the plan +> predicted held: the kernel is composition — the null test below is *bitwise*. Still to +> come: the Max wrapper (`tap.tapecho~` vertical slice) in TapTools-Max, and the book +> chapter. Design decisions taken during implementation that this record should carry: +> the head layout is `span_ms` (the motor, = a ratio-1.0 head) times a per-head ratio, so +> four evenly spaced heads is the default and a three-head Copicat layout is set explicitly +> (the "preset + free" open question, resolved toward *free with an even-spacing default* — +> no spacings are claimed as measured from any unit); regeneration reaches +> `k_regen_max_driven` = 1.5 but is capped **per sample** back to 1.0 whenever drive is 0, +> since the saturator is the only thing bounding the past-unity regime. The Watkins Copicat sits in Ed O'Brien's rig; the Space Echo school is all over the catalog. The house delay family (`delay.h`, multitap, procrastinate) is clean digital; @@ -85,13 +99,15 @@ this is the dirty one, and nearly all of it exists: sound-on-sound howl — the dub move, made safe by the same inversion `discreet.h` runs on. At drive 0 the fb cap falls back to the `delay.h` rule. -Head layout: default to a fixed three-head Copicat-style spacing preset with heads freely -settable underneath (open question below). Tests, house patterns: an oracle measurement of -wow — drive a sine through one head and read the pitch deviation with `tap::dsp::yin` -against the analytic transport excursion; and a null test — wow 0, wear at the band -ceiling (the `airport.h` bypass), drive 0 should collapse the echo to a plain multitap -delay (bitwise if the interpolators align — both are the family Hermite — otherwise pinned -to a measured error bound, honestly stated). +Head layout: four evenly spaced heads by default, every ratio freely settable underneath. +Tests, house patterns: an oracle measurement of wow — drive a sine through one head and read +the pitch deviation with `tap::dsp::yin` against the analytic transport excursion; and a null +test — wow 0, drive 0, regen 0 should collapse the echo to a plain multitap delay. *Both +landed, and the null is bitwise* (the interpolators do align — same family Hermite, same +fractional position, same equal-power pan law), measured in the kernel test and again across +the C ABI in the notebook. Measured at ship: per-pass generation loss within 0.2% of the +analytic wear transfer on both sides of the corner; wow 10.91 cents measured against 10.88 +predicted; every past-unity drive setting plateaus under its analytic ceiling. ### 2. `tap.stammer~` — the live stutter rig *(second; the most "us")* @@ -194,7 +210,8 @@ is to make that sharing literal, not copied. ## Order, and why 1. **`tap.tapecho~`** — smallest distance from shipped code, and it stress-tests - `tape_loop.h` as the library the components chapter claims it is. + `tape_loop.h` as the library the components chapter claims it is. ✅ *Kernel done; the + stress test passed — the shared machinery needed no changes to serve a second topology.* 2. **`tap.stammer~`** — original design (no sourcing gate), highest Max-lineage resonance, establishes the family's capture + seeded-performance conventions. 3. **`tap.ondes~`** — the flagship; source collection starts immediately (it @@ -208,9 +225,9 @@ is to make that sharing literal, not copied. - **The fuzz's name.** `tap.fuzz~` (generic, safe, dull) vs `tap.shred~` (generic English word, but adjacent to the mark) vs something from the family's own metaphor. Decide before the vertical slice; the kernel header name can follow. -- **Echo head layout.** Fixed Copicat-style preset spacings with free placement - underneath, or free placement only with presets as Max-side messages? Leaning preset + - free, so the default sounds like *a* machine out of the box. +- ~~**Echo head layout.**~~ Resolved at ship: free ratios with a nominal even-spacing + default (0.25 / 0.5 / 0.75 / 1.0), rather than a named-machine preset — no head spacings + are claimed as measured from any unit, and a Copicat-style three is two lines to set. - **One capture component or two.** Stammer and scrub both record the live input into a reel; whether that is one shared class with two heads of use, or two thin wrappers over `tape::reel`, is a design call to make when the stammer lands. diff --git a/include/taptools/tapecho.h b/include/taptools/tapecho.h new file mode 100644 index 0000000..6cd386f --- /dev/null +++ b/include/taptools/tapecho.h @@ -0,0 +1,422 @@ +/// @file +/// @brief Portable multi-head tape-echo kernel for tap.tapecho~ — no Max/Min dependency. +/// @details The first kernel of the Radiohead family (book/PLAN-radiohead-family.md): the +/// multi-head tape echo of the Watkins/WEM Copicat and Roland Space Echo school — +/// one record head, a span of moving tape, several playback heads at fixed positions +/// along it, and a regeneration path from the heads back to the record head. +/// +/// It is a *recreation of the topology*, not a port or a circuit model of any one +/// machine: the tape-path DSP (fractional read, periodic wow/flutter, in-loop +/// coloration) is the published tape-echo modeling literature already carried by +/// tape_loop.h (Arnardottir, Abel, Smith, "A Digital Model of the Echoplex Tape +/// Delay", AES 125, 2008; Valimaki et al.'s tape-echo work). No head spacings, +/// filter curves, or trim values are claimed as measured from any unit — see the +/// head-layout note below. +/// +/// Almost all of the machinery is tape_loop.h; this kernel is the composition. Two +/// classes, the airport.h split: +/// - `head` — ONE playback head: its position along the tape path (`ratio` of the +/// motor span), its level, and its place in the stereo field. It carries its own +/// anti-zipper ramps and reads a reel it does not own. Unlike `airport::loop` a +/// head is NOT independently useful — it is a read position, not a machine — so it +/// is a component for composition and testing, not a standalone external. +/// - `machine` — one reel in delay-line topology, one transport, one wear stage, and +/// k_max_heads heads. Its process() is a sum over the heads plus the regeneration +/// write, and nothing else. +/// +/// Geometry of the head path: `span_ms` is the motor — the delay of a head at the +/// far end of the path (ratio 1.0) — and each head's delay is `span_ms * ratio`, so +/// moving the motor moves every head together, as a tape speed does. Defaults are +/// four evenly spaced heads (0.25, 0.5, 0.75, 1.0). Even spacing is a nominal layout +/// chosen because it is neutral and audibly "a tape echo"; real machines' head +/// positions vary by model and unit and are not modeled here. Ratios are freely +/// settable, which is how a three-head Copicat-style layout is built. +/// +/// The stability story, and the design statement this kernel exists to make: it is +/// `discreet.h`'s inversion carried into a *performed* effect. delay.h caps feedback +/// strictly below 1 so the loop is always contractive; discreet.h lets regeneration +/// reach exactly 1.0 because tape_loop.h `wear` (darken -> bounded saturation -> DC +/// block) is the stabilizer. Here regeneration is allowed to go *past* unity, into +/// deliberate sound-on-sound self-oscillation — the dub move, the reason anyone +/// reaches for this machine live — and it stays bounded for the same reason: +/// `vca::swing_shape` is bounded by 1/drive for any drive > 0, so whatever the loop +/// gain, the tape is bounded by |in|max + regen/drive and the output by the head +/// levels times that. Because that bound *only* exists while the saturator is +/// engaged, the cap is drive-dependent, applied per sample: +/// +/// drive > 0 : regen may reach k_regen_max_driven (howls, bounded) +/// drive = 0 : regen is capped at 1.0 (wear is then linear with |H| <= 1, so +/// 1.0 sustains and cannot grow — the discreet.h contract) +/// +/// Turning drive to 0 while howling therefore lands the loop at 1.0 rather than +/// letting it run away; the *target* keeps its high value and takes effect again +/// when drive returns. +/// +/// Geometry: prepare(sr, max_span_seconds) buys the worst-case tape once (4 s at +/// 48 kHz is ~1.5 MB of double tape). No later call allocates; setters only retarget +/// ramps and are safe while audio runs. Double-precision, per-sample, mono in / +/// stereo out. +/// +/// Honest limits: +/// - `set_span_ms` glides as a tape-speed change and audibly bends pitch while +/// moving — by design, inherited from discreet.h: moving the heads IS the doppler. +/// Use set_smooth_ms to choose how fast the motor changes speed. There is no +/// crossfading "digital" mode. +/// - The transport is periodic only (see tape_loop.h): deterministic, bit-exactly +/// reproducible, with no stochastic capstan drift. That is a family-wide decision, +/// not an oversight — changing it would break the family's bit-exact renders. +/// - Wow/flutter is a single position offset shared by every head. One motor moves +/// the whole tape path, so a speed error displaces all the heads together; the +/// per-head phase differences of a real transport are not modeled. +/// - Regeneration is taken from the same post-level head sum that feeds the output, +/// so a head's level is also its send into the loop (as the head selector on the +/// machines is). There is no separate feedback-source selection. +/// - The read floor is 2.5 samples (Hermite support) and reads are clamped so the +/// wow excursion can never cross the record head; extreme wow at very short spans +/// flattens against that clamp rather than wrapping. +/// - Heads sum with no master gain: four heads at unity can sum past unity, and gain +/// staging is the caller's job (the multitap contract). +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include + +#include "tape_loop.h" // tap::tools::tape — reel / wow_flutter / wear / ramp, the shared machinery + +namespace tap::tools { + namespace tapecho { + + constexpr int k_max_heads = 4; // four slots; a three-head layout is heads=3 + constexpr double k_min_span_ms = 1.0; // below this it is a comb, not an echo + constexpr double k_default_max_seconds = 4.0; // default worst-case buy (~1.5 MB @ 48k) + constexpr double k_default_span_ms = 375.0; // a plausible motor-speed default + constexpr double k_regen_max_driven = 1.5; // past unity: sound-on-sound, bounded by the saturator + constexpr double k_regen_max_linear = 1.0; // drive 0: |H_wear| <= 1, so 1.0 sustains, cannot grow + constexpr double k_default_regen = 0.35; // a few audible repeats + constexpr double k_default_darken_hz = 4000.0; + constexpr double k_default_drive = 0.5; // mild record-head saturation + constexpr double k_default_wow_ms = 0.4; // a smaller, faster transport than discreet.h's + constexpr double k_default_wow_hz = 1.2; + constexpr double k_default_flutter_ms = 0.03; + constexpr double k_default_flutter_hz = 11.0; + constexpr double k_default_mix = 35.0; // an effect in a chain, not a wet-only loop + constexpr double k_default_smooth_ms = 20.0; // anti-zipper ramp for setters + + /// One playback head: a position along the tape path, a level, and a place in the stereo + /// field, all slewed. Reads a reel it does not own (the machine owns the tape). + class head { + public: + head() { + m_ratio.snap(1.0); + m_level.snap(1.0); + m_pan.snap(0.0); + } + + /// Snap the ramps to their targets — a DSP restart is not a parameter move. + void prepare() { + m_ratio.snap(m_ratio.target()); + m_level.snap(m_level.target()); + m_pan.snap(m_pan.target()); + } + + /// Position along the head path as a fraction of the motor span, clamped to (0, 1]. + void set_ratio(double r, long smooth) { m_ratio.to(std::clamp(r, k_min_ratio, 1.0), smooth); } + + /// Linear level. Unclamped: negative flips polarity, as a mixer channel does. + void set_level(double lin, long smooth) { m_level.to(lin, smooth); } + + /// Equal-power pan, -1 (hard left) .. 1 (hard right). Endpoints are exact. + void set_pan(double p, long smooth) { m_pan.to(std::clamp(p, -1.0, 1.0), smooth); } + + double ratio() const { return m_ratio.target(); } + double level() const { return m_level.target(); } + double pan() const { return m_pan.target(); } + + /// Advance the ramps one sample WITHOUT reading. Disabled heads still tick, so + /// enabling one mid-glide continues its ramp instead of jumping (the count is a + /// mute, not a freeze). + void tick() { + m_ratio.tick(); + m_level.tick(); + m_pan.tick(); + } + + /// Advance the ramps and read: accumulate this head's panned contribution onto the + /// stereo busses and return its post-level mono value (what the regeneration path + /// sums). `span_samples` is the motor span; `offset` the shared transport error. + double read(const tape::reel& reel, long write_pos, double span_samples, double offset, double& out_left, + double& out_right) { + const double ratio = m_ratio.tick(); + const double level = m_level.tick(); + const double pan = m_pan.tick(); + + // Clamped so the Hermite support can never cross the record head (discreet.h). + const double span = span_samples * ratio - offset; + const double d = std::clamp(span, tape::k_min_frac_delay, static_cast(reel.capacity()) - 2.0); + const double g = level * reel.read_hermite(static_cast(write_pos) - d); + + // Equal-power with exact endpoints — the delay.h multitap law: a hard-panned head + // is bitwise absent from the far bus. + if (pan <= -1.0) { + out_left += g; + } + else if (pan >= 1.0) { + out_right += g; + } + else { + const double theta = (pan + 1.0) * 0.25 * tape::k_pi; + out_left += std::cos(theta) * g; + out_right += std::sin(theta) * g; + } + return g; + } + + private: + static constexpr double k_min_ratio = 0.001; // a head at the record head is not a head + + tape::ramp m_ratio; // (0, 1] of the motor span + tape::ramp m_level; // linear + tape::ramp m_pan; // -1..1 + }; + + /// The machine: one reel, one transport, one wear stage, k_max_heads heads. + class machine { + public: + /// Defaults are a tape echo, not a neutral bypass: four evenly spaced heads on a + /// 375 ms motor, a few repeats, gentle wear, the transport breathing. + machine() { + m_span_ms.snap(k_default_span_ms); + m_regen.snap(k_default_regen); + m_darken_hz.snap(k_default_darken_hz); + m_drive.snap(k_default_drive); + m_input_level.snap(1.0); + m_mix.snap(k_default_mix); + m_transport.set_wow(k_default_wow_ms, k_default_wow_hz); + m_transport.set_flutter(k_default_flutter_ms, k_default_flutter_hz); + for (int i = 0; i < k_max_heads; ++i) { + // Nominal even spacing along the path, the last head at the motor span. + m_heads[static_cast(i)].set_ratio(static_cast(i + 1) / k_max_heads, 0); + } + } + + // -- lifecycle ----------------------------------------------------------------------- + + /// (Re)allocate tape for `max_span_seconds` at `sr`, snap all ramps, erase the tape. + /// Not real-time-safe. + void prepare(double sr, double max_span_seconds = k_default_max_seconds) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_reel.prepare(m_sr, std::max(k_min_span_ms * 0.001, max_span_seconds)); + m_transport.prepare(m_sr); + m_wear.prepare(m_sr); + m_span_ms.snap(std::min(m_span_ms.target(), max_span_ms())); + m_regen.snap(m_regen.target()); + m_darken_hz.snap(m_darken_hz.target()); + m_drive.snap(m_drive.target()); + m_input_level.snap(m_input_level.target()); + m_mix.snap(m_mix.target()); + for (auto& h : m_heads) { + h.prepare(); + } + m_wear.set_cutoff_hz(m_darken_hz.current()); + m_wear.set_drive(m_drive.current()); + clear(); + } + + /// Erase the tape and the wear/transport state; parameters are untouched. The eject + /// button — it is also how you stop a self-oscillating loop instantly. + void clear() { + m_reel.clear(); + m_wear.clear(); + m_transport.clear(); + m_write = 0; + } + + bool prepared() const { return m_reel.prepared(); } + + // -- parameter targets (click-free; safe while audio runs) --------------------------- + + /// Motor speed as the delay of a ratio-1.0 head, in ms, clamped to [k_min_span_ms, + /// the prepared max]. Slewed — and the slew IS the varispeed doppler. + void set_span_ms(double ms) { + m_span_ms.to(std::clamp(ms, k_min_span_ms, max_span_ms()), smooth_samples()); + } + + /// Number of active heads, clamped to [0, k_max_heads]. A mute, not a freeze: inactive + /// heads keep ramping, so enabling one mid-glide does not jump. + void set_heads(int count) { m_num_heads = std::clamp(count, 0, k_max_heads); } + + /// Per-head position along the path, (0, 1] of the motor span, slewed. 0-based index. + void set_head_ratio(int head, double ratio) { + if (valid_head(head)) { + m_heads[static_cast(head)].set_ratio(ratio, smooth_samples()); + } + } + + /// Per-head linear level, slewed. Also the head's send into the regeneration path. + void set_head_level(int head, double lin) { + if (valid_head(head)) { + m_heads[static_cast(head)].set_level(lin, smooth_samples()); + } + } + + /// Per-head equal-power pan, -1..1, slewed. Endpoints are bitwise exact. + void set_head_pan(int head, double pan) { + if (valid_head(head)) { + m_heads[static_cast(head)].set_pan(pan, smooth_samples()); + } + } + + /// Regeneration into the record head, clamped to [0, k_regen_max_driven], slewed. + /// Values above 1.0 self-oscillate and are only reached while drive > 0 (see the + /// header banner: the saturator is what bounds them). + void set_regen(double r) { m_regen.to(std::clamp(r, 0.0, k_regen_max_driven), smooth_samples()); } + + /// Per-pass darkening corner in Hz (tape_loop.h wear band), slewed. + void set_darken_hz(double hz) { + m_darken_hz.to(std::clamp(hz, tape::k_darken_floor_hz, tape::k_darken_ceil_hz), smooth_samples()); + } + + /// Record-head saturation drive, >= 0, slewed. 0 is exactly linear — and caps the + /// effective regeneration at 1.0 for as long as it stays there. + void set_drive(double d) { m_drive.to(std::max(0.0, d), smooth_samples()); } + + /// Input level into the record head, linear, slewed. Fading this while the loop + /// self-oscillates is the sound-on-sound performance move. + void set_input_level(double lin) { m_input_level.to(lin, smooth_samples()); } + + /// Dry/wet mix 0..100, equal-power, slewed. 0 is bitwise dry on both busses, 100 wet. + void set_mix(double pct) { m_mix.to(std::clamp(pct, 0.0, 100.0), smooth_samples()); } + + /// Wow: depth in ms of tape position, rate in Hz. Instant transport config, not ramped. + void set_wow(double depth_ms, double rate_hz) { m_transport.set_wow(depth_ms, rate_hz); } + + /// Flutter: the faster, shallower partner. Instant transport config, not ramped. + void set_flutter(double depth_ms, double rate_hz) { m_transport.set_flutter(depth_ms, rate_hz); } + + /// Anti-zipper ramp time for the setters, in ms. 0 = instant (useful for tests). + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + double span_ms() const { return m_span_ms.target(); } + int heads() const { return m_num_heads; } + double head_ratio(int head) const { + return valid_head(head) ? m_heads[static_cast(head)].ratio() : 0.0; + } + double head_level(int head) const { + return valid_head(head) ? m_heads[static_cast(head)].level() : 0.0; + } + double head_pan(int head) const { + return valid_head(head) ? m_heads[static_cast(head)].pan() : 0.0; + } + double regen() const { return m_regen.target(); } + double darken_hz() const { return m_darken_hz.target(); } + double drive() const { return m_drive.target(); } + double input_level() const { return m_input_level.target(); } + double mix() const { return m_mix.target(); } + double wow_depth_ms() const { return m_transport.wow_depth_ms(); } + double wow_rate_hz() const { return m_transport.wow_rate_hz(); } + double flutter_depth_ms() const { return m_transport.flutter_depth_ms(); } + double flutter_rate_hz() const { return m_transport.flutter_rate_hz(); } + double smooth_ms() const { return m_smooth_ms; } + double max_span_ms() const { return static_cast(m_reel.capacity()) * 1000.0 / m_sr; } + double samplerate() const { return m_sr; } + + // -- audio --------------------------------------------------------------------------- + + void process(double in, double& out_left, double& out_right) { + if (!prepared()) { + out_left = out_right = in; + return; + } + const double span = m_span_ms.tick() * 0.001 * m_sr; + const double regen = m_regen.tick(); + const double darken = m_darken_hz.tick(); + const double drive = m_drive.tick(); + const double send = m_input_level.tick(); + const double mix = m_mix.tick(); + + if (darken != m_wear.cutoff_hz()) { + m_wear.set_cutoff_hz(darken); + } + if (drive != m_wear.drive()) { + m_wear.set_drive(drive); + } + + // One motor: a single transport error displaces every head together. + const double offset = m_transport.tick(); + + double wet_left = 0.0; + double wet_right = 0.0; + double head_sum = 0.0; + for (int i = 0; i < k_max_heads; ++i) { + head& h = m_heads[static_cast(i)]; + if (i < m_num_heads) { + head_sum += h.read(m_reel, m_write, span, offset, wet_left, wet_right); + } + else { + h.tick(); // muted, not frozen + } + } + + // Past unity only while the saturator is there to bound it (header banner). + const double regen_eff = std::min(regen, (drive > 0.0) ? k_regen_max_driven : k_regen_max_linear); + + // The return path: head sum -> wear (darken, saturate, DC block) -> record head. + m_reel.write(m_write, send * in + regen_eff * m_wear.process(head_sum)); + if (++m_write >= m_reel.capacity()) { // keep the head in [0, capacity): a long can + m_write = 0; // overflow in half a day of audio on LLP64 + } + + // Equal-power dry/wet with exact endpoints (delay.h law: 0 bitwise dry, 100 wet). + if (mix <= 0.0) { + out_left = out_right = in; + return; + } + if (mix >= 100.0) { + out_left = wet_left; + out_right = wet_right; + return; + } + const double theta = mix * 0.01 * (tape::k_pi * 0.5); + const double dry_g = std::cos(theta); + const double wet_g = std::sin(theta); + out_left = dry_g * in + wet_g * wet_left; + out_right = dry_g * in + wet_g * wet_right; + } + + /// Block form: the trivial loop over the scalar path. + void process(const double* in, double* out_left, double* out_right, size_t n) { + for (size_t i = 0; i < n; ++i) { + process(in[i], out_left[i], out_right[i]); + } + } + + private: + static bool valid_head(int head) { return head >= 0 && head < k_max_heads; } + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double m_sr{48000.0}; + double m_smooth_ms{k_default_smooth_ms}; + int m_num_heads{k_max_heads}; + long m_write{0}; + tape::reel m_reel; + tape::wow_flutter m_transport; + tape::wear m_wear; + std::array m_heads; + tape::ramp m_span_ms; // ms, the motor + tape::ramp m_regen; // 0..k_regen_max_driven + tape::ramp m_darken_hz; // Hz + tape::ramp m_drive; // >= 0 + tape::ramp m_input_level; // linear + tape::ramp m_mix; // 0..100 + }; + + } // namespace tapecho +} // namespace tap::tools diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index 13b2c37..b6a1835 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -26,6 +26,7 @@ #include "svf.h" #include "swing_vca.h" #include "tape_loop.h" +#include "tapecho.h" #include "tb303_voice.h" #include "tr808_clap.h" #include "tr808_cowbell.h" diff --git a/notebooks/tapecho.ipynb b/notebooks/tapecho.ipynb new file mode 100644 index 0000000..61b81f7 --- /dev/null +++ b/notebooks/tapecho.ipynb @@ -0,0 +1,506 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e0fd4fc0", + "metadata": {}, + "source": [ + "# tap.tapecho~ — the echo, measured\n", + "\n", + "The multi-head tape echo of the Copicat / Space Echo school (`taptools/tapecho.h` over the\n", + "shared `taptools/tape_loop.h`): one record head, a span of moving tape, several playback heads\n", + "at fixed positions along it, and a regeneration path from the heads back to the record head.\n", + "\n", + "Two claims carry the kernel, and both are measured below. The first is structural — **this\n", + "kernel is composition, not construction**: with the tape path neutralized it is *bitwise* the\n", + "plain Hermite multitap of `delay.h`, which is what makes \"`tape_loop.h` is a library\" a\n", + "measurement rather than a slogan. The second is the design statement — **regeneration is\n", + "allowed past unity** into deliberate sound-on-sound self-oscillation, bounded by the\n", + "saturator (`vca::swing_shape`, ≤ 1/drive) rather than by a feedback cap, and capped back to\n", + "1.0 the moment drive leaves.\n", + "\n", + "Every trace drives the **shipping C++** through `tools/capi` via ctypes.\n", + "\n", + "Sections: **1** the head layout · **2** the null test against `delay.h` · **3** generation loss\n", + "per pass · **4** past unity, and the bound that holds it · **5** the transport" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "16bf109b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T22:30:09.685955Z", + "iopub.status.busy": "2026-08-15T22:30:09.685744Z", + "iopub.status.idle": "2026-08-15T22:30:10.114754Z", + "shell.execute_reply": "2026-08-15T22:30:10.113199Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def echo(**params):\n", + " # A machine with the transport parked and the wear path neutral: sections opt in.\n", + " base = dict(smooth_ms=0, wow=(0, 0), flutter=(0, 0), regen=0.0, drive=0.0,\n", + " darken_hz=20000.0, input_level=1.0, mix=100)\n", + " base.update(params)\n", + " return tap.TapEcho(sr, 4.0, **base)\n", + "\n", + "def goertzel(x, f):\n", + " n = np.arange(x.size)\n", + " return 2.0 * np.abs(np.dot(x, np.exp(-2j * np.pi * f * n / sr))) / x.size" + ] + }, + { + "cell_type": "markdown", + "id": "21ef350f", + "metadata": {}, + "source": [ + "## 1 · The head layout\n", + "\n", + "`span_ms` is the motor: the delay of a head at the far end of the path (ratio 1.0). Every other\n", + "head sits at `span_ms * ratio`, so moving the motor moves the whole layout together, as a tape\n", + "speed does. The defaults are four evenly spaced heads — 0.25, 0.5, 0.75, 1.0 — a nominal layout\n", + "chosen because it is neutral and audibly \"a tape echo\"; real machines' head positions vary by\n", + "model and unit and none are claimed as measured here.\n", + "\n", + "An impulse into a 400 ms span, no regeneration, shows the four returns exactly on their\n", + "positions. (Pinned by the kernel scenario *\"each head echoes at its own position along the tape\n", + "path\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7b0be83b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T22:30:10.117877Z", + "iopub.status.busy": "2026-08-15T22:30:10.117520Z", + "iopub.status.idle": "2026-08-15T22:30:10.283670Z", + "shell.execute_reply": "2026-08-15T22:30:10.282378Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "head 0 (ratio 0.25): return at 100.000 ms, level 0.707106781 (centre-pan law cos(pi/4) = 0.707106781)\n", + "head 1 (ratio 0.50): return at 200.000 ms, level 0.707106781 (centre-pan law cos(pi/4) = 0.707106781)\n", + "head 2 (ratio 0.75): return at 300.000 ms, level 0.707106781 (centre-pan law cos(pi/4) = 0.707106781)\n", + "head 3 (ratio 1.00): return at 400.000 ms, level 0.707106781 (centre-pan law cos(pi/4) = 0.707106781)\n" + ] + } + ], + "source": [ + "span = 0.400\n", + "m = echo(span_ms=span * 1000, heads=4)\n", + "x = np.zeros(int(0.6 * sr)); x[0] = 1.0\n", + "left, right = m.process(x)\n", + "\n", + "t = np.arange(left.size) / sr\n", + "fig, ax = plt.subplots()\n", + "ax.plot(t, left, color=C[0], lw=0.8)\n", + "for i in range(4):\n", + " ax.axvline(span * (i + 1) / 4, color=C[3], lw=0.8, ls=\":\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"output (left)\")\n", + "ax.set_title(\"impulse → four heads at 0.25 / 0.5 / 0.75 / 1.0 of a 400 ms span (dotted)\")\n", + "plt.show()\n", + "\n", + "for i in range(4):\n", + " k = int(span * (i + 1) / 4 * sr)\n", + " print(f\"head {i} (ratio {(i + 1) / 4:.2f}): return at {k / sr * 1000:7.3f} ms, \"\n", + " f\"level {left[k]:.9f} (centre-pan law cos(pi/4) = {np.cos(np.pi / 4):.9f})\")" + ] + }, + { + "cell_type": "markdown", + "id": "d65ae534", + "metadata": {}, + "source": [ + "## 2 · The null test — the echo *is* the multitap of `delay.h`\n", + "\n", + "Neutralize the tape path (no transport error, no wear in play because there is no regeneration)\n", + "and a one-head echo must reduce to the plain fractional delay this library already had. It does,\n", + "**bitwise** — same Hermite read at the same fractional position under the same equal-power pan\n", + "law — for a span deliberately chosen not to be a whole number of samples.\n", + "\n", + "This is the load-bearing structural claim: the tape echo adds a head layout, a transport, and a\n", + "worn regeneration path *on top of* machinery that is shared, not reimplemented. Both objects are\n", + "reached here through the same C ABI, so the comparison crosses the same boundary the Max\n", + "externals do. (Pinned by *\"with the tape path neutral, a one-head echo is bitwise the multitap\n", + "of delay.h\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "174b4833", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T22:30:10.286018Z", + "iopub.status.busy": "2026-08-15T22:30:10.285778Z", + "iopub.status.idle": "2026-08-15T22:30:10.312024Z", + "shell.execute_reply": "2026-08-15T22:30:10.310993Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "left bitwise identical: True max |diff| = 0.0\n", + "right bitwise identical: True max |diff| = 0.0\n", + "and not vacuous — both are non-trivial signals: rms = 0.3367\n" + ] + } + ], + "source": [ + "span_ms = 137.31 # deliberately not a whole number of samples\n", + "rng = np.random.default_rng(2463534242)\n", + "x = rng.uniform(-1, 1, int(0.5 * sr))\n", + "\n", + "e = echo(span_ms=span_ms, heads=1, ratios=[1.0], levels=[1.0], pans=[0.0])\n", + "el, er = e.process(x)\n", + "\n", + "ref = tap.Multitap(sr, 1000.0, smooth_ms=0, taps=1)\n", + "ref.set(times=[span_ms], gains=[1.0], pans=[0.0])\n", + "rl, rr = ref.process(x)\n", + "\n", + "print(f\"left bitwise identical: {np.array_equal(el, rl)} max |diff| = {np.max(np.abs(el - rl))}\")\n", + "print(f\"right bitwise identical: {np.array_equal(er, rr)} max |diff| = {np.max(np.abs(er - rr))}\")\n", + "print(f\"and not vacuous — both are non-trivial signals: rms = {np.sqrt(np.mean(el ** 2)):.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "788641da", + "metadata": {}, + "source": [ + "## 3 · Generation loss, one pass at a time\n", + "\n", + "Each trip through the regeneration path is one pass of `tape_loop.h`'s `wear`: a darkening\n", + "one-pole lowpass, the bounded soft saturator, then the normalized DC blocker. At drive 0 the\n", + "saturator is exactly linear, so the per-pass ratio is precisely `regen * |H_wear(f)|` and can be\n", + "predicted analytically — the same formulas the kernel applies, computed independently here.\n", + "\n", + "A two-tone burst (one tone well above the darkening corner, one well below) through a one-head\n", + "echo shows both sides of the tilt: the highs die fast, the lows barely fade. That is the honest\n", + "tape story — wear is a tilt, not a fader." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5fb96772", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T22:30:10.314444Z", + "iopub.status.busy": "2026-08-15T22:30:10.314131Z", + "iopub.status.idle": "2026-08-15T22:30:10.528183Z", + "shell.execute_reply": "2026-08-15T22:30:10.527019Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu0AAAE9CAYAAAC/aFzVAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAOxAAADsQBlSsOGwAAcCJJREFUeJzt3XlcVFX/B/DPzLCvM4IgLiiKiuCCyOC+AZpbpuZuPaWVPZllu6VZv57SrKd9saTF1sdyScvMUkEU92FRFERFRWVfnGFfZ+7vD2RkYIABgRng8369eOnce+fec+9whu8995zvEQmCIICIiIiIiEyW2NgFICIiIiKi+jFoJyIiIiIycQzaiYiIiIhMHIN2IiIiIiITx6CdiIiIiMjEMWgnIiIiIjJxDNqJiIiIiEwcg3YiIiIiIhNnZuwCEJFp+eGHH2Bra4v777+/XR+TWp4gCFi/fj2mTJkCf3//ZttvSEgI3NzccO+99zbbPpuitLQU4eHhSEhIQKdOnTBy5Eh4enrq3TYjIwN//vknVCoVhgwZgqCgIIhEohbfrrqkpCT89NNPmD9/Pvr161dr/bvvvosBAwYY/bq2FQqFAseOHYOFhQUmT55c52dfU3l5Ofbt24eLFy+iU6dOmDZtGtzc3Fq4tNQesKWdqIP69ttvsWvXrlrLQ0JCsHXr1lYtizGOSS1PrVZj3bp1OHnyZLPu95NPPsHOnTubdZ+N9dNPP6FHjx546qmncPXqVfzxxx/w8fHBSy+9VGvb/fv3o2/fvti9ezdu3ryJBx54APfeey/Ky8tbdLuaEhMTsW7dOsTHx+td/5///Mfo17WtWLVqFYKCgnDx4kUcP34cAwcOREhISIPvS0lJwdChQ/HUU0/h+vXr2LFjBzw9PbF79+6WLzS1fQIRdUjDhg0TFixYUGt5SEiIsHXr1lYty+jRo4X777+/VY9JLa+8vFwAIHz66afNul8fHx/hoYceatZ9Nta///1vYe3atUJFRYV22S+//CIAELZt26ZdlpubKzg5OQn//ve/tcsSExMFKysrYf369S22nT4HDhwQAAi7du3Su97W1tbo17Ut2LFjhwBAOHTokHbZe++9J5iZmQkXL16s971Tp04VXF1dhezsbO2yZ555RrC1tRXS0tJaqsjUTrB7DFEdsrKy8Pvvv6OwsBCTJ0+Gl5eX3kf9Go0GBw8exPnz52FhYYFJkyahf//+Ovuqepw/Y8YM/P3334iLi0P//v0xY8aMWo+0G7u/f/75B7GxsZgzZw48PT2xc+dOXLhwAQBgZWWFXr16YfLkyXBwcNC+/8svv0RaWhrKysrw1ltvAQCGDh2K6dOnw9LSEubm5jrHKyoqwl9//YVr167ByckJ06ZNQ5cuXZp8joYw5JgAcOTIEcTGxsLCwgIBAQHw9fVt1Pqaqs5j+vTp+PPPP3Hp0iV4e3tj6tSpzf5Z3c3xDfmcW+oa1SU7Oxu7d+/W1pm+ffvW2sbQcjf2usXFxWHXrl2YOHEiRo8eDQC4du0aDh48CJVKhX79+mH69OkwM7vzZ+/MmTP4888/8eKLLyI9PR1//PEHzM3NMWvWLL2/a9W98MIL6NOnj86y+fPnY9myZdi3bx/mzZsHANixYwdycnLw3HPPabfr06cPZs6cic2bN2PNmjUtsl1zePfdd1FWVlZruVQqxcqVKw3eT83rvHfvXjg6OmLJkiXabY4cOYLo6GiIRCKMHz9e7+9gbm4udu/ejVu3bmH8+PHw8/PDBx98gGHDhmH8+PE62za0v59//hlisRiLFi1CeHg4oqKi0LNnT8yaNUvnd0SfzZs3w8/PDxMmTNAue+KJJ7Bu3Tp88803eOedd/S+Lzc3F//88w+ee+45ODk5aZevWrUKH330EX744Qe9T2qIqrB7DJEeUVFR6N+/Pz7//HNcuXIFjz32GLZv317rUX9KSgr8/f2xbNkyXLp0CSdPnsSQIUPw/vvv6+yv6nH+smXL8MMPP+DSpUtYsGABHn74YZ3tGrO/HTt2YNGiRfjuu++Ql5cHtVoNoLK/ZElJCUpKSpCamor3338fnp6eOuUuLS2FIAhQq9XabaserdfsqhIXFwcvLy+sW7cON27cwHfffYfevXvXeoxu6DkawpBjajQazJo1CwsWLEBcXBxiY2Px6KOP4sknnzRofV2qru2CBQvwyy+/4MKFC1i0aBFmzpypvcZA83xWd3N8Qz7nlrpG+sTExKB///749NNPkZiYiGXLluG3336rtZ0h5W7sdTt69CjGjh2LhIQEBAQEAADefPNN9O/fH3/++Sdu3ryJF198EcOHD0dOTo72fZGRkVi3bh3+/vtvLF68GJcvX8aXX34Jb29vXLlypd7zrRmwA0B+fj7Kysp0bq6OHTsGqVRa6wZm5MiRuHHjBpKTk1tku+ZQWlqq/axKSkpQWFiIDRs24IMPPmjUfqqu8++//44FCxbgypUr2u8bpVKJiRMn4v7778f58+dx9uxZjBkzplbwmpiYCB8fH2zcuBFXr17FCy+8gM2bN2PDhg04cOCAdjtD97dlyxZ8//33ePHFF/HJJ58gMTERjz32GGbMmFHvuQiCgOPHj2t/z6rY2Nhg8ODBOHbsWJ3vTU9Ph0ajQffu3XWWV72OiIio99hE7B5DpIdcLhcmTJgglJWVCYIgCGq1Wnj00UdrPeofP3680L9/f0GpVGqX7dixQxCLxUJUVJR2mY+Pj9C5c2dh9+7d2mU//PCDIBKJhLi4uCbtz8nJSfjtt98MOp8lS5YIw4YN01lWV/eY6l1VNBqNMHDgQMHPz08oLCzUbrN06VLBxsZGSE5ObvQ56tOUYx47dkwAIMTGxurs6/jx4watr0vVtd2xY4d2WVRUlCAWi4VvvvlGu6ylPitDj69Pzc+5pa6RPsOHDxfGjRsnlJaWCoIgCBUVFcJDDz1kUPcYfb+f9V236t1jdu3aJVhZWQnPPfecoNFotMsACP/73/+078nPzxe8vLx0un989dVXAgBhyZIl2rpeVFQkdO/eXVi+fHmjr8Fbb70lABB+/fVX7bLg4GDBx8en1ra//vqrAEA4duxYi2ynT1X3mMWLFwtvvvlmrR8LC4t6u8c8++yzAgBhy5YtdW6jT9V1XrBggfY6V1mwYIHg6uoqpKamapdFREQIAIR9+/Zpl82YMUMYPHiwUFBQoFMeKysrYe3atY3eX1BQkNC5c2dh8+bN2mX79+8XAAhhYWF1nkt2drYAQHjzzTdrrZs9e7bQo0ePBt/70ksv6Sy/fv26AEAYNGhQne8lEgRBYEs7UQ2xsbFQKBR47rnntN1ExGIxli5dqrNdXFwcDh8+jNWrV0MqlWqX33///XB3d8fPP/+ss32XLl1w33336WwnCIK2hbGx+3NycsLs2bP1nsPNmzfxv//9D++++y7eeustFBUV4ezZsw0OVKspKioK58+fx/PPPw8bGxvt8tdffx1FRUX45ZdfGnWOzXnMgoICAJXdmKobOXKkQevr4+zsrJPJxs/PD1OmTNEONGvOz6opx6/S0OfckteounPnzuHUqVN47rnnYGFhAQCQSCR45JFH9G5v6O9nQ9ctJCQE8+bNwxtvvIH3339f28L9+eefY/DgwVi0aJF2Wzs7Ozz++OP49ddfa3X5WLZsmbauW1tbY8qUKThx4kSjroFCocB//vMfjBkzBnPnztUuLyoqgqWlZa3traystOtbYrv6VH/aUf1HEIQ63/PDDz/gww8/xDPPPNOkp2cA8NBDD+l0vcvKysK2bduwatUqnewpY8aMwfDhw/Hjjz8CuJMpZ+XKlbC1tdVut3LlSpSUlDR6f1Vq/o5OmjQJ9vb29X72Vde3rs+gvuvv5OSEMWPG4Oeff0ZeXp52+aZNm3T2TVQX9mknquHy5csAUKtvcs3XsbGxAIDTp08jJSWl1n5qPl738vLSeW1jYwM7OzukpqY2y/6qfPjhh1izZg0CAwPh5eUFa2trqNVqVFRUIDc3F87Oznrfp8/FixcBAD4+PjrLe/bsCTs7O+16Q8+xOY85YcIEBAQEYPLkyZg4cSImTZqEadOmYeDAgQatr4+3t7feZd9++y2A5vusmnp8wLDPuSWvUXVVdWbAgAENnkdjfj/ru25//fUXvv/+e3z00UdYtWqVzrrY2Fh06dJFO16jSnx8vLZbTq9eveo8TpcuXRr1O3vt2jXMnDkTXbt2xbZt2yAW32kPs7a2Rm5ubq33lJaWate3xHb1Wbx4MWbNmlVr+UcffaR3+1OnTmH58uUIDg7Ge++91+D+61LzOp8/fx6CICA+Pr7WZ1VYWKitR4mJiQBqfwd7eHhobxIbs78qffv2hUQi0Vnm6upa72dfdX2rrnd1paWlDV7/r776CkFBQRg2bBhmzZqFK1euIDo6Gn369IG9vX297yViSztRHWoOOqz+hxiATv/ami1WS5YswZw5c3S2r95qXEUikaCioqJJ+5PJZLX2l5aWhhdffBHvvPMO9u7di/fffx9vvfWWzoCpxqhqeat57kDl9anZMtfQOTbnMS0sLHD06FFs27YNHh4e+PLLLzFo0CA8+uijBq2vj76Bs9WP3Ryf1d0c39DPuSWvUXVV5apZ7pqvG/v7Wd91GzRoEHr16oUtW7YgOztbZ51arYaZmVmtz6Z3795Yu3Yt7OzsdLav+XvbmN/ZrKws3HPPPRAEAfv376+Vb7tHjx5IS0ur9b6qwNDd3b1FtmsuqampmD17Nnr06IFt27bVCnIbo+bnWV89uu+++/Dggw/qbF9XvWjq/pryfeXk5AQbG5s6P4OGrr+XlxcSEhKwbt062NvbY+rUqThz5gwkEonem1yi6tjSTlRD1QCzS5cu6Qz2unTpks52VV+wkyZNqhWkNUVz7C8+Ph5qtRrBwcE6y2NiYmptqy8orqlqApYLFy5g0KBB2uXJycnIz8/XO0HL3WrMMc3NzTFnzhzt9dqwYQPWrl2LlStXwtfXt8H1dUlISNC7rCpzSXN/9o09fmM+55a6RtVVlevixYs6dabmeTSm3A3p0aMHtmzZgokTJyIoKAihoaHaVvqqz6dma2tzKygowLRp05CVlYXw8HC92XJGjRqF7777DleuXNEZvHrq1Cl069YNPXr0aJHtmkNpaSlmz56NgoICHDx4sNE3nw2pejIzcuRIrFixos7tqn8njx07Vrv8xo0bOi3ehu7vbohEIowYMQKnT5/WWV5SUoLY2Fj8+9//bnAf9vb2+Ne//qV9ff36dVy+fBlvvvlms5eX2he2tBPVMGTIEAwdOhSffPKJtuVGEAR89913Otv5+flh5MiR+M9//oP8/Hyddenp6douA4Zqjv1169YNQGWKtSrnzp3DwYMHa23r4uJSqy9zTf7+/ujfvz8+/PBDnT+OGzZsgKWlJRYsWNBgmRrL0GMmJCQgMzNT571VwZqlpWWD6+uTlpaGvXv3al/HxcVh37592v6vzf3ZN/b4hn7OzXGNoqOj8dZbb+H69et1lnfw4MHw8/PDxx9/rG2lFARBpztPY8ptKHd3d4SHh6OwsBCBgYHa3+cnn3wSERER+OOPP3S212g09Wb3aIyysjLMnj0b8fHx2Lt3L4YMGaJ3u7lz50IqleLjjz/WLrt+/Tp+//13nScazb1dc3jsscegUCjw008/1dkKvHHjRmzfvr1J++/WrRtmzZqFd999t9bTEqVSifPnzwOo7K40ZcoUbNq0SacP+xdffKHty9+Y/d2txx57DJGRkTh+/Lh22VdffYWSkhIsW7ZMu+z48eN46623dL5nL1++jOLiYu1rtVqNVatWwc/PjzNCU4PY0k5Ug0gkwqZNmzB58mSMGTMG48aNg0KhwLJly/Dll1/qtFBv27YNM2fOhJeXF2bOnAlHR0dcvHgRZ8+exU8//aS35a0+d7s/Ly8vPPjgg1i+fDmOHz+O8vJyREZG4rnnnsOLL76os+3s2bPx73//GytWrEDXrl21edqrE4vF2Lp1K6ZOnYrhw4dj8uTJOHv2LMLDw/H11183+6P4xhwzIyMD06ZNg6+vL7y8vKBSqfDLL7/gsccew4ABA3D48OF619dnxowZCAkJwW+//QZra2ts3boV48aN0/mD3NyffWOOb+jn3BzX6PTp01i3bh3Gjh2Lnj176i1v9TozevRojB8/HqdOncKjjz6Kb775RrtdY34/DdWjRw+Eh4dj4sSJCAwMRGhoKBYsWICLFy9i7ty5mDp1Knx8fJCRkYHjx48jODhYm8f9brzyyis4ePAgJk2ahLCwMISFhWnXeXh4aHOQy2QyfPfdd1i0aBHS0tLQp08f/PzzzxgxYgRefvll7Xuae7u7dfnyZfz444/w9vZGbGysdhwHoJun/f/+7/8wdepUbV76xvrmm28wZ84c9O/fH3PmzEHnzp2RmJgIhUKBzz77TDu+4sMPP8T48eMxfPhw3HPPPYiLi8M999wDW1tbne9kQ/d3NxYuXIiDBw9i2rRpWLp0KfLz8/Hjjz/i/fff1xmLc+TIEaxbtw6zZs1C586dAQBJSUmYNWsWJkyYADs7O/z555+wsrLCnj177qrrEXUMIqG+4eJEHVhqaip27tyJwsJCTJkyBZ06dULPnj3xyy+/6LQwazQahIaGIjo6GmKxGF5eXpg8ebJOa+6nn36Kbt261epKsX79eowcORKBgYHNsr8qe/fuxdmzZ9GlSxfMmzcPV69exfbt27FmzRqdfpwHDx7E6dOnUVxcrB0Y9dVXX8He3h4LFy7UbpeXl4fdu3cjKSkJTk5OmDFjRq0ArjHnWFNTj1lSUoJ//vkHFy5cgK2tLUaPHg0/Pz+D1+szcOBA+Pv746uvvsLOnTtx+fJleHt7Y/bs2bW6FDXHZ3U3xzfkc77ba/T888/jxx9/RFJSkt4+wNWlpaVhx44d2smVfH198dprr+Hee+/F8OHDG1Xu+q6bvnWpqan44osv4O3trc0ak5SUhH/++QeZmZno3r07xo4dqzM5U1RUFHbt2oVXX31Vp8U2LCwMJ06cwNq1a+s8119++aXOlltPT89aGVZu3LiB33//Hbm5uRgyZAimT5+ut4tac29X3ZUrV7BlyxYsWbJE743rm2++CR8fH8yZMwfZ2dl1DkyVyWR4/vnncfPmTbi7uyMkJASPPfZYncet6zpXFxERgVOnTqGiogL9+vXD5MmTa409yMnJwfbt23Hr1i1MmDABfn5+sLW1xQcffFBrMHJD+/vuu+8gFot1uqkAwMcffwwPDw/MnDmzzvOpcuTIERw7dgwWFhaYMmVKrcHzERER+Oeff/D000/DxcVFuzw1NRV79uyBUqmEr68vJk2axICdDMKgnUiP69evo3PnzjpByquvvop33nkH169fR9euXY1YOmpJVUFzze5QHeX4Nfn7+2PevHlYvXq1sYtCJuann37C2rVrkZiYWGsW5eaWlpYGa2trnRSrn332GZ566imcPXsWgwcPbtHjE5kCdo8h0iM9PR2TJ0/GuHHj4OTkBIVCgfDwcHz44YcM2KnDEAQBM2bMaNIMqdT+OTs746uvvmrxgB2onG12/PjxGDVqFLp27YrY2Fj89ddfWLt2LQN26jDY0k5Uh4yMDPz999+4fv06nJ2dcc899+idupzal8Z2Z2lvxycyVUqlEvv27cOVK1cglUoRGBhYq0sKUXvGoJ2IiIiIyMQx5SMRERERkYlj0E5EREREZOIYtBMRERERmThmj9FDo9FApVLBysoKIpHI2MUhIiIionZKEASUlJRAKpXWO98Cg3Y9VCoVnJycjF0MIiIiIuogcnJy0KlTpzrXM2jXo2rGtpycHFhbW7fqsQVBQEZGBlxdXdnKT1QP1hUiw7CuEBnGWHWluLgYTk5Odc4YXIVBux5VH5S1tbVRgvaq4/LLlahurCtEhmFdITKMsetKQ8fkQFQiIiIiIhPHoJ2IiIiIyMSxe4wJ0JSkQyjLBQAUFJcjKzUH1qJs2FmbAwBEFo4QW3UxZhGJiIiIyIgYtBuZpiQdeaGjAHWxdlkPAEIykF+1QGINh6DjDNyJiIiIOih2j6kmJCQE/v7+GD16dKsdUyjL1QnY9VIXa1viiYiIiKjjYdBezfLlyxEZGYljx44ZuyhERERERFrsHmNkhSUVBm2Xf3ETLO27QSSxAsSWt/+1gkhipXcZJFYQiS11/xXxHo2IiIioLWLQbmT5hWrYGrJh2jaUpt3lwcQW1QJ9y9v/twTE1rcDfUuIxLf/rX4DcHu7hm8Obr/W2c6SeYGJiIiI7hKDdiOzt5VAY8B24Vlz0c2tMzy6ADYW5YC6BIK6BNCUVv6rLoWgKb79b8nt9aWA5s6/0JQBmjIIFXkQWvzMqhFXv0mocXMgtr4d6Fe7ibh9A1D9huHOzYF17ZsCPU8dILbgzQIRERG1GwzajczWyuxOlph67L4YjJtRvQAAgz1tESiXYdxQRzjaGfYRCoLmdoBfLZBXl1QL8KvdAGgqX+su011X+d7SajcHxTrb6d4o3D4OclvxZkGke1NQ9TRA5+bAutrNg+4Ng94nBhLrWt2Oaj51gMiMNwstqHp6VAECREU5UOerIELlNWd6VCIiaq8YtLcRK+d1w19nHXHiXB5iEwsRm1iIz7alQO5tj0C5FCMHOcDaUlLn+0Ui8e1WautWLPXtmwXtzUHNG4DiajcP9dwUaG8OimvfRNx+wnDn/5X/Qqj2NKIcrXizIK52c1DjqYBO9yPdG4Y7XZKsazxZ0H3CUGucgsS6cv/i9l+V9aVHtQRQUH0jpkclIqJ2qv3/pTdxIgtHQGJdf9pHiTX8BnWHv7wLCovVOHY2F2GRKkRdyMeJc3k4cS4PVpZijB7sgKAAGYZ52cNMYhqtvSKRGDCzgQg2rXpcQVNR4+lA9RuAYgi1ltX11KHq5qC42o1FzS5J1Z4sCGpAXQRBXQRA2Xo3CyKzGjcHd7od6d4c1NXtyOr2e3S7HemObaj51MESIlHdN4rNrVHpURm0ExFRO8Og3cjEVl3gEHRcZ0bUGyk5cO/mpHdGVFtrCSaP6ITJIzrhVl45DkepEKpQ4UJSEUIVlf93tJNgvJ8UwXIZvHvbdMjuGiKxGSA2g8jMoGG+zabyZqH604I7Txi0Nwz13BTUfMIgqIv1dEUqqfVUAkIFoK6AoC6sLEdrnbDIvEbLf/XuRZZ6xjNY6RnsbKn3hkGnq5LYEppyzlVAREQdl0gQhFYdk9gWFBcXw8bGBkVFRbC2bu3uJAIyMjLg6uraqGA7NasUYZEqhJ5W4kZGqXZ5FycLTPSvDOB7dbVqiSKTkQmCcLs7UNXNQe0bBkO7Hd1ZVu09Ok8WSnSeSpgiidQPIstOem4eamZCqj62wbKOG4pqGZKYCYnaqKb+XSHqaIxVVwyNOxm069EWg/bq709MLkaYQoWwSBWyVeXadb27WSFQLkOgvxSunSyas9jUAQmCUJmNSOfmoLhR3Y70j1OofuNx5wmDoC4EKgoaLlhLqm8eBH0DmLWDnK31jG3Q11XpzhOGqmUQmTPQorvCoJ3IMAza26C2HLRXp9EIOJdYiFCFEoejc1FQrNauG+RpiyB/Kcb5SQ3OQENkTOq8i8gPn9DgdtaD/wuxVWedDEm1bwpKdbskGZA9CZqylj9JvcR65k6w1HPzUNcNhXWNpw263Y/qvJHoAIObOwoG7USGMfWgnd/K7ZhYLMKQfnYY0s8OK+d3Q+SFfISeVuL4uTycSyzEucRCfLotBXJvBwTJpRg5uP4MNERtgVknOSQO/Zt9v4KgrmceBN0MRnduGKrPnVB/V6W6njJUjlcornwqgdYcryCp8RRAz0Dl+uZOqDEm4c6YhxpdkrQ3FK0/uLk9Y3pUovaHQXsHYWEuxqjBjhg12BFFJZUZaEIVKkQl5OPk+TycPF8tA41chmEDTCcDDZEpEIkkRs6EVFzraUHDcydU76JUqtNVqaE0rJWZkAqNNLjZUmdMgu4NQ0ODm/VPuFb3TM63/xWJW+sMWxzToxK1TwzaOyAbKwkmDe+EScMrM9Acic7FQYUSF67VzkATJJfB28MGYjEDeDIuQ9OjiiwcW69QrcAYmZAqBzdX1BqUbNjcCSU6TyN0nxwU1zHB2530qRDKgYpyCLdDzFa7WagabKx38LK+ORVMd3Az06MStU/s065He+nT3lip2aU4pFDhoEKJG+l3MtC4djJHoL8MQQFSeHRt3etBVF3NR/452TlwcnbiI/92Qv/g5royH+lPn6p34HP1ORX0pk8tbbhwLaWBcQpNGdysKclC8dnnGjy0/YTwFulKRtRWmXqfdgbtenTUoL16Ga4klyBUocShSBWyqmWg8ehqhaAAGQKHSeHqxAw0ZDymUFeofRAEze0Av+ZTgOLaXYjuYnDznaxJxh7cfJuZA0Rmtg0Pbq61joObqX1i0N4GdfSgvTptBppIJY5E5yK/6E4GmoF9bBEkl2I8M9CQEZhaXSFqrKYNbi7R7VakvRm48yRBKL0Fde4ZY59eba02uLnqPRzcTI3DoL0NYtCuX3mFBor4fIQqVDgRm4vS8spfHYkY8Pe2R5BchlHMQEOtxJTrCpExGZoe1Xb0LkhsetS4OajeJanmDUX98zDU+5RBXQJA0+LnrlczDW42ZObm9jq4uaMw9aCdzaNkMHOzujPQnDpf+WNlIcboIQ4I9JfB35sZaIiITJXYXAaxdbdWOZbO4OZqXYlqZz6q3Z1I/+Dm0hrjF0r03FBUdm8y/cHN+tffWWb8wc3tWVtKj8qgnZqkegYaZX45DkflIlShRHy1DDQOthJM8JMiUC6FT29bZqAhIuqgRCJRZYu32Bwi2LfacasGN+uOJ9A/Q7PumIQ7A5Vrd1+qPrhZ3zwMldtVjlsohVCR13o3CkD9qU31TNKm052og83c3NbSozJop7smszfHrAnOmDXBuTIDTaQKoQolrqeV4o+IHPwRkaPNQBMol6J3N2agISJqKR01Pao+IpEIkFhWBqHmDq123MqbhVI9TwEafrJQV/civfMwaGdwrrpRKKtcpikBylvxqYLemZurB/pVNw3WtW8k6h3HULl9Sw1ubmvpUdmnXQ/2ab97giDgakplBpowhZ4MNHIpAv1lzEBDTdZe6gpRS2B61I5JEDR1DFQuqTUmof6UqnXNw1D5hEF3zMPtLkjGoB3cXBXU6xvcrC91auXNgqY8D2VXvmjwMC2dHpUDUZsgJCQEISEh0Gg0iImJYdDeTDQaAeevFCJUocLhGBXyC6tnoLFBkFzGDDTUaO2xrhC1BNYVaml3Zm6u68mCnjEHdY5fqGfMQ42uShDUDReuGTBoN2FsaW85VRlowiJVOH62RgaaAfYIlMswerADrK2YgYbq197rClFzYV2h9krQlOufQ6HWQOWaNxSVNwWa4lSUJ+9o8DimErSzaZNaVfUMNMUlahw9m4ewSCUiL+TjVFzlj5WFGKMGOyBQLoOcGWiIiIhID5H49uBmM7smvV+dd9GgoN1UMGgno7G2kmDScBkmDZdBlV+B8GgVwhRKxF0tQlikCmGRlRloxt/OQDOQGWiIiIiog2LQTiZBam+GWeOdMWu8M9KySxFWLQPNnogc7InIgUsncwT6Vw5g7dOdGWiIiIio42DQTibHzdkSS6a4YvE9LriaUoKwyMoMNJm3yvHL/iz8sj8LHl2tKgN4uQxdmIGGiIiIGqmtpUflQFQ9OBDV9Gg0As5fLUSYQoXwaN0MND6972SgkdrzPrSjYF0hMgzrClHdTCE9KrPH3AUG7aatvEKDyAsFCFMocaxaBhrx7Qw0QcxA0yGwrhAZhnWFyDDGqivMHkPtlrmZGCMHOWDkIAcUl6hxLDYPYQolFBfycTqu8sfSXIRRQxwRJJfBf4AdzM3Exi42ERERUZMxaKc2zdpKguAAGYIDKjPQHI5WISxSifNXinAoUoVDkSrY20owfqgUQXIpBvZhBhoiIiJqexi0U7shtTfDfeOdcd94Z6TnlCFMoUSoQoWktBL8eTQHfx7NgYvMHBP9pQiSy9C7mxUfFRMREVGbwKCd2qUuThZYPMUVi6e44mpKMUIVSoRFVmag+fVAFn49kIVeblYIlEsR6C+Fm7OlsYtMREREVCcG7dTu9e5mjd7drPHITDfEXS1E6O0MNElpJfj2j3R8+0c6fHrbIFAuw3g/R8jszY1dZCIiIiIdDNqpwxCLRRjkaYdBnnZ4cl5XRF0oQFikEsfO5iHuahHirhbh8+0pGOZ1OwPNEAfYMAMNERERmQAG7dQhmZuJMWKQA0bczkBz/FweQhVKRMbnQ3H7pyoDTaC/FHJve2agISIiIqNh0E4dnrWVBEFyGYLklRlojsSoEKpQ4fyVwjsZaGwkGOfniGC5jBloiIiIqNUxaCeqRmpvhpnjnDFzXGUGmkORlRlorqWWYO/RW9h79BY6S+9koOnTnRloiIiIqOUxaCeqQxcnCyy6xxWL7qnMQBOmUCE0UonMW+XYdjAL2w5moaebJYL8ZQiUMwMNERERtRwG7UQGqMpAs2xmF8RfK0LoaSXCo1W4nlaKb/ek49s96fD2sEGQXIbxw5iBhoiIiJoXg3aiRhCLRRjYxxYD+9jiyfndEHUhH6GKygw08deKEH+tCJ/vqMpAI8XoIY7MQENERER3jUE7UROZSUQYPtABwwc6oLhUjROxeQhVqKCIz6uWgSYZIwc7IkjODDRERETUdAzaiZqBtaUEgXIZAuUy5BZU4Ei0CgdvZ6AJj1IhPOpOBpogfxkGeTIDDRERERmOQTtRM3O0M8O945xx7zhnZOSUISxKhTCFEldTmIGGiIiImoZBO1ELcnWywKLJLlg02QXXUosRqqgM4DOqZaBx72KJIHllBpquzEBDREREeogEQRCMXQhTU1xcDBsbGxQVFcHa2rpVjy0IAjIyMuDq6srW13ZKEATEXS1CqEKJw9Eq5BaotesGeNggyF+KCf5SZqBpAOsKkWFYV4gMY6y6YmjcyZZ2olYmElXLQDOvG6IS8hF6WoljsXm4cK0IF64VYdPOVAzzskegvxRjfJmBhoiIqKNj0E5kRGYSEYb7OGC4z+0MNOfyEHpaNwPNh1uTMWqQAwLlMsi97WFhzgw0REREHQ2DdiITYW0pQaC/DIH+tzPQxOQiVKHEucRChEfnIjw6tzIDzVBHBMplGMwMNERERB0Gg3YiE+RoZ4Z7xzrh3rFOyLhVhkORKoRFKnEluQR7j93C3mO34Cw1R6C/FIFyKTy7W7OvKhERUTvGoJ3IxLl2ssDCyS5YONkFSaklCFUoERapQnpO2Z0MNK6WCAqQIdBfiq6dmYGGiIiovWH2GD2YPYZMnSAIiL9ahNBIJcKjamSg6WWDILkU44dJ0cmh/WagYV0hMgzrCpFhmD2GiJqdSCSCTx9b+PSxxYq5lRlowhQqHD2biwtJRbiQVIRNO1Lh52WHILkMo4c4wtaaGWiIiIjaKgbtRG1c9Qw0JWUaHI/NRZhChdNxeYi8UIDICwWwME/GyEEOCPSXIcCHGWiIiIjaGgbtRO2IlYW4VgaaMIUSsYmFOBydi8PRubCzlmCcnyMC/WUY3NcWEmagISIiMnntOmh3dnZGSUkJ1qxZgzVr1hi7OEStqnoGmsxbZTgUpUKoojIDzV/HbuGv2xloJg6rzEDTtwcz0BAREZmqdh20X79+Hd999x2ysrKMXRQio3LpZIEFk1ywYFJlBpqwSCXCFCqk5ZRhe2gWtodWZqAJlFdmoOnmwgw0REREpqRdB+22trawtGTwQVRdr65WWDbTDUvv7YL4a0UIUygRHpWLGxml+O7PdHz3Zzq8bmegmeAnRSfH9puBhoiIqK0wWtAeHR2NsLAw7evly5fDwcGh1nZRUVE4ceIEnJ2dMWPGDNjZ2bVmMYnaLZFIBJ/etvDpbYsn5nZDdLUMNAlJRUhIKsIXO1IxtL8dggJkGMMMNEREREZjtBQShYWFSE9PR3x8PF588UXcunWr1jZvv/02goKCEBkZiQ8//BC+vr7IyMjQrg8ICICdnZ3Oz6hRo1rzNIjaBTOJCAE+Dnj5YXfseMcHry5zx6jBDhCLRYhKKMC7P9zE3Jfj8MZXSTh6Jhdl5RpjF5mIiKhDMVpL+9ixYzF27FgkJCRgy5YttdbfvHkTr732Gvbu3YvJkydDrVZjzJgxeOutt/Dpp58CAA4fPgy1Wq3zPomELYFEd8PKQoyJ/jJM9Jchr/BOBpqzlwtxJCYXR2JyYWstxrihUgTJpRjc144ZaIiIiFqYyfZp379/P5ycnDB58mQAlcH44sWL8eGHH2qD9oZmKx02bBji4uKg0Wjw9ddfIzk5We925eXlqKio0L4uLi4GUDkzVmtPGFt1TE5US6bA3kaC6aM7YfroTshUluFQpAphkSpcSS7BvuO3sO/4LTg5mhklAw3rCpFhWFeIDGOsumLo8Uw2aL9x4wbc3d11lrm7u+PGjRsG7yMiIgIaTeVj/PoCifXr1+ONN96otTwjI6PBG4PmJggCVCoVgPrLTGQMEwYDEwY7IjnLFsfPleD4+RJkqSqwIywbO8Ky4eYkwaiBVhg1yApdOrXs1wvrCpFhWFeIDGOsulLVWNwQkw3aBUGodcHEYnGj7n5sbGwM2m7t2rVYvXq19nVxcTGcnJzg6upqlKAdAFxdXfnlSibL1RUYNhBYKQi4kFSEMIUK4dG5SMupwM7Dhdh5uBBePa0RKJdhgp9ji2SgYV0hMgzrCpFhjFVX2nzQ3q1bN6SmpuosS0lJQdeuXZv9WObm5jA3rx1UiEQio3zBVR2XX65k6ioz0NjBp7cdVszthuiL+QhVqHD0TC4Srhcj4XoxvtxZmYEmUC7DGF9H2DVjBhrWFSLDsK4QGcYYdcXQY5ls0B4UFIQnnngCJ06cwMiRIwEAO3bs0PZxJyLTIpGIIPd2gNzbASWLNDh5Lg+hCiVOx+UjKqEAUQkF+GhrMkYMckCwXIYAH3tYmBstgRUREVGbYrSg/ebNm/j111+1s5V+9dVXkMlkWLJkCdzc3ODp6YlnnnkGc+bMwcMPP4zz588jNjYWX3/9tbGKTEQGsrIQY8IwKSYMkyKvsAIRMbkIVSgRm1iIiJhcRDADDRERUaOIBCMNJ79y5Qq++OKLWsuffvppnQGoe/fuxYkTJ+Dk5ITFixfD1dW1xctWXFwMGxsbFBUVGaVPe0ZGBvseUruUdTsDTWikCok37/Thc3I0w4RhUgQHyAzOQMO6QmQY1hUiwxirrhgadxotaDdFISEhCAkJgUajQUxMDIN2ohZ0Pa0EYZFKhCpUSMsu0y7v7mKJILkUgXIZurtY1vn+vMJyJF7LgKeHKxxsm3+gK1F7wb8rRIZh0N4GsaWdqPUIgoCEpCKEKlQ4FKWCKv/OnAn9e1ojSC7DhGFSON3OQJOSWYrNu1JxPDYPggCIRMDoIQ5YPqsrutUT5BN1VPy7QmQYBu1tEIN2IuNQqwXEXCxAaKQSR8/koqikcp4FsQjw7W8Hv/522Lo/EyWlGqg1d94nEQPWlhJsWt2XgTtRDfy7QmQYBu1tEIN2IuMrLdPg5Pk8HDxdmYGmQl3/V5VEDIwc7IA3lnu0UgmJ2gb+XSEyjKkH7Sab8pGIOjZLCzHG+0kx3k+K/KIK7D+pxKYdqXVur9YAx8/mIb+oAvY2/GojIqL2hUmSicjk2duYIcDHvsHtNAIQk1DQqJmTiYiI2oK7ao46ceIETp48iT59+mDUqFHIyclB//79m6tsRERaUnsziERAQ/H4G19fNzgDDRERUVvR5Jb2VatWYebMmfj222/x119/wdzcHPfddx9ycnKas3ytKiQkBP7+/hg9erSxi0JENdjbmGH0EAdI6vjWEosAN2cLSO3NkJxZiu/3ZuCh/0vAincuYWdYFnJyy1u3wERERM2oSQNRz5w5g3vvvRdnzpzB9u3bcebMGXz55ZdYtWoV3N3d8fzzz7dEWVsNB6ISmaaUzFKseOcyikvVdWaP6eJkUW8GmiC5DGN8HWFnLTHSWRC1Lv5dITJMuxyIev78eUycOBFOTk46y3v27Ink5OSm7JKIqEHdXCyxaXVfhOxOxbGzlXnaxaLKrDHV87T7e9vD39sezyzUzUATnVCA6IQCfLQ1GSMGOSDIX4rhAx1gYc7hPUREZNqaFLR37doVFy9erLX87NmzCAgIuOtCERHVpZuLJd5Y7mHQjKg1M9AciclF6GklYhMLERGTi4iYXNhaizHWV4rgACkG97WDRMyWSCIiMj1N6h5TVlYGX19fTJw4EVZWVrhx4wZGjBiBd999F3FxcXB2dm6JsrYado8hMn13U1eylGU4FKlCaKQKiTeLtcudHM0wYZgUwQEy9O1hzTpI7QL/rhAZpl12j7GwsMCff/6Jp556CmFhYSgvL8e1a9ewZ8+eNh+wE1H711lmgfmTXDB/kguup5UgLFKFUIUSadll2BmWjZ1h2ejhaolAuRSB/sxAQ0RExnfXM6JqNBqUl5fD0rL9/FFjSzuR6WvuuiIIAhKSihCqUOFQlAqq/Artuv49rREkl2HiMCk6OervikNkqvh3hcgw7aKl/ebNm4iLizPowO7u7vD29jaslCYmJCQEISEh0Gg0DW9MRO2KSCTCAA9bDPCwxRP3d0XMxQIcVFRmoLl4vRgXrxfjy52pGNrfDoHMQENERK3MoJb2n376CS+//LLOsoKCAuTm5sLa2hrm5ubIy8uDjY0Nnn76abz99tstVuDWwJZ2ItPXWnWltEyDE+fyEKqozEBToa78yjQ3E2HkIAcEyWUI8LFnBhoyWfy7QmQYU29pb1L3mMLCQowePRqvvfYa5syZAwA4ffo0/vWvf+Gvv/5C7969m15yE8Cgncj0GaOu5BdV4Eh0LkIVlRloqr49ba3FGDdUiiA5M9CQ6eHfFSLDmHrQ3qSBqBEREfD09NQG7AAQEBCABx54ANu3b8fq1aubslsiIpNmb2OG6WOcMH2MU60MNPuO38K+47fg5GiGif4yBMmlzEBDRETNpklBe35+PlQqVa3lt27dgo2Nzd2WiYjI5NXOQKNEqEKFtOwy7AjNwo7QLG0GmiB/mXbiJyIioqZoUveYzMxMeHt746GHHsLixYthYWGBAwcOYN26dQgPD4dcLm+JsrYado8hMn2mWFcEQcCFpCKE6clA49XLBoH+UmagoVZninWFyBSZeveYJqd8jIyMxLPPPotTp05BrVZjwIABePvtt3Hvvfc2udCmgkE7kekz9bqiVguIvpiPUIUKR8/kori0MiuVWARtBpqxvo6wZQYaamGmXleITEW7DdqrqNVqVFRUME97M+GXK5Fh2lJdKSnT4CQz0JCRtKW6QmRMph60N6lPe0pKCi5cuKB3Xffu3eHl5dWU3RIRtUtWFmJMGCbFhGFS5BVWICLmTgaaIzG5OBKTWy0DjQyD+9oyAw0REeloUtAeGhqKl156SftarVYjOzsbVlZWePrpp/HOO+80WwFbEydXIqKW5mB7JwNN5q0yhEepEKpQIjG5hBloiIioTnfdPabK1atXMX/+fOzatQs9evRojl0aDbvHEJm+9lZXktJKcKhaBpoqPVwtESSXIdBfygw01CTtra4QtRRT7x7TbEE7AGzYsAHm5uZ48cUXm2uXRsGgncj0tde6UpWBJvS0EuFRuVAV6GagCZJLMcGPGWjIcO21rhA1N1MP2pvUPaYuBQUFUKvVzblLIqIORSQSwdvDFt4etlgxt1tlBprTKhw9m4uEpCIkJBXhix2p8POqzEAzZggz0BARdQRNCtrPnDmDv//+W2fZzZs3sWXLFvz555/NUjAioo5OIhFB7u0AubcDSso0OBGbi7BIFU7H5SPyQgEiLxTgI/NkjBzkgEB/ZqAhImrPmhS0Z2Rk4OTJk9rXIpEITk5O+O233xAYGNhshSMiokpWFmJM9Jdhor8MeYUVOBKTizCFEmcvF+JwdC4OR+fCzlqCcX6OCPRnBhoiovamWfu0txfs005k+lhXKmXeKsOhKBXCbmegqeIsNcfEYVIEMgNNh8e6QmSYdtmnPSQkBGfPnsXnn39u0HIiImoZLp0ssGCSCxZMckFSWgnCFEqEKVRIyynD9tAsbA/NgrurJQLllSkku3ZmBhoioraoSUG7RqPRO+C0sLCwXc2MSkTUlvRys8KymW5Yem8XxF8rQpiiMgPNjYxSfPdnOr77Mx0DetkgUF450VMnB2agISJqKxoVtB89ehS//PIL4uLikJWVhZUrV2rXlZeX488//8TGjRubvZBERGQ4kUgEn9628OltiyfmdkN0Qj7CFJUZaC4kFeECM9AQEbU5jQraBUFARUUF1Gq19v9VrK2tsWHDBixZsqTZC0lERE1jJhEhwMcBAT4NZ6AJkssg92YGGiIiU9Skgahnz55FVlYWgoODW6JMRhMSEoKQkBBoNBrExMRwICqRCWNduTu5BRWIOHMnA02Vqgw0QXIZBnvaQswMNG0e6wqRYUx9ICqzx+jB7DFEpo91pflUZaAJVShxpUYGmkD/ygw0nt2ZgaatYl0hMoypB+0Gd4+JiIjAzZs3sXjxYkRERODnn3/Wu924ceOwePHixpeYiIiMQicDTWoJwiLvZKDZdjAL2w5WZqAJCpAh0J8ZaIiIjMHgoF0kEkEikWj/b2am/61V2xARUdvTq6tuBppQhRLhUSrcyCjFlj3p2LInHQM8bBDkL8V4ZqAhImo17B6jB7vHEJk+1pXWU6EWEJ2Qj9DbGWhKSjUAALEYGOZlj0B/KUYzA43JYl0hMky76R5Tk1qtxsmTJ5GSkgKNRqNd7unpCX9//6buloiITEzNDDTHY3MRplDhdFweFPH5UMTnw8I8GaMGOSBQLkOAjz3MzZiBhoioOTUpaC8tLcXYsWNx4cIF9OjRA2LxnS/nBQsWMGgnImqnrCzECPSXIdBfhtyCChyJqcxAE5tYiPDoXIRH58LeRoJxQx0RyAw0RETNpklB+z///IP8/HykpqbC3t6+uctERERtgKOdGe4d64R7xzoh41YZDkWqEBZZmYFm77Fb2HvsFjPQEBE1kyYF7SUlJZDL5QzYiYgIAODayQILJ7tg4eTKDDShCiXCIlVIr56BposlguTMQENE1BRNGoiakpKCqVOn4vTp07CysmqJchkVB6ISmT7WFdMnCALirxYhNLIyA01ugVq7rioDzQR/KWT2zEDTklhXiAzTLgeiXr9+HWKxGEOGDEFQUBAsLCy060aPHo158+Y1ZbdERNSOiEQi+PSxhU8fW6yY2w1RCfkIu52B5sK1Ily4VoRNO1O1GWjG+DrCxooZaIiI9GlS0F5eXq4dbFpWVoaysjLtutLS0uYpGRERtRtmEhGG+zhguI8DikvVOHEur1YGmg+3VmagCQqQQe7NDDRERNUxT7se7B5DZPpYV9qHqgw0oQolziUWapdXZaAJksswiBlo7grrCpFh2mX3mJs3byIuLq7WcpFIBAcHB/j4+MDBwaEpuzaqkJAQhISE6OSdJyKilqMvA02oQomrKXcy0HSWmmOivxRBchn6dLdi4ElEHVKTWtp/+uknrFy5Erm5ubC2toa5uTny8vJgY2MDQRCg0Wjwyiuv4PXXX2+JMrc4trQTmT7WlfbtWmoxQhUqhCmUyLhVrl3u3sUSwXIZJsql6OrMDDSGYF0hMoypt7Q3qcPgrFmz0LNnT+zcuRNFRUXIzc2FQqGAu7s7YmNjsW/fPnz00UcIDQ1t8gkQEVHH5dHVGo/e54af3xyAT573xMxxTnC0k+BGeim+3ZOOB19LwFP/vYzd4dlQ5pc3vEMiojauSd1jjh49ir59+2LOnDnaZf7+/liyZAl27tyJ1atX4/HHH8fhw4cRFBTUbIUlIqKOpXoGmifnVWagCT2txLHYPMRfK0L8tSJ8viMFw7zsESSXYvQQZqAhovapSUF7fn4+cnNzay1XqVSwtKx8XGlrawuxmCP/iYioeejLQBN6WgVF/J0MNJbmyRg52BFBcikz0BBRu9KkoH3cuHH497//jZdeegkLFy6EhYUFwsLC8OWXXyI0NBRlZWX4/fff8eOPPzZ3eYmIiGBtKUGgvwyB/rLKDDTRKoRGqnAusRDhUSqER6kqM9D4OSJYLsPAPsxAQ0RtW5NTPp4+fRrPPfccTp8+DbVaDS8vL6xfvx6zZs2CUqlEVlYW+vXr19zlbRUciEpk+lhXSJ+MW2UIi6wcwHo1pUS7vCNnoGFdITKMqQ9Eves87Wq1GhUVFdpuMe0Bg3Yi08e6Qg2pKwNNTzdLBPnLECiXwq0DZKBhXSEyTLsP2tsjBu1Epo91hQwlCALirhYhVKHE4WgVcgvU2nXeHjYIksswfpgjZPbmRixly2FdITKMqQftTR6hc+rUKUyePBmurq4wNzeHmZkZzMzM8OSTTzZ1l0RERM1OJBJhYB9brFrYHdve9sGGFR4IkkthZSlG/LUifLotBfNficfLn13FgVO3UFSibninREStrEkDUbOysjB9+nS8+uqrkMvluHz5MqZOnYo33ngDTz31VHOXkYiIqFmYSUQYPtABwwfezkATm4dQBTPQEJHpa3Ke9oCAADzzzDPYvHkzsrKysHTpUpw9exb79++Hl5dXc5eTiIioWVlbShAolyFQficDzUGFCuevMAMNEZmeJgXtmZmZcHd3BwA4OjpCqVQCAHr16oUrV640X+mIiIhagaOdGe4d54x7xzkjI6cMYVEqhJ5W4lpqCfYevYW9R2/BRXYnA03vbh0rAw0RGV+TgvbqY1eHDBmCp556ChEREdi5cydmz57dbIUjIiJqba5OFlg02QWLJrvgakoxwhQqhEYqkXmrHL8eyMKvB7IqM9DIZQj07xgZaIjI+JoUtPv7+6N79+4AgAEDBuDhhx/G1KlT4efnh0ceeaRZC0hERGQsvbtZo3c3ayyb2QXx1yoz0IRHqXA9rRTf/pGOb/9Ih09vGwTKZZjgJ4XUvkl/VomIGsSUj3ow5SOR6WNdIWOpUAuIupCPUIUSx87moaRMAwAQiwH/AfYI9JdhzBAHWFtJjFzSSqwrRIYx9ZSPbBIgIiJqBH0ZaA4qlIiMz8fpuMofS3MRRg1xRKA/M9AQUfNoctB++PBhbN68GcnJydBoNNrls2bNwgsvvNAshWttISEhCAkJ0TkfIiKiutTMQHM4WoXQ2xloDkWqcChSBXtbCcYPlSIoQIqBvZmBhoiapkndYy5evIihQ4di+fLl6N+/v84jBB8fH4wdO7ZZC9na2D2GyPSxrpApy8gpQ1ikEqEKFa6llmiXGyMDDesKkWHaZfeYU6dOYfr06fjoo4+aWj4iIqJ2y9XJAovuccWie1zrzEDTy80KgfLKAL6Lk4Wxi0xEJq5JQXv37t1RUFDQ3GUhIiJqd6pnoIm7WogwhQrh0SokpZUwAw0RGaxJ3WMEQcCcOXMwfPhwTJs2DRYWd1oIZDIZXF1dm7WQrY3dY4hMH+sKtWUVagGR8fkIi9SfgSZILsPowc2TgYZ1hcgw7bJ7TEVFBUpLS/HKK6/glVde0Vn3+OOP48svv2zKbomIiDoEM4kIIwY5YMQgBxSXqHH8XB5C68hAEySXwX+AHTPQEHVwTQra//77b8TFxeHcuXO1BqKKxfxSISIiMpS1lQRBchmC5DKo8itwJEaFUIUS568U6WSgmeAnRaCcGWiIOqomBe1FRUUYP348Bg4c2NzlISIi6rCk9maYOc4ZM8c5Iz2nDIeqZaDZE5GDPRE5cOlkjkB/KQL9ZejTveEunPlFFUjNroCNfQUcbM1b4SyIqCU0qU97UlISpk+fjpiYGJ3+7O0F+7QTmT7WFepIamagqeLR1aoygNeTgSYlsxSbd6XieGweBAEQiYDRQxywfFZXdHOxbO1TIDJ5pt6nvUlB+/Hjx/Hoo49CEARMnDhRJ3AfPXo05s2b17RSmwgG7USmj3WFOiKNRtDJQJNXqNauG9jHBoH+Moz3k6KwWI0V71xGcaka6mrzBUrElRNCbVrdl4E7UQ2mHrQ3qXtMeXk5Ro0aBQAoKytDWVmZdl1paWlTdklEREQNEItFGORph0GedlgxryuiLhQgVKHE8dg8nL9ShPNXivD59hQ42EpQVKKGpkaznFoDFJeqEbI7FW8s9zDOSRBRkzQpaB8/fjzGjx/f3GUhIiIiA5mbiWtnoDmtxOn4fCjz1XW+T60Bjp/NQ35RBextmBOeqK1gbSUiImrjqmegibtaiKffS6x3e40AqPIZtBO1JczPSERE1I64d7GEId1x9xzJwbXU4pYvEBE1C95iExERtSP2NmYYPcQBJ2LzdAah1rTzUDZ2HspG725WCJTLEOgvhWun9pcRjqi9YNBORETUziyf1RVnLhbWkT1GjKcXdsfZywU4Ep2LqykluJqShq93p2Gwpy0C5TKM93OEgy1DBCJT0qSUj+0dUz4SmT7WFaL6pWSWImR3Ko6drczTLhYBo2rkaS+v0EARn49QhQrHY3NRVl4ZEphJRJB72yNILsXIwY6wsmBvWmr/TD3lI4N2PRi0E5k+1hUiw+QVliPxWgY8PVzrnRG1qESNo2dyERapQtSFfG26SGtLMcYMcURQgBR+/e0hkbC+Uftk6kE7n30RERG1Y/Y2ZujqbNZgphgbKwkmj+iEySM64VZeOcKjVAhTqHAhqQgHTitx4LQSUnszTBwmRZBcCq9eNrxhJmpFDNqJiIhIRycHc8yZ2BlzJnZGSmYpwiJVCFUocTOjFLvCs7ErPBtdO1sg0F+G4AAperhaGbvIRO0eu8fowe4xRKaPdYXIMM1VVwRBwOWbxQhVqHAoUomc3Artur49rBEUIMOEYVJ0ltbdBYfIlLF7DBEREbV5IpEI/dxt0M/dBstnuyH2cgEOnlYhIkaFyzeLcflmMTb/lgrffnYI9Jdi3FAp7Gwkxi42UbvBlnY92NJOZPpYV4gM09J1paxcg1Pn8xCqUOHk+TyUV1SGFeZmIowY6IBAuRQjBjrAwpwZaMi0saW9DQkJCUFISAg0mnpmoyAiIiItC3Mxxg6VYuxQKQqK1Ig4o0KoQoUzlwoQcSYXEWdyYWstxljfygGsQ/rZQSLmjTZRY7GlXQ+2tBOZPtYVIsMYq65kq8pxKEqFMIUSl24Ua5c7OZphor8MQXIp+vawZv0lk8GWdiIiIupwnKXmmBfUGfOCOuNGeglCFSqERSqRmlWGHaFZ2BGahR6ulgiUSxHkL9NO+ERE+rGlXQ+2tBOZPtYVIsOYUl0RBAEJSUWVGWiiVFDl38lA49XLBkFyKSYMk6KTAzPQUOtjSzsRERERKjPQDPCwxQAPWzxxf1dEX8xH6GkVjp7NRUJSERKSivDFjlT4edkhSC7DGF9H2FgxAw0RwKCdiIiIjEAiEUHu7QC5twNKyjQ4EZuLsEgVTsflI/JCASIvFODDrckYNcgBQQEyyL3tYW7GDDTUcTFoJyIiIqOyshBjor8ME/1lyC2owJGYXIQplIhNLER4dC7Co3NhbyPBOD9HBMtlGNjHFmJmoKEOhkE7ERERmQxHOzPcO9YJ9451QsatMhyKVCFUocTVlBLsPXoLe4/egovMHBP9pQiSy9C7m5XR++oTtQYG7URERGSSXDtZYOFkFyyc7IJrqcWVGWgUSmTcKsevB7Lw64Es9HKzQpBcikC5DF2cLIxdZKIWw+wxejB7DJHpY10hMkx7qysajYC4q4UIU6gQHq1CXqFau25gHxsEyWUY7yeFox3bJalxmD2GiIiIqJmIxSIM8rTDIE87PDm/GyLj8xGqUOJ4bB7OXynC+StF+GxbCvy97REkl2HUYAdYWzIDDbV9DNqJiIioTTKTiDBikANGDHJAcYkax2LzEKpQIvJCPk6dr/yxshRj9GAHBMllGDbAHmaStv+0gTomBu1ERETU5llbSRAcIENwgAyq/AqER6sQelqJ+GuVkzmFKlRwtJNgwrDKGVi9e9u0i+5C1HEwaCciIqJ2RWpvhlnjnTFrvDNSs0txSKHCQYUSN9JL8fvhHPx+OAddnCwQ6C9FUIAMvdysjF1kogYxaCciIqJ2q6uzJZZMdcXiKS64klyCUIUSYZEqpOeU4X//ZOJ//2TCs7sVAuUyBPpL0VnGDDRkmhi0ExERUbsnEong2cManj2s8dgsN8QmFiJUocSR6FwkJpcgMTkNX+1Ow2BPWwTJZRjn5wh7G4ZJZDr420hEREQdilgsgm8/O/j2s8NT87vhdFw+wiKVOHEuD2cvF+Ls5UJ88msKAnzsERwgw4iBDrC0EBu72NTBMWgnIiKiDsvCXIwxvo4Y4+uIwmI1Is7kIkyhRMzFAhyPzcPx2DzYWFVuEySXYWg/O0iYgYaMgEE7EREREQBbawmmjOyEKSM7ISe3HOFRKoQqlLh4vRj7Tyqx/6QSMgczTBwmRZBchv49rZmBhloNg/YmEgQBarUaarW64Y0bud+KigqUlpbyi4CoBolEAolEwrpBRC3OydEc9wd2xv2BnXEzoxSHIpU4qFAiJbMMvx3Kxm+HstHNxQJB/jIEymXo4Wpp7CJTOycSBEEwdiFMTUPTyZaXlyMtLQ2FhYUtcny1Wg2JhLO3Eelja2sLNzc3mJmZtaup2YlairGmZm+PBEHAxevFCItU4lCkCrfyKrTr+rtbIyhAhgnDpHByNDdiKampjFVXGoo7qzBo16O+iycIAi5fvgyJRAIXFxeYm5s36wdb1dJuZmbGL1eiagRBQHl5OTIzM6FWq+Hp6YnMzEwGIkQNYNDeMtQaATEXCxCmUCLiTC6KSjQAALEI8O1vhyC5DGN8HWFnzUa4tsLUg3Z2j2mksrIyqNVq9OjRo94L21SCIEAikTBoJ9LDysoKZmZmSEpKQnl5ubGLQ0QdmEQsgv8Ae/gPsMeqhRqcPJ+HUIUSp+PyEZ1QgOiEAny0NRkjBzkgSC5DgI89LMyZgYaajkF7E4nFrHhExlBV9/iQkIhMhaWFGOP9pBjvJ0V+UQWOxOQi9LQSsYmFOBKTiyMxubCzlmCcnyMC/WUY0tcWYjEb5qhxGLQTERERNRN7GzNMH+2E6aOdkKUsw6HIygw0ickl+OvYLfx17BacpeaVGWgCpPDszgw0ZBg2F1O78e6772LlypUGbVtRUQGRSISEhIQWLlXTtYUyNreEhAT07dsXZWVlxi4KEdFd6yyzwPxJLti8pj++WdcfS6a4wM3JAtmqcmwPzcK/376MZW9exE/7MpCaXWrs4pKJY0u7EeUXVUCVXwGpvRmnSr5L+fn5ePfddxEdHW3sotBd8PLywuDBg/HVV1/hySefNHZxiIiaTS83Kyyb6Yal93ZB/LUihCqUCI9S4UZ6KbbsSceWPenw9rBBkFyG8cMcIbNnBhrSxZZ2I0jJLMVrm69h9otxePiNi5j9YhxeD7mGlMyWu8v+4YcfMHDgQNjY2CAoKAiXLl3SrlMqlVi4cCHs7OzQqVMnrFy5Uqel827X1+Ts7Iyffvqp1nIzMzP8+eefTTq/rVu3YsiQIXB3d2/S+02BSCTC+fPnjV0Mo3vwwQfxxRdfGLsYREQtQiQSwae3LZ5e0B3b3vbBhic9EBwgg5WlGPHXivDpthTMfyUeL392FQdOKVFc0rzzwVDbxaC9laVklmLFO5dx8lweqsbRCQJwIjYPK9653CKB+5dffomXXnoJ77zzDjIzM/HWW29h27Zt2vVLly5FamoqEhIScOzYMezfvx9r165ttvWtYdeuXZgyZUqrHpNaRnBwMBISEnDx4kVjF4WIqEWZSUQY7uOAVx52x46N3li71B0jBjpABEARn4+N39/A/avj8Na313HiXB7KKzTGLjIZEYP2VhayOxXFpWqoa9Q7tQYoLlXjq91pzXq8srIyvPrqq3j33Xcxffp02NnZYeTIkXj11VcBAGlpafjjjz/wzjvvoHv37hgwYADWrVuHr776Cmq1+q7XN9Vbb70FkUhU60elUund/uTJk/D19dVZ1qVLF4hEIpibm8Pb2xu//vprrfft27cPgwYNgoODAyZPnoykpCTtuvPnzyM4OBiOjo7o1asXXn31VW2awYcffhiPPfaYzr62b98ONzc37XnfvHkT8+fPh6urK1xdXbF8+XLk5+frLb+npycAYNCgQRCJRDp98w8cOIChQ4dqP7vqfdwbcwwAuH79OubPn48uXbqga9euePvtt7VZWOo736r+9R9//DF8fX1haWmJn3/+Gc7Ozvj444/h6ekJBwcHzJ07V+f4J06cwLhx4+Do6IjevXvjv//9r/Z44eHhcHZ2xgcffIC+ffuiW7duAAA7Ozv07dsXJ0+erPM8iIjaG2tLCQLlMqxf4YHtG32wamE3DOxji9JyAYciVXj1i2uY/0o8PtqajHOJBdBomEGro2FH6mYQtOJss+xHrQGOns3DlFXxDW4bummIQfuMjY1FTk4OcnNz0aNHD+Tl5WHUqFH45JNP0LdvX8TGxkIQBPj7+2vf4+/vj9zcXFy/fh2XL1++q/W9e/duxBW449VXX9XeWGg0GsydOxc2NjZwdHSstW1xcTFUKhU6d+6sszw9PR1A5Y1LWFgYFixYgMGDB2PAgAHabb755hts374dnTt3xrPPPotZs2YhOjoahYWFmDx5MhYvXozt27fj+vXruP/++yGRSPDGG29g2bJlmDFjBj7++GPY2NgAAL777jv861//gkQiQWlpKYKDgzF16lTExcWhoqICjz76KJ555hl88803tc4hMTERIpEI586dw8CBAwFUBsoAsG3bNuzYsQPOzs54/PHH8dxzz+Gvv/5q9DGKi4sRHByMMWPGICoqChKJBJ988gmuXbuGzp0713u+VX7++Wds27YN/fr1Q3h4OHJycpCQkIBTp06hsLAQ06ZNw6effoo1a9bg8uXLmDRpEj799FPMmzcP165dw5w5c+Ds7IylS5cCAHJychAbG4vjx4/rfH4uLi5ITU014DeFiKj9cbQzw8xxzpg5zhnpOWU4FKlEqEKFa6kl2BORgz0ROXDtZI5AfxmCAqTw6Nr888aQ6WFLezuXnZ0NAPjll18QERGBq1evQiqVYubMmaioqEBeXh5sbGxgbn5nwItUKgUA5OXl3fX6ujz44IO1WtHraplftWoVcnNz8e233+pNi9VQvm4LCwtMmTIF9913H/bu3auz7j//+Q8GDBgAZ2dnfP755zh//jzOnDmDffv2QaPR4J133oFMJoOvry/WrVuHr7/+GgAwduxYuLi4YOfOnQAqn1js379fG4zu27cPhYWF+PDDD+Hs7IwuXbrgvffew//+9z9oNI17vLl+/Xr06dMHjo6OeOSRRxATE9OkY+zbtw+5ubnYvHkzunXrhi5dumDDhg3o3bt3g+db5c0330S/fv20r83MzPDRRx/ByckJ7u7uuP/++7Xl27x5M6ZNm4alS5fCzs4OgwYNwurVq3XGM4hEInz66ae1briIiKhSFycLLLrHFV+/2h9fre2HhZM7w0Vmjoxb5di6PxOPvnUJj751EVv3ZyLjFjNvtWdsaW8GhrZ65xdVYPaLcagvxhSLgF839IfMwbJZ8rba29sDAF555RX06tULAPD222/Dw8MDly5dgoODA4qKilBeXq4NvKu6oDg4ONz1+rr8+OOPeOCBB3SWmZnV/nV89913cfjwYURERMDCwkLvvqpa4LOysnSWb9y4Ed988w1u3ryJ0tLKsQKrVq3S2ab6kwAHBwc4OzsjOTkZN2/eRK9evSCR3Jl+2tPTE2lpaVCr1ZBIJHj44YexZcsWPPjgg/jhhx8QEBAALy8vAMC1a9eQkpKidxKujIwMuLm51XltanJxcdH+39raGsXFxU06RlJSEjw8PPRex4bOt0rNgb6Ojo6wtLSss3y//fZbrd/j6tdcJpNpf0ery8zMRNeuXWstJyLqyHp3s0bvbtZ4ZKYbzl8tROhpFQ7HVLbAf707DV/vTsMgT1sE+Usxzk8KRzuGee0JW9pbkb2NGUYPcYCkjqsuEQOjBjvA3kaif4Mm8PHxqRUMV7VMi8ViDB48GCKRCJGRkdr1kZGRcHR0RM+ePe96/d3YunUrPvvsM/z11196u8VUN2LECJw5c0b7+u+//8YHH3yAn3/+GUqlEoIgYMmSJdouJ1WuXbum/X9eXh6ys7PRvXt39OjRA9evX9cJWBMTE+Hm5qYNbB966CEcOXIESUlJ+P7777Wt7ADQs2dP9OnTB4Ig1PqpK2Bv7E1aY4/Rq1cvXLt2TW9mH0POt7Fl7NmzJ/71r3/VKtuVK1fq3V9hYSEuX76M4cOHG3wsIqKORCwWYbCnHZ5d3B3b3/bGm//uhQnDpLA0F+FcYiE++qUyA82rX1xDWKQSJWUcwNoetNugXaPRYP369fDw8MDYsWMRGxtr7CIBAJbP6gprS0mtwF0irhyE8tgsw1tgDSGVSrF48WJs2LAB169fR05ODtasWYPBgwejb9++cHNzw8yZM7F69WokJycjISEBb731Fh599FFIJJK7Xt9U4eHheOaZZ/DXX3+he/fuDW4/e/Zs7N+/X/u6oKAAEolE21Xnt99+03Zlqe71119HQkICcnJy8NRTT8HHxwe+vr6YOnUqBEHAmjVroFKpcObMGbz55pt45JFHtO/t0aMHAgMDsWLFCty4cQMLFizQrps6dSrEYjGef/55pKamIi8vD/v378fDDz9c5zm4ubkhJiamwe4+TT3G1KlTYW9vj8cffxwpKSnIyMjA2rVrcfXqVYPOt7GWL1+OXbt2YcuWLVCpVMjMzMT333+PN998s973HTx4EP369dM+tSAiorqZm4kxarAj1j3SEzve8cHLD/WA3NseGkHAiXN5WP/tDcxdHYeN393A6bg8qNUcwNpWtdug/fjx4ygtLUVYWBjuv/9+PPPMM8YuEgCgm4slNq3ui5GDHVDVyCgWASMHO2DT6r7o5mJZ/w6aYNOmTfD29oavry88PT1RXFyM33//XRtUb9myBW5ubvDy8sLIkSMRHByMDRs2aN9/t+ub4uuvv0ZmZqY2m0pD2WMWL16MmJgY3Lx5EwAwa9YszJgxAwEBAejcuTO+//573HvvvbXe9/DDD2PevHno1asXUlJSsGvXLojFYtjb22P//v1QKBRwd3fHfffdhwULFmgHx1ZZunQp9u3bh7lz5+p087C2tkZoaCgyMjIgl8vh7u6Ojz76CE8//XSd57xhwwa88sorkEgkBs3s2thjWFtb4+DBg8jLy4Ovry+GDRsGe3t7eHh4GHy+jeHl5YUDBw7g559/Ru/evTFkyBAcOXIEjz76aL3v+/HHH7FixYomH5eIqKOysZJg0vBO2LiyN37d4I2V87piQC8bFJdqcOC0Eq98fg3z18Tjs20piL9WaHAjEZkGkdABPrGEhAQ888wz+Pvvvw3avri4GDY2NigqKoK1te6I7NLSUly9ehW9e/fW6cvbFPpmRBUEARUVFTAzM2uWPu0dybvvvosbN27gs88+M3ZRqIkuXryI6dOnIz4+vs4xDFV10MPDAyqVCq6urqwrRPUQBAEZGRmsKx1YalYpQhUqhCqUuJlxZz4YN2cLBMmlCJLL4N7FyoglNA3Gqiv1xZ3VGS1oj4mJweHDh7Wvly1bpnfg4tmzZ3HixAk4Oztj2rRp2vR6hiovL8fs2bPx6quvYsSIEQa9p7WCdn0YtBPVj0E7UeMwaKcqgiDg8s1ihCpUOBSpRE7unXFefXtYI1AuxUR/GTpLzevZS/tl6kG70brH5OXlISkpCTExMXj22Wdx69atWtu8++67GDduHI4ePYqNGzfC19cXmZmZ2vWjRo2CVCrV+Rk7dqx2fXl5OR544AEsX77c4ICdiIiIqD0SiUTo526DJ+7viq3rvfHeqt6YMrITbK3FuHyzGJt/S8OitfF4/qMr+OtYDgqKmj5JIjU/o3ePSUhIwIABA3Dt2jVtSkIASE5OhoeHB/bs2YMpU6agoqICo0ePxvDhw/HJJ58AAPLz82vl9pZIJLC3t0dZWRkWLFiAhQsX6gwQNARb2olMF1vaiRqHLe3UkLJyDU6dz0NopAonz+WhvKIyNDQ3E2G4jwOCAqQYMdABFubtdigkANNvaTfZBJ779++Hk5MT7rnnHgCVObyXLFmCjz/+WBu068vvXOXAgQPYs2cPDh06hMcffxzu7u51ZpApLy/XSQVYlWe6KkVddVWv9a1rLtWPQUS6atZB1hOi+rGuUEPMzUQY4+uIMb6OKChSI+JMLsIiVThzqQBHz+bi6Nlc2FiJMdbXEUFyKYb0s4NE3P5uAI1VVww9nskG7devX0ePHj107nTc3d1x48YNg95/zz33aGcDBaB3Apoq69ev15mqvUpGRkatO56Kigqo1WpUVFTcVUrDugiCoH16wBYRotqq6mB2djYKCgoAsK4Q1UcQBG3mLdYVMoRfH8Cvjy2U+VY4GVeCY+dKcC2tAv+cVOKfk0pI7cQY6WOF0YOs0Mut/fQMMFZdqWosbojJBu2CINQKiiUSicFTwJuZmWlzdDdk7dq1WL16tfZ1cXExnJyc4Orqqrd7TH5+PszMzPTO4NlcqmYXJSJdVTPSOjs7w8zMjI/8iRpQ1YrHukKN5eoKeHkCD98H3EgvwaFIFUIVKqRml2HfqSLsO1WEHq6WCPSXItBf2iJpq1uTsepKmw/au3btipSUFJ1lqampLTK1ubm5ud4guSo3eM1lda1rDoIg6ByDiHTVrIMtVReJ2hPWFbpbPd2s8fC91nhoRhckJBVVZqCJUuFmRim+35uB7/dmwKuXDYLkUkwYJkUnh7bZ+GiMumLosUw2aA8KCsKKFStw+vRpBAQEAAB27tyJ4OBgI5eMiIiIqGMSiUQY4GGLAR62eOL+roi5WICDCiWOnslFQlIREpKK8MWOVPh52SFILsPoIY6wtW7+7sQdkdGC9uTkZOzYsUObwvHbb79Fp06dsHDhQnTp0gV9+/bFypUrMXv2bCxbtgznz59HTEwMNm/ebKwik5GVlJQgOzsb3bt3BwAkJiaiZ8+eTe5KdOXKFfTo0aPOSXxaU0VFBZKTk3UyKBEREZkyiUQEf297+Hvbo2SRBifP5SFUocTpuHxEXihA5IUCWJgnY9QgBwTKZQjwsYe5WfvOQNOSjHblSkpKkJSUhKKiIqxatUqbt7209M5MXZ988gk2bdqE8vJyjBo1CrGxsfDw8DBWkcnIXn/9de1NW0VFBfr27YsrV640eX/9+/dHfHx8cxWvXleuXEFZWVmd68ViMaZPnw6FQtEq5SEiImpOVhZiTBgmxZv/9sD2jd54dnF3DPa0RVm5gPDoXLy2OQnzXo7HB/+7ibOXCqDRMJtRYxk9T7spCQkJQUhICDQaDWJiYlokT7umJB1CWW7dG5g7QGPm3CJ52jMzM2Fvb19nDtD09HRYWFigU6dOTVpf5dq1a+jcuTPs7Ox0ll+5cgVubm6NntUWALKysrRBupOTEyoqKmBubo4LFy7Ay8ur0fsDKgcrR0ZGwtfXt0nvbwwvLy/s2rULAwYMAFD5lMDd3V2nlf+bb77B9u3b8ffff7d4edoy5mknahzmaSdjyrxVhrBIFcIilbiSXKJd7iIzx0R/KYLkMvTuZmUSv5umnqedzyiqWb58OSIjI3Hs2LEW2b+mJB15oaOQHz6h7p+w0dCUpDfrcX/88Uf07t0bQ4YMgUwmw4wZM5CTk6Ndn5SUBH9/f/Tt2xddu3bFlClTtCmPDFlfk1wux+7du2st79+/P8LCwpp0Dj/88AMmTJgAJyenJr3f2KomEavSt29fXLp0SWebuXPn4vDhw0hKSmrl0hEREbUMl04WWDjZBSFr+uObV/tj0T0ucO1kjkxlOX49kIXlGy7h0bcu4ee/M5CeU/cTaWLQ3qqEslxA3UBaH3UxUF5PS3wTJCQkICIiAmlpaUhPT0d2djZeeOEF7foHH3wQHh4eUCqVyM7OhkqlwrPPPmvw+qZQKpVITEys9VNXSs89e/YgMDBQ7zqNRqMdG6FPXl4e8vLyDC5bVlaWTjctoPIpRfUbnaysLNy8eVP7uqioCNevX69zn9W7x1TNNXDz5k0kJiZq5xNwdHSEn58f9u7da3BZiYiI2opeXa3w6H1u+PnNAfj4eU/MHOsEB1sJktJK8O0f6Viy7gKefu8yfj+cjdyCioZ32MEwaO8A1q9fj27dugEApFIpgoKCkJiYCKCyK8vRo0fx2muvwczMDHZ2dli9ejV+/fVXlJWVNbi+qbZu3YopU6Zof8aOHYu+fftqJ8upSaFQYNCgQbWWf/nll+jcuTP69++P3r176/QJj4qKgp+fH3r27Al3d3cEBgYiNTW1zjIdOHAAvXr1woABAyCTybBw4UJtsL9582Y8+uij2m3nzZsHHx8f7Uy6mzZtwuOPP17nvqv3n1+6dCkA4PHHH8eUKVPw+eefa7cbMmQITp8+Xed+iIiI2jqRSISBfWyxalF3bN/og/VPeCDQXworCzHirhbhk19TMO/lOKz5/CpCFUoUl6qNXWSTYLIpH9sS1R9uzbq/4qOT0FCafenMtEbtMzs7G7du3cLFixfx008/YcOGDQCA+Ph4iEQieHt7a7f18fFBcXExkpKScPny5XrX9+vXT+/xMjIytDcG+qxYsQIrVqwAUNmXKzAwEEuXLoWDg0OtbQsKClBUVKS3a0x0dDSuX78OOzs7rFmzBvPnz8fFixdRXFyMGTNm4JVXXsFTTz0FjUaDJ554Ak888QR+//33WvvJzMzE3LlzsWHDBjz55JO4desWJk2ahJdffhmbNm1CcHAwPvjgA6jVapSWliImJgY9e/bEyZMnMWbMGBw8eNDgdKShoaEQiUT466+/MHDgQJ11Tk5OuHr1qkH7ISIiauvMJCKMGOSAEYMcUFyixrHYPIQplFBcyMepuMofKwsxRg9xQJBchmED7GEmMX7/d2Ng0N5BfP755/juu++Qnp6O4OBgTJo0CUBlwGxtba0z+6y9vT2Ayi4fDa2vy3//+1988cUXOsvU6tp3yhqNBosWLULfvn21NxI1VaV0rGrVrm7NmjXaAa+vv/463n//fURHR+PGjRuQSCSYNm2aNsPMwoULMWXKFFRUVNSazXb//v2QSqV48sknAQCdOnXC6tWrsXLlSmzatAkBAQEQBAGRkZFQKpXw9/fH8OHDceDAAQQEBCAiIgIbN26s83oYqry83CRSUBIREbU2aysJggNkCA6QQZVfgcPRKoQqlIi7WjmZU6hCBUc7Ccb7SREsl8G7t41JDGBtLQzam4Ghrd7qvIvID5/Q4HbWYw7AQubTrL+Ir7/+Ol5//XUUFRXh8ccf16YXlMlkKCoqQklJCaysrABA23e7U6dODa6vy3vvvYcHHnhAZ1nNQBkAnnrqKRQWFmL79u117svS0hIuLi5IT689QLdLly4628lkMmRlZSElJQU5OTmYMmWKzvbu7u64desWXFxcdJZnZWXBzU33iYmbmxtycnKgVqshkUgwfvx4HDx4EEqlEsHBwRg+fDjWrVuHiRMnwtbWFkOGDKnzHAyVnp6OHj163PV+iIiI2jKpvRnuG++M+8Y7Iy27FGGRlQH89bRS/HEkB38cyUEXJwsE+ksRFCBDLzcrYxe5xTFor6Z6ysf2oirgrGJjY4M5c+Zg8eLFEAQBQ4cOhZmZGSIiIrSt7xEREXB1dUWPHj1gZ2dX7/q7sXHjRhw9ehQRERENTpA0atQoREdHY9q0aTrLz507p03ZmJ6ejszMTPTu3RsSiQSdOnVCQkKCzs2CvlZ2AOjduzcuXbqkc3Ny9uxZ9OzZU3v9goOD8dtvv0GpVOKrr77C4MGDce7cOfz2228IDAxs1E2WWCzW+3sWGRmJNWvWGLwfIiKi9s7N2RJLprhi8T0uuJJcglCFEociVUjPKcP//snE//7JRJ/uVgiSyzBxmBQundrnE2sG7dUsX74cy5cv1+bLbA/OnDmDt99+G4888gjc3d1x+fJlrF27FnPmzIFIJEKnTp2wdOlSrFq1Cps2bUJBQQH+7//+Dy+88IJB65vq119/xTvvvIPff/8dmZmZ2uwvvXv3hlhce3z0/Pnz8fHHH+PVV1/VWb5u3TrIZDJ07twZr776KsaPHw8fHx94eXnB3d0dCxYswKpVq2BnZ4eTJ09i7969erOzTJ06Fc7Oznj44YfxwgsvICkpCW+88QZee+017TbBwcF4/vnn4eDggGHDhkEsFmPkyJEICQnBZ5991qjz79WrF/bu3Qtra2vIZDI4OzsjKSkJSUlJmDFjRqP2RURE1BGIRCJ49rCGZw9rPDbLDbGJhQhTKHE4OhdXkktwJTkNX+1Ow2BPWwTJZRg71BEOtu0n1G0/Z9IGiCwcAYl1/WkfJdaAuWOzHXPYsGFYvnw5Pv/8c1y9ehWurq547LHH8MQTT2i3+fTTT/Gf//wHzzzzDMzNzfHyyy/rpHRsaH1NvXv31vZ7r87T0xO2trYAKrPBODk5YdmyZTrbxMTE6H3vnDlz8NJLLyE+Ph7e3t4QiUTo06cP/vvf/+Kbb75BUlIShg8fru1XLpFIcPDgQfz3v//FunXrUFhYiFGjRuHrr7/WKU/VBFkWFhY4cuQIXnvtNSxfvhwymQzvvPOOTvkGDBgAPz8/+Pr6am8sZs+ejStXrmifQtSl+rGAyqw369evx5YtW7BkyRK8/vrr+P777/Gvf/1L72BcIiIiukMsFsG3nx18+9lh5fxuUMTnI1ShxIlzeTh7uRBnLxfik19TEOBjj+AAGUYMdIClRf1JE/OLKpCaXQEb+wo42NbfA8AYOCOqHvXNTNWWZ0Rt63766SfExcXh7bffNnZRml1ZWRkmTpyInTt36vTTp9o4IypR43BGVOpICovVOHo2F6GnlYi5WADN7SjXxkqMMb6OCPKXYWh/O0iqZaBJySzF5l2pOB6bB0EARCJg9BAHLJ/VFd1cGh/rNZahM6IyaNejJYP2hgiCoO13zS9XotoYtBM1DoN26qhu5ZbjUFTlANaL1+/0cpA5mGGCnxTBATLYWYvx5LuJKC5VQ11tqJlEDFhbSrBpdd8WD9wNDdrZPYaIiIiI2p1Ojua4P7Az7g/sjOTMUoQplDioUCIlswy7wrOxKzwbVhYilJYLqNmErdYAxaVqhOxOxRvLPYxzAjUwaCciIiKidq27iyX+Nb0LHpzmiks3ihGqUCJUoYQqv+7ZVtUa4PjZPOQXVcDexvghc/098juYkJAQ+Pv7Y/To0cYuChERERE1M5FIhP49bbBibje8/0yfBrfXCIAqv/bkjsbAoL2a5cuXIzIyEseOHTN2UYiIiIioBTk5mqOhYR5iUeVET6aAQXsTtacJmIjakqq6xwF1RER0N+xtzDB6iAMkdUTDEjEwaoiDSXSNAdinvdEsLCwgkUiQmpoKFxcXmJubN2vwUJU9Rq1WMyghqkYQBJSXlyMzMxMSiaTBWXSJiIgasnxWV5y5WFhn9pjls7oar3A1MGhvJJFIBA8PD6SlpSE5OblFjqFWqyGRSFpk30Rtna2tLdzd3XlTS0REd62biyU2re6LkN2pOHa2Mk+7WASMHNx6edoNxaC9CczNzdGjRw9oNBpUVDTv4ARBEJCdnQ1nZ2cGJUQ1mJmZQSwWQyQSgVNMEBFRc+jmYok3lnsgr7Acidcy4OnhapIzojJobyKRSASJRNLsLeKCIMDMzAyWlpYM2omIiIhaib2NGbo6m5lMH/aaOBCViIiIiMjEMWgnIiIiIjJxptn+byQhISEICQlhOkciIiIiMikigaO5aikqKoKtrS1ycnJgbW3dqscWBAEZGRlwdXVln3aierCuEBmGdYXIMMaqK8XFxXByckJhYSFsbGzq3I4t7XqUlJQAAJycnIxcEiIiIiLqCEpKSuoN2tnSrodGo4FKpYKVlVWrt0pU3W0Zo5WfqC1hXSEyDOsKkWGMVVcEQUBJSQmkUinE4rqHm7KlXQ+xWIxOnToZtQzW1tb8ciUyAOsKkWFYV4gMY4y6Ul8LexVmjyEiIiIiMnEM2omIiIiITByDdhNjZmaG119/HWZm7LlEVB/WFSLDsK4QGcbU6woHohIRERERmTi2tBMRERERmTgG7UREREREJo5BOxERERGRiTPNnvYd0O7du5GQkAAAcHBwwIoVK4xcIiLTJAgCjhw5gnPnzsHV1RXTpk2Dra2tsYtFZJJOnDiBqKgoODk5Ydq0aXB0dDR2kYhMliAI+PTTT2Fra4tHHnnE2MWphQNRTcTPP/+Mc+fOITY2FrGxsUhOTjZ2kYhMTmZmJqZOnQpHR0f4+PggKioKV69exZEjR9CvXz9jF4/IpAQFBaGiogJDhgxBfHw8oqOjcejQIQwZMsTYRSMySR9++CFee+019OzZE+fPnzd2cWph0G5ivv76a/zf//0fg3YiPbKyspCamqoNOgRBwPjx49G3b1988803Ri4dkWk5efIkRowYoX09Y8YMyGQy/Pjjj0YsFZFpunjxIqZPn46FCxdi9+7dJhm0s3sMEbUZnTt3RufOnbWvRSIRXFxcUFZWZsRSEZmm6gE7UDlNurm5uZFKQ2S61Go1HnroIXzwwQe4dOmSsYtTJwbtRNRmxcTEYO/evdizZ4+xi0Jkkv744w+cO3cO586dQ0pKCrZu3WrsIhGZnI0bN6JPnz6YOXMm3nvvPWMXp04M2omoTUpISMC0adPwxhtvIDg42NjFITJJhYWFUCqV2n9v3LgBd3d3YxeLyGTExsbiyy+/xJkzZ4xdlAaxT7uJYZ92ooadPXsWkydPxssvv4xnn33W2MUhahP+7//+D7/88os2UxkRAXPmzEFBQQECAwMBABEREYiKisIzzzyDZcuWwcXFxcglvIMt7UTUppw8eRLTp0/Hhg0b8Pjjjxu7OEQmKTk5GQ4ODnBwcNAuE4vFEIs5PQtRdffeey8uXrwIlUoFACguLoZarYZKpYJarTZu4Wpg0G4ijh8/jiNHjkChUCA/Px8bN26EWCzGSy+9ZOyiEZmMq1evYtKkSfDx8YFSqcTGjRsBAN26dcODDz5o5NIRmY5bt25h2rRpGDlyJNzc3BAfH489e/bghx9+MHbRiEzK0qVLdV6/9957yMzM1P59MSUM2k1EaWkpVCoV+vbti759+0KlUkEikRi7WEQmRSKR4MknnwQAbasIAJ3WRCICBg8ejMOHD2PXrl1ITk7GpEmT8PHHH8PNzc3YRSMyacOHD4eZmWmGx+zTTkRERERk4ti5jYiIiIjIxDFoJyIiIiIycQzaiYiIiIhMHIN2IiIiIiITx6CdiIiIiMjEMWgnIiIiIjJxDNqJiIiIiEwcg3YiIiIiIhPHoJ2IiIiIyMQxaCciIiIiMnFmxi4AERGZno8//hi3bt2CVCrFP//8A3t7e6xatQpjxowBAGzduhXvv/8+RCIROnfujMmTJ+Opp56CRCIBAFy7dg0bN27EhQsX0LNnT7zwwgsYMmRIg+uIiEg/trQTEVEtN2/exMaNG3Hu3DmsXr0avr6+mDRpEs6cOQMACAoKwpdffokvvvgCjz/+OLZs2YI33nhD+/45c+agrKwM69evx4wZM/DEE09ArVY3uI6IiPQTCYIgGLsQRERkWl544QX88ccfSEhIgFhc2b7zwAMPwNzcHFu2bKm1/alTpzBnzhykpKQAAFxdXfHTTz9h0qRJAICysjJYWFg0uI6IiPRj9xgiItJr6NCh2oAdAIYNG4YdO3YAALKzs/Hhhx8iMjISt27dQllZGdLS0rQB+DfffIMXXngBXbt2xahRo7Bo0SJ4enoCQL3riIhIPwbtRESkV05Ojs7r7OxsODk5AQAWLVoEW1tbrFq1Ck5OTkhOTsbcuXO1QfuMGTMwY8YMpKenY9++ffD398fRo0cxcODAetcREZF+7NNORER6hYeH48SJEwCA1NRU/PDDD5g+fToA4MKFC5g/fz6mTZsGf39/HDlyRPu+qv7qJSUl6NKlC+bPnw9bW1tcuHCh3nVERFQ3Bu1ERKTXqFGj8Oijj6J///7w9PTExIkT8cgjjwAAXn75ZTzyyCMYOHAgunfvrtMqb25ujpKSEnTt2lW7ftiwYZg+fXq964iIqG4ciEpERLW88MILyM7OxpYtW5CUlAR7e3s4OzvrbKNSqXDjxg1069YNDg4OOHv2LPz8/LT94EtLS3HlyhV07twZnTt31nlvfeuIiKg29mknIqI6iUQieHh46F0nlUohlUq1r/39/XXWW1pawtvbW+9761tHRES1sXsMEREREZGJY/cYIiKqJTk5GRUVFejVq5exi0JERGDQTkRERERk8tg9hoiIiIjIxDFoJyIiIiIycQzaiYiIiIhMHIN2IiIiIiITx6CdiIiIiMjEMWgnIiIiIjJxDNqJiIiIiEwcg3YiIiIiIhP3/ysTwwSywMjCAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted per-pass ratio hi 0.2920 lo 0.8898\n", + "measured per-pass ratio hi 0.2915 lo 0.8895\n" + ] + } + ], + "source": [ + "def wear_gain(f, cutoff_hz):\n", + " w = 2 * np.pi * f / sr\n", + " a = 1.0 - np.exp(-2 * np.pi * cutoff_hz / sr)\n", + " ejw = np.exp(-1j * w)\n", + " lp = np.abs(a / (1 - (1 - a) * ejw))\n", + " r, nm = 0.999, (1 + 0.999) / 2\n", + " return lp * np.abs(nm * (1 - ejw) / (1 - r * ejw))\n", + "\n", + "f_hi, f_lo, cutoff, regen, span = 6000.0, 300.0, 2000.0, 0.9, 0.25\n", + "m = echo(span_ms=span * 1000, heads=1, ratios=[1.0], regen=regen, drive=0.0, darken_hz=cutoff)\n", + "n = int(1.5 * sr)\n", + "t = np.arange(n) / sr\n", + "burst = np.zeros(n)\n", + "w = int(0.1 * sr)\n", + "burst[:w] = 0.4 * np.sin(2 * np.pi * f_hi * t[:w]) + 0.4 * np.sin(2 * np.pi * f_lo * t[:w])\n", + "y, _ = m.process(burst)\n", + "\n", + "loop = int(span * sr)\n", + "hi = np.array([goertzel(y[k * loop : k * loop + w], f_hi) for k in range(1, 5)])\n", + "lo = np.array([goertzel(y[k * loop : k * loop + w], f_lo) for k in range(1, 5)])\n", + "\n", + "fig, ax = plt.subplots()\n", + "passes = np.arange(1, 5)\n", + "ax.semilogy(passes, hi, color=C[0], marker=\"o\", label=f\"{f_hi:.0f} Hz (above the corner)\")\n", + "ax.semilogy(passes, lo, color=C[1], marker=\"s\", label=f\"{f_lo:.0f} Hz (below it)\")\n", + "ax.set_xlabel(\"pass\"); ax.set_ylabel(\"magnitude\"); ax.set_xticks(passes)\n", + "ax.set_title(f\"generation loss per pass, darken {cutoff:.0f} Hz, regen {regen}\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(f\"predicted per-pass ratio hi {regen * wear_gain(f_hi, cutoff):.4f} \"\n", + " f\"lo {regen * wear_gain(f_lo, cutoff):.4f}\")\n", + "print(f\"measured per-pass ratio hi {np.mean(hi[1:] / hi[:-1]):.4f} \"\n", + " f\"lo {np.mean(lo[1:] / lo[:-1]):.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9f0a063f", + "metadata": {}, + "source": [ + "## 4 · Past unity, and the bound that holds it\n", + "\n", + "`delay.h` caps feedback at 0.99 so its loop is always contractive. `discreet.h` lets\n", + "regeneration reach exactly 1.0 because `|H_wear| ≤ 1` makes 1.0 sustain without growing. This\n", + "kernel goes one step further and allows regeneration *past* unity — the sound-on-sound howl a\n", + "tape echo is reached for live — and it stays bounded because the saturator does: with drive\n", + "engaged, `swing_shape` is bounded by `1/drive` no matter what the loop gain is.\n", + "\n", + "Because that bound only exists while the saturator is engaged, the cap is **drive-dependent and\n", + "applied per sample**: at drive 0 the effective regeneration falls back to 1.0, whatever the\n", + "target says. Below, the same excessive target (1.4) at four drives plus the drive-0 case: every\n", + "one plateaus, and every one stays under the analytic ceiling the saturator sets." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "af947e08", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T22:30:10.530647Z", + "iopub.status.busy": "2026-08-15T22:30:10.530441Z", + "iopub.status.idle": "2026-08-15T22:30:11.595486Z", + "shell.execute_reply": "2026-08-15T22:30:11.594483Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " drive rms mid rms late growth peak ceiling finite\n", + " 0.3 2.4777 2.4935 1.0064 3.0400 3.6534 True\n", + " 0.6 1.2357 1.2439 1.0066 1.5174 2.0035 True\n", + " 1.0 0.7395 0.7459 1.0086 0.9189 1.3435 True\n", + " 2.0 0.3695 0.3723 1.0075 0.7027 0.8485 True\n", + " 0.0 0.0522 0.0473 0.9054 0.6608 -- True <- drive 0: effective regen capped back to 1.0, still no growth\n" + ] + } + ], + "source": [ + "def plateau(drive, regen=1.4, seconds=14.0):\n", + " m = echo(span_ms=250.0, heads=1, ratios=[1.0], regen=regen, drive=drive, darken_hz=6000.0)\n", + " x = np.zeros(int(seconds * sr))\n", + " burst = int(0.5 * sr)\n", + " x[:burst] = 0.5 * np.random.default_rng(7).uniform(-1, 1, burst)\n", + " y, _ = m.process(x)\n", + " mid = y[int(0.55 * y.size) : int(0.75 * y.size)]\n", + " late = y[int(0.75 * y.size) :]\n", + " return (np.sqrt(np.mean(mid ** 2)), np.sqrt(np.mean(late ** 2)),\n", + " np.max(np.abs(y)), np.all(np.isfinite(y)))\n", + "\n", + "drives = [0.3, 0.6, 1.0, 2.0]\n", + "rows = [(d,) + plateau(d) for d in drives]\n", + "capped = plateau(0.0)\n", + "\n", + "# The analytic ceiling on the tape is |in|max + regen/drive: the saturator bounds the returned\n", + "# signal by 1/drive, and the record head adds the direct send on top. The single centre-panned\n", + "# head then scales it by cos(pi/4). (Looser bounds exist — the DC blocker's L1 gain is ~2 — but\n", + "# real signals do not excite the worst case, which is why the measured curve sits below.)\n", + "ceiling = [np.cos(np.pi / 4) * (0.5 + 1.4 / d) for d in drives]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(drives, [r[3] for r in rows], color=C[0], marker=\"o\", label=\"measured peak\")\n", + "ax.plot(drives, ceiling, color=C[3], ls=\"--\", label=\"ceiling: (|in|max + regen/drive), panned\")\n", + "ax.set_xlabel(\"drive\"); ax.set_ylabel(\"peak |output|\")\n", + "ax.set_title(\"regen 1.4: self-oscillating, and bounded by the saturator\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(f\"{'drive':>6} {'rms mid':>9} {'rms late':>9} {'growth':>8} {'peak':>7} {'ceiling':>8} finite\")\n", + "for (d, mid, late, pk, fin), cap in zip(rows, ceiling):\n", + " print(f\"{d:6.1f} {mid:9.4f} {late:9.4f} {late / mid:8.4f} {pk:7.4f} {cap:8.4f} {fin}\")\n", + "mid, late, pk, fin = capped\n", + "print(f\"{0.0:6.1f} {mid:9.4f} {late:9.4f} {late / mid:8.4f} {pk:7.4f} {'--':>8} {fin}\"\n", + " f\" <- drive 0: effective regen capped back to 1.0, still no growth\")" + ] + }, + { + "cell_type": "markdown", + "id": "3a300317", + "metadata": {}, + "source": [ + "## 5 · The transport\n", + "\n", + "Wow and flutter are `tape_loop.h`'s deterministic periodic pair — a slow deep sine and a faster\n", + "shallow one, summed into a read-position offset shared by every head (one motor moves the whole\n", + "path). Periodic-only is a family decision, not an oversight: it keeps renders and tests\n", + "bit-exactly reproducible, and the stochastic capstan term is a documented non-goal.\n", + "\n", + "A sinusoidally modulated read swings the playback ratio by `depth · 2π · rate`, which predicts\n", + "the peak pitch deviation in cents. Measured out of the output below by zero-crossing period,\n", + "and confirmed bit-exact across two runs." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "62e41002", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T22:30:11.597919Z", + "iopub.status.busy": "2026-08-15T22:30:11.597717Z", + "iopub.status.idle": "2026-08-15T22:30:11.832656Z", + "shell.execute_reply": "2026-08-15T22:30:11.831512Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "predicted peak deviation 10.88 cents\n", + "measured peak deviation 10.91 cents\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "two runs bitwise identical: True\n" + ] + } + ], + "source": [ + "depth_ms, rate_hz = 2.0, 0.5\n", + "predicted = 1200 / np.log(2) * depth_ms * 1e-3 * 2 * np.pi * rate_hz\n", + "\n", + "def render():\n", + " m = echo(span_ms=1000.0, heads=1, ratios=[1.0], wow=(depth_ms, rate_hz))\n", + " t = np.arange(int(4.5 * sr)) / sr\n", + " y, _ = m.process(0.8 * np.sin(2 * np.pi * 440.0 * t))\n", + " return y\n", + "\n", + "y = render()\n", + "\n", + "# Instantaneous pitch by zero-crossing spacing, over the filled-tape region.\n", + "seg = y[int(1.5 * sr) : int(3.5 * sr)]\n", + "cross = np.where((seg[:-1] <= 0) & (seg[1:] > 0))[0]\n", + "frac = seg[cross] / (seg[cross] - seg[cross + 1])\n", + "times = (cross + frac) / sr\n", + "hz = 1.0 / np.diff(times)\n", + "cents = 1200 * np.log2(hz / 440.0)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(times[:-1] + 1.5, cents, color=C[0], lw=0.9)\n", + "for s in (+predicted, -predicted):\n", + " ax.axhline(s, color=C[3], lw=0.8, ls=\"--\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"deviation (cents)\")\n", + "ax.set_title(f\"wow {depth_ms} ms at {rate_hz} Hz — predicted swing ±{predicted:.2f} cents (dashed)\")\n", + "plt.show()\n", + "\n", + "print(f\"predicted peak deviation {predicted:6.2f} cents\")\n", + "print(f\"measured peak deviation {np.max(np.abs(cents)):6.2f} cents\")\n", + "print(f\"two runs bitwise identical: {np.array_equal(y, render())}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d4f20b02", + "metadata": {}, + "source": [ + "## Checkpoint\n", + "\n", + "- The head layout is exact: each head returns at `span · ratio`, and the motor moves them\n", + " together.\n", + "- With the tape path neutral the echo is **bitwise** `delay.h`'s multitap — the kernel is\n", + " composition over `tape_loop.h`, measured, not asserted.\n", + "- Generation loss per pass matches the analytic wear transfer on both sides of the corner.\n", + "- Regeneration past unity self-oscillates and stays under the saturator's ceiling at every\n", + " drive measured; at drive 0 the\n", + " effective value is capped back to 1.0 and still does not grow.\n", + "- The transport bends pitch by the predicted amount and is bit-exactly reproducible." + ] + } + ], + "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 acd5a55..2d067d6 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -15,7 +15,8 @@ tap.overdrive~ (`Overdrive`), the step-sequencer rows behind tap.808.seq~ / tap.303.seq~ (`TriggerRow`, `NoteRow`), tap.808.kick~ (`Kick`), tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), the Discreet Music -two-machine tape loop tap.discreet~ (`Discreet`), the Music for Airports +two-machine tape loop tap.discreet~ (`Discreet`), the multi-head tape echo +tap.tapecho~ (`TapEcho`), the Music for Airports incommensurate loop bank tap.airport~ (`Airport`), the generative event loop tap.garden~ (`Garden`), and tap.tune~'s pitch corrector (`Tune`, with the shared DspTap detector passed through as `Yin` for the notebooks' @@ -283,6 +284,25 @@ def load() -> ctypes.CDLL: "taptools_discreet_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), "taptools_discreet_clear": ([vp], ctypes.c_int), "taptools_discreet_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + + "taptools_tapecho_create": ([], vp), + "taptools_tapecho_destroy": ([vp], None), + "taptools_tapecho_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_span_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_heads": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_tapecho_set_head_ratio": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_head_level": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_head_pan": ([vp, ctypes.c_int, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_regen": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_darken_hz": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_drive": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_input_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_mix": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_wow": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_flutter": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_tapecho_clear": ([vp], ctypes.c_int), + "taptools_tapecho_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), "taptools_airport_create": ([], vp), "taptools_airport_destroy": ([vp], None), "taptools_airport_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), @@ -1240,6 +1260,86 @@ def __del__(self): self._h = None +class TapEcho: + """tap.tapecho~'s kernel (tap::tools::tapecho::machine): the multi-head + tape echo of the Copicat / Space Echo school, composed over the same + tape_loop.h machinery as `Discreet`. One motor (`span_ms`) sets the + delay of a ratio-1.0 head and moves every head together; up to four + heads sit at settable positions along the path with their own level and + equal-power pan. Regeneration may pass 1.0 into deliberate + self-oscillation, bounded by the saturator rather than a feedback cap — + at drive 0 the effective regen is capped back to 1.0. Mono in, stereo + out.""" + + def __init__(self, sr: float = 48000.0, max_span_seconds: float = 4.0, **params): + self._h = _LIB.taptools_tapecho_create() + _check(_LIB.taptools_tapecho_prepare(self._h, float(sr), float(max_span_seconds)), + "prepare") + self.set(**params) + + def set(self, *, span_ms=None, heads=None, ratios=None, levels=None, pans=None, + regen=None, darken_hz=None, drive=None, input_level=None, mix=None, + wow=None, flutter=None, smooth_ms=None) -> "TapEcho": + """`ratios`/`levels`/`pans` are per-head sequences (head i gets element + i); `wow` and `flutter` take (depth_ms, rate_hz) pairs.""" + # configuration first, so ramped targets in the same call honor the new slew + if smooth_ms is not None: + _check(_LIB.taptools_tapecho_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + if wow is not None: + depth, rate = wow + _check(_LIB.taptools_tapecho_set_wow(self._h, float(depth), float(rate)), "wow") + if flutter is not None: + depth, rate = flutter + _check(_LIB.taptools_tapecho_set_flutter(self._h, float(depth), float(rate)), + "flutter") + if ratios is not None: + for i, r in enumerate(ratios): + _check(_LIB.taptools_tapecho_set_head_ratio(self._h, i, float(r)), "head_ratio") + if heads is None: + heads = len(list(ratios)) + if heads is not None: + _check(_LIB.taptools_tapecho_set_heads(self._h, int(heads)), "heads") + if levels is not None: + for i, v in enumerate(levels): + _check(_LIB.taptools_tapecho_set_head_level(self._h, i, float(v)), "head_level") + if pans is not None: + for i, p in enumerate(pans): + _check(_LIB.taptools_tapecho_set_head_pan(self._h, i, float(p)), "head_pan") + if span_ms is not None: + _check(_LIB.taptools_tapecho_set_span_ms(self._h, float(span_ms)), "span_ms") + if regen is not None: + _check(_LIB.taptools_tapecho_set_regen(self._h, float(regen)), "regen") + if darken_hz is not None: + _check(_LIB.taptools_tapecho_set_darken_hz(self._h, float(darken_hz)), "darken_hz") + if drive is not None: + _check(_LIB.taptools_tapecho_set_drive(self._h, float(drive)), "drive") + if input_level is not None: + _check(_LIB.taptools_tapecho_set_input_level(self._h, float(input_level)), + "input_level") + if mix is not None: + _check(_LIB.taptools_tapecho_set_mix(self._h, float(mix)), "mix") + return self + + def process(self, x): + x = _f64(x) + out_l = np.zeros_like(x) + out_r = np.zeros_like(x) + _check(_LIB.taptools_tapecho_process(self._h, _p64(x), _p64(out_l), _p64(out_r), x.size), + "process") + return out_l, out_r + + def clear(self) -> None: + """Erase the tape and the transport/wear state; parameters are kept. + Also the fastest way to stop a self-oscillating loop.""" + _check(_LIB.taptools_tapecho_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_tapecho_destroy(h) + self._h = None + + class Airport: """tap.airport~'s kernel (tap::tools::airport::loop_bank): up to eight free-running tape loops of unequal, incommensurate lengths, each with a diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 3421e67..5d32282 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -25,6 +25,7 @@ add_executable(taptools_kernel_tests overdrive_test.cpp spectra_test.cpp step_seq_test.cpp + tapecho_test.cpp tune_test.cpp tr808_clap_test.cpp tr808_cymbal_test.cpp diff --git a/tests/tapecho_test.cpp b/tests/tapecho_test.cpp new file mode 100644 index 0000000..542842b --- /dev/null +++ b/tests/tapecho_test.cpp @@ -0,0 +1,406 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.tapecho~ kernel (tapecho.h over tape_loop.h). +/// @details Two house patterns carry most of the suite. The NULL TEST is the load-bearing one: +/// with the tape path neutralized (no wow, no wear, no regeneration) a one-head echo +/// must be *bitwise* the plain Hermite multitap of delay.h — that is what makes +/// "tape_loop.h is a library, and this kernel is only composition" a measurement +/// rather than a claim. The pitch promises (wow depth) are ORACLE-BASED, measured out +/// of the output with the DspTap YIN detector, as in discreet_test.cpp; the +/// self-oscillation bound uses the two-window RMS pattern from grm_comb_test.cpp. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + constexpr double k_pi = 3.14159265358979323846; + + using tap::tools::tapecho::machine; + + /// A machine with the transport parked, the wear path neutral, and instant setters: tests opt + /// into wow, drive, and regeneration explicitly. + machine make(double max_span_seconds = 2.0) { + machine m; + m.prepare(k_sr, max_span_seconds); + m.set_smooth_ms(0.0); + m.set_wow(0.0, 0.0); + m.set_flutter(0.0, 0.0); + m.set_regen(0.0); + m.set_drive(0.0); + m.set_darken_hz(20000.0); + m.set_input_level(1.0); + m.set_mix(100.0); // wet only: the tape is what these tests measure + return m; + } + + size_t at(double seconds) { + return static_cast(seconds * k_sr); + } + + double rms(const std::vector& x, size_t begin, size_t end) { + double acc = 0.0; + for (size_t i = begin; i < end; ++i) { + acc += x[i] * x[i]; + } + return std::sqrt(acc / static_cast(end - begin)); + } + + double peak(const std::vector& x, size_t begin, size_t end) { + double p = 0.0; + for (size_t i = begin; i < end; ++i) { + p = std::max(p, std::abs(x[i])); + } + return p; + } + + /// YIN oracle at an offset — same detector setup as discreet_test.cpp / tune_test.cpp. + double measure_hz(const std::vector& x, size_t offset) { + const size_t tau_min = static_cast(k_sr / 2000.0); + const size_t tau_max = static_cast(std::ceil(k_sr / 55.0)); + tap::dsp::yin det(tau_max, tau_min, tau_max); + REQUIRE(x.size() >= offset + det.frame_size()); + const auto r = det.analyze(x.data() + offset); + REQUIRE(r.voiced()); + return k_sr / r.period; + } + + double cents(double f, double ref) { + return 1200.0 * std::log2(f / ref); + } + + /// Deterministic noise, never denormal-small — same LCG as delay_test.cpp. + struct noise { + uint32_t state{2463534242u}; + double operator()() { + state = state * 1664525u + 1013904223u; + return (static_cast(state) / 2147483648.0) - 1.0; + } + }; + + /// Render an impulse through a machine and return the left bus. + std::vector impulse_response(machine& m, double seconds) { + std::vector y(at(seconds), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + double r = 0.0; + m.process(i == 0 ? 1.0 : 0.0, y[i], r); + } + return y; + } + +} // namespace + +SCENARIO("each head echoes at its own position along the tape path") { + machine m = make(); + m.set_span_ms(100.0); + m.set_heads(4); // the default even spacing: 0.25, 0.5, 0.75, 1.0 of the span + + const std::vector y = impulse_response(m, 0.15); + + // A head at ratio r returns the impulse at exactly r * span. Integer spans read Hermite frac 0, + // so the returned sample is the recorded one scaled only by level and the centre pan law. + const double centre = std::cos(0.25 * k_pi); // pan 0, the multitap equal-power law + for (int i = 0; i < 4; ++i) { + const double ratio = static_cast(i + 1) / 4.0; + const size_t k = at(0.1 * ratio); + INFO("head " << i << " at ratio " << ratio << ", expected return at sample " << k); + CHECK(std::abs(y[k] - centre) < 1e-12); + CHECK(std::abs(y[k - 1]) < 1e-12); // and nowhere else: the neighbours are silent + CHECK(std::abs(y[k + 1]) < 1e-12); + } +} + +// The load-bearing test of the whole kernel: neutralize the tape (no transport error, no +// regeneration) and the echo must be the plain Hermite delay of delay.h, sample for sample. +// Not vacuous — a 1e-12 nudge on the span, the level, or the pan breaks it (checked during +// development), and it is bitwise because both paths are the same Hermite read at the same +// fractional position under the same equal-power pan law. +SCENARIO("with the tape path neutral, a one-head echo is bitwise the multitap of delay.h") { + const double span_ms = 137.31; // deliberately not a whole number of samples + + machine m = make(1.0); + m.set_heads(1); + m.set_head_ratio(0, 1.0); + m.set_head_level(0, 1.0); + m.set_head_pan(0, 0.0); + m.set_span_ms(span_ms); + + tap::tools::delay::multitap ref; + ref.prepare(k_sr, 1000.0); + ref.set_smooth_ms(0.0); + ref.set_taps(1); + ref.set_time_ms(0, span_ms); + ref.set_gain(0, 1.0); + ref.set_pan(0, 0.0); + + noise rng; + bool exact = true; + for (size_t i = 0; i < at(0.5); ++i) { + const double in = rng(); + double ml = 0.0, mr = 0.0, rl = 0.0, rr = 0.0; + m.process(in, ml, mr); + ref.process(in, rl, rr); + exact = exact && (ml == rl) && (mr == rr); // bitwise, not approximately + } + REQUIRE(exact); +} + +SCENARIO("the motor moves every head together") { + // Doubling the span doubles every head's return time — one motor, one tape path. + machine a = make(); + a.set_heads(4); + a.set_span_ms(100.0); + const std::vector y_short = impulse_response(a, 0.25); + + machine b = make(); + b.set_heads(4); + b.set_span_ms(200.0); + const std::vector y_long = impulse_response(b, 0.25); + + for (int i = 0; i < 4; ++i) { + const double ratio = static_cast(i + 1) / 4.0; + INFO("head " << i << " at ratio " << ratio); + CHECK(std::abs(y_short[at(0.1 * ratio)]) > 0.5); + CHECK(std::abs(y_long[at(0.2 * ratio)]) > 0.5); + } + + // And the heads really moved: the doubled span vacates the two short-span positions it does + // not also occupy (25 and 75 ms; 50 and 100 ms are shared by both layouts). + CHECK(std::abs(y_long[at(0.025)]) < 1e-12); + CHECK(std::abs(y_long[at(0.075)]) < 1e-12); +} + +// The design statement of the kernel: regeneration past unity is legal, self-oscillates, and +// stays bounded because the saturator — not a feedback cap — is the stabilizer. The analytic +// bound on the tape is |in|max + regen * L1(wear) / drive, with the DC blocker's L1 gain of +// ~2 on top of the saturator's 1/drive ceiling: 0.5 + 1.4 * 2 / 0.6 = ~5.2. The measured peak +// sits far below that (real signals do not excite the L1 worst case); the ceiling asserted here +// is the measured value with margin, and the promise that matters is the non-growth. +SCENARIO("regeneration past unity self-oscillates but stays bounded") { + machine m = make(); + m.set_heads(1); + m.set_head_ratio(0, 1.0); + m.set_span_ms(250.0); + m.set_regen(1.4); + m.set_drive(0.6); + m.set_darken_hz(6000.0); + + noise rng; + std::vector y(at(12.0), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + const double in = (i < at(0.5)) ? 0.5 * rng() : 0.0; + double r = 0.0; + m.process(in, y[i], r); + } + + const double early = rms(y, at(6.0), at(9.0)); + const double late = rms(y, at(9.0), at(12.0)); + INFO("oscillation RMS: [6,9)s = " << early << ", [9,12)s = " << late); + REQUIRE(std::isfinite(late)); + REQUIRE(late > 0.01); // it really is oscillating, not decaying away + REQUIRE(late <= early * 1.02); // and it has plateaued: bounded, not runaway + REQUIRE(peak(y, 0, y.size()) < 3.0); +} + +SCENARIO("at drive 0 the regeneration cap falls back to unity") { + // Same excessive regen target, no saturator. The per-sample cap holds the effective value at + // 1.0, where the linear wear path (|H| <= 1) sustains without growing. + machine m = make(); + m.set_heads(1); + m.set_head_ratio(0, 1.0); + m.set_span_ms(250.0); + m.set_regen(1.4); + m.set_drive(0.0); + m.set_darken_hz(6000.0); + + noise rng; + std::vector y(at(12.0), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + const double in = (i < at(0.5)) ? 0.5 * rng() : 0.0; + double r = 0.0; + m.process(in, y[i], r); + } + + const double early = rms(y, at(6.0), at(9.0)); + const double late = rms(y, at(9.0), at(12.0)); + INFO("capped RMS: [6,9)s = " << early << ", [9,12)s = " << late); + REQUIRE(std::isfinite(late)); + REQUIRE(late <= early * 1.02); // no growth, though the target says 1.4 + REQUIRE(peak(y, 0, y.size()) < 2.0); + REQUIRE(m.regen() == 1.4); // the target is kept: it takes effect again when drive returns +} + +SCENARIO("the echo transport bends pitch by the set wow depth, and two runs are bit-exact") { + const double depth_ms = 2.0; + const double rate_hz = 0.5; + // Peak deviation of a sinusoidally modulated read: ratio swings by depth * 2*pi*rate. + const double predicted = 1200.0 / std::log(2.0) * depth_ms * 0.001 * 2.0 * k_pi * rate_hz; + + auto render = [&] { + machine m = make(); + m.set_heads(1); + m.set_head_ratio(0, 1.0); + m.set_span_ms(1000.0); + m.set_wow(depth_ms, rate_hz); + std::vector y(at(4.5), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + const double t = static_cast(i) / k_sr; + double r = 0.0; + m.process(0.8 * std::sin(2.0 * k_pi * 440.0 * t), y[i], r); + } + return y; + }; + + const std::vector y = render(); + + double worst = 0.0; + for (size_t off = at(1.5); off + at(0.05) < at(3.5); off += 2048) { + worst = std::max(worst, std::abs(cents(measure_hz(y, off), 440.0))); + } + INFO("peak deviation " << worst << " cents, predicted " << predicted); + CHECK(worst > 0.6 * predicted); + CHECK(worst < 1.4 * predicted); + + const std::vector z = render(); + bool exact = true; + for (size_t i = 0; i < y.size(); ++i) { + exact = exact && (y[i] == z[i]); // bitwise: the transport is deterministic + } + REQUIRE(exact); +} + +SCENARIO("a span change glides as tape speed, not a splice") { + machine m = make(); + m.set_heads(1); + m.set_head_ratio(0, 1.0); + m.set_span_ms(500.0); + + std::vector y; + y.reserve(at(4.5)); + auto run = [&](double seconds) { + for (size_t i = 0; i < at(seconds); ++i) { + const double t = static_cast(y.size()) / k_sr; + double l = 0.0, r = 0.0; + m.process(0.8 * std::sin(2.0 * k_pi * 440.0 * t), l, r); + y.push_back(l); + } + }; + + run(2.0); // fill the tape at the short span + m.set_smooth_ms(500.0); + m.set_span_ms(750.0); // respool +0.25 s of span over 0.5 s: tape speed halves + run(0.5); + m.set_smooth_ms(0.0); + run(2.0); + + const double gliding = measure_hz(y, at(2.2)); + const double settled = measure_hz(y, at(3.5)); + INFO("mid-glide " << gliding << " Hz, settled " << settled << " Hz"); + CHECK(std::abs(cents(gliding, 220.0)) < 60.0); + CHECK(std::abs(cents(settled, 440.0)) < 5.0); + + double worst_step = 0.0; + for (size_t i = at(2.0) + 1; i < at(2.5); ++i) { + worst_step = std::max(worst_step, std::abs(y[i] - y[i - 1])); + } + INFO("largest sample step during the glide: " << worst_step); + CHECK(worst_step < 0.1); // a 440 Hz sine at 0.8 moves ~0.046/sample; a splice would jump ~1.6 +} + +SCENARIO("a hard-panned head is bitwise absent from the far bus") { + machine m = make(); + m.set_heads(2); + m.set_head_ratio(0, 0.5); + m.set_head_pan(0, -1.0); // hard left + m.set_head_ratio(1, 1.0); + m.set_head_pan(1, 1.0); // hard right + + noise rng; + bool left_clean = true, right_clean = true; + double left_energy = 0.0, right_energy = 0.0; + for (size_t i = 0; i < at(0.5); ++i) { + double l = 0.0, r = 0.0; + m.process(i < 16 ? rng() : 0.0, l, r); + // Head 0 returns only on the left at 0.5 span, head 1 only on the right at 1.0 span. + const size_t half = at(0.375 * 0.5); + const size_t full = at(0.375); + if (i >= half && i < half + 16) { + right_clean = right_clean && (r == 0.0); + left_energy += l * l; + } + if (i >= full && i < full + 16) { + left_clean = left_clean && (l == 0.0); + right_energy += r * r; + } + } + REQUIRE(left_energy > 0.0); // the heads really did return + REQUIRE(right_energy > 0.0); + REQUIRE(right_clean); // and the far bus is bitwise zero, not just small + REQUIRE(left_clean); +} + +SCENARIO("mix endpoints are bitwise exact on both busses") { + machine m = make(); + m.set_heads(4); + m.set_span_ms(200.0); + m.set_regen(0.5); + + m.set_mix(0.0); + noise rng; + bool exact = true; + for (int i = 0; i < 4800; ++i) { + const double in = rng(); + double l = 0.0, r = 0.0; + m.process(in, l, r); + exact = exact && (l == in) && (r == in); // bitwise dry, both busses + } + REQUIRE(exact); +} + +SCENARIO("no heads is silence, and the tape still turns underneath") { + machine m = make(); + m.set_span_ms(200.0); + m.set_heads(0); + + noise rng; + bool silent = true; + for (size_t i = 0; i < at(0.5); ++i) { + double l = 0.0, r = 0.0; + m.process(rng(), l, r); + silent = silent && (l == 0.0) && (r == 0.0); + } + REQUIRE(silent); + + // Bring a head back and the tape it was recording all along is there, immediately. + m.set_heads(1); + m.set_head_ratio(0, 1.0); + double energy = 0.0; + for (size_t i = 0; i < at(0.25); ++i) { + double l = 0.0, r = 0.0; + m.process(0.0, l, r); + energy += l * l; + } + REQUIRE(energy > 0.0); +} + +SCENARIO("unprepared, the echo passes input through") { + machine m; + double l = 0.0, r = 0.0; + m.process(0.7, l, r); + REQUIRE(l == 0.7); + REQUIRE(r == 0.7); + m.process(-0.3, l, r); + REQUIRE(l == -0.3); + REQUIRE(r == -0.3); +} diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 4bbfbf2..ec93a88 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -1144,6 +1145,88 @@ int taptools_discreet_process(taptools_discreet h, const double* in, double* out return with(h, [&](discreet_machine& m) { m.process(in, out, static_cast(n)); }); } +// ---- tap.tapecho~ -------------------------------------------------------------------------------- + +using tapecho_machine = tap::tools::tapecho::machine; + +taptools_tapecho taptools_tapecho_create(void) { + return static_cast(new tapecho_machine()); +} + +void taptools_tapecho_destroy(taptools_tapecho h) { + delete static_cast(h); +} + +int taptools_tapecho_prepare(taptools_tapecho h, double sr, double max_span_seconds) { + if (max_span_seconds <= 0.0) { + return -1; + } + return with(h, [&](tapecho_machine& m) { m.prepare(sr, max_span_seconds); }); +} + +int taptools_tapecho_set_span_ms(taptools_tapecho h, double ms) { + return with(h, [&](tapecho_machine& m) { m.set_span_ms(ms); }); +} + +int taptools_tapecho_set_heads(taptools_tapecho h, int count) { + return with(h, [&](tapecho_machine& m) { m.set_heads(count); }); +} + +int taptools_tapecho_set_head_ratio(taptools_tapecho h, int head, double ratio) { + return with(h, [&](tapecho_machine& m) { m.set_head_ratio(head, ratio); }); +} + +int taptools_tapecho_set_head_level(taptools_tapecho h, int head, double lin) { + return with(h, [&](tapecho_machine& m) { m.set_head_level(head, lin); }); +} + +int taptools_tapecho_set_head_pan(taptools_tapecho h, int head, double pan) { + return with(h, [&](tapecho_machine& m) { m.set_head_pan(head, pan); }); +} + +int taptools_tapecho_set_regen(taptools_tapecho h, double r) { + return with(h, [&](tapecho_machine& m) { m.set_regen(r); }); +} + +int taptools_tapecho_set_darken_hz(taptools_tapecho h, double hz) { + return with(h, [&](tapecho_machine& m) { m.set_darken_hz(hz); }); +} + +int taptools_tapecho_set_drive(taptools_tapecho h, double d) { + return with(h, [&](tapecho_machine& m) { m.set_drive(d); }); +} + +int taptools_tapecho_set_input_level(taptools_tapecho h, double lin) { + return with(h, [&](tapecho_machine& m) { m.set_input_level(lin); }); +} + +int taptools_tapecho_set_mix(taptools_tapecho h, double pct) { + return with(h, [&](tapecho_machine& m) { m.set_mix(pct); }); +} + +int taptools_tapecho_set_wow(taptools_tapecho h, double depth_ms, double rate_hz) { + return with(h, [&](tapecho_machine& m) { m.set_wow(depth_ms, rate_hz); }); +} + +int taptools_tapecho_set_flutter(taptools_tapecho h, double depth_ms, double rate_hz) { + return with(h, [&](tapecho_machine& m) { m.set_flutter(depth_ms, rate_hz); }); +} + +int taptools_tapecho_set_smooth_ms(taptools_tapecho h, double ms) { + return with(h, [&](tapecho_machine& m) { m.set_smooth_ms(ms); }); +} + +int taptools_tapecho_clear(taptools_tapecho h) { + return with(h, [&](tapecho_machine& m) { m.clear(); }); +} + +int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, double* outR, int n) { + if (!in || !outL || !outR || n < 0) { + return -1; + } + return with(h, [&](tapecho_machine& m) { m.process(in, outL, outR, static_cast(n)); }); +} + // ---- tap.airport~ -------------------------------------------------------------------------------- using airport_bank = tap::tools::airport::loop_bank; diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 0ee4b5a..6885bf5 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -366,6 +366,33 @@ TAPTOOLS_API int taptools_discreet_set_smooth_ms(taptools_discreet h, double ms) TAPTOOLS_API int taptools_discreet_clear(taptools_discreet h); TAPTOOLS_API int taptools_discreet_process(taptools_discreet h, const double* in, double* out, int n); +// ---- tap.tapecho~ (tap::tools::tapecho::machine) ------------------------------------------------- + +typedef void* taptools_tapecho; + +TAPTOOLS_API taptools_tapecho taptools_tapecho_create(void); +TAPTOOLS_API void taptools_tapecho_destroy(taptools_tapecho h); +/// Buy tape for `max_span_seconds` at `sr`; snaps ramps and erases the tape. +TAPTOOLS_API int taptools_tapecho_prepare(taptools_tapecho h, double sr, double max_span_seconds); +TAPTOOLS_API int taptools_tapecho_set_span_ms(taptools_tapecho h, double ms); // the motor; slewed = varispeed +TAPTOOLS_API int taptools_tapecho_set_heads(taptools_tapecho h, int count); // 0..4 active playback heads +/// Per-head setters; `head` is 0-based. `ratio` is the head's position as a fraction of the span. +TAPTOOLS_API int taptools_tapecho_set_head_ratio(taptools_tapecho h, int head, double ratio); // (0, 1] +TAPTOOLS_API int taptools_tapecho_set_head_level(taptools_tapecho h, int head, double lin); +TAPTOOLS_API int taptools_tapecho_set_head_pan(taptools_tapecho h, int head, double pan); // -1..1 equal-power +/// 0..1.5. Above 1.0 self-oscillates and is only reached while drive > 0 (the saturator bounds it). +TAPTOOLS_API int taptools_tapecho_set_regen(taptools_tapecho h, double r); +TAPTOOLS_API int taptools_tapecho_set_darken_hz(taptools_tapecho h, double hz); // per-pass wear corner +TAPTOOLS_API int taptools_tapecho_set_drive(taptools_tapecho h, double d); // >= 0; 0 caps regen at 1.0 +TAPTOOLS_API int taptools_tapecho_set_input_level(taptools_tapecho h, double lin); // into the record head +TAPTOOLS_API int taptools_tapecho_set_mix(taptools_tapecho h, double pct); // 0..100, equal-power +TAPTOOLS_API int taptools_tapecho_set_wow(taptools_tapecho h, double depth_ms, double rate_hz); +TAPTOOLS_API int taptools_tapecho_set_flutter(taptools_tapecho h, double depth_ms, double rate_hz); +TAPTOOLS_API int taptools_tapecho_set_smooth_ms(taptools_tapecho h, double ms); +TAPTOOLS_API int taptools_tapecho_clear(taptools_tapecho h); +/// Process n samples mono-in / stereo-out (the dry path is mixed to both busses). +TAPTOOLS_API int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, double* outR, int n); + // ---- tap.airport~ (tap::tools::airport::loop_bank) ----------------------------------------------- typedef void* taptools_airport; diff --git a/tools/render/CMakeLists.txt b/tools/render/CMakeLists.txt index c4d95ea..3084dfe 100644 --- a/tools/render/CMakeLists.txt +++ b/tools/render/CMakeLists.txt @@ -2,7 +2,7 @@ # through its kernel header to WAV files for listening checks — the kernels' reusability # outside Max, demonstrated in ~150 lines apiece. -foreach (tool diode_render tb303_render ladder_render vco_render grm_comb_render grm_pitchaccum_render autowah_render tr808_render eno_render) +foreach (tool diode_render tb303_render ladder_render vco_render grm_comb_render grm_pitchaccum_render autowah_render tr808_render eno_render radiohead_render) add_executable(${tool} ${tool}.cpp) target_link_libraries(${tool} PRIVATE TapTools::taptools) set_target_properties(${tool} PROPERTIES diff --git a/tools/render/radiohead_render.cpp b/tools/render/radiohead_render.cpp new file mode 100644 index 0000000..b49a2c9 --- /dev/null +++ b/tools/render/radiohead_render.cpp @@ -0,0 +1,258 @@ +/// @file +/// @brief Offline renderer for the Radiohead family — writes demo WAVs for listening checks. +/// @details Exercises tapecho.h with no Max involved (the kernels' portability, demonstrated). +/// The tape echo is a *performed* effect, so these scenarios move the controls while +/// they render rather than auditioning static settings — that is the only way to hear +/// what the kernel is actually for. +/// +/// Scenarios: `tapecho_heads` (a guitar-ish phrase through the four evenly spaced +/// heads, spread across the stereo field), `tapecho_three_head` (a Copicat-style +/// three-head layout, dirtier wear, heads down the middle), `tapecho_selfosc` (the +/// design statement made audible: regeneration pushed past unity into sound-on-sound +/// howl with the saturator holding it bounded, the input faded out under it, then +/// regeneration pulled back to let it decay), and `tapecho_varispeed` (the motor +/// slewed from a short span to a long one mid-phrase — the doppler that a tape +/// machine's speed change *is*). +/// +/// Usage: radiohead_render [output-directory] (default: current directory) +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include +#include +#include + +#include + +namespace { + + constexpr double k_r_sr = 48000.0; + constexpr double k_r_pi = 3.14159265358979323846; + + /// 48 kHz float32 WAV, 1 or 2 channels (interleaved) — same writer as the other render tools. + bool write_wav(const std::string& path, const std::vector& samples, double sr, uint16_t channels = 1) { + std::FILE* f = std::fopen(path.c_str(), "wb"); + if (!f) { + std::fprintf(stderr, "cannot open %s\n", path.c_str()); + return false; + } + const uint32_t n = static_cast(samples.size()); + const uint32_t data_bytes = n * 4; + const uint32_t rate = static_cast(sr); + + auto u16 = [&](uint16_t v) { std::fwrite(&v, 2, 1, f); }; + auto u32 = [&](uint32_t v) { std::fwrite(&v, 4, 1, f); }; + + std::fwrite("RIFF", 1, 4, f); + u32(36 + data_bytes); + std::fwrite("WAVE", 1, 4, f); + std::fwrite("fmt ", 1, 4, f); + u32(16); + u16(3); // IEEE float + u16(channels); + u32(rate); + u32(rate * 4 * channels); + u16(static_cast(4 * channels)); // block align + u16(32); // bits + std::fwrite("data", 1, 4, f); + u32(data_bytes); + for (double s : samples) { + const float v = static_cast(s); + std::fwrite(&v, 4, 1, f); + } + std::fclose(f); + std::printf("wrote %s (%.1f s)\n", path.c_str(), n / (sr * channels)); + return true; + } + + /// The kernel sums its heads with no master gain — gain staging is the caller's job, and for + /// these renders this tool is the caller. Each scenario carries an explicit trim chosen so the + /// file peaks below unity on playback; nothing here is normalized after the fact, so the + /// relative loudness *within* a render (a howl building over a phrase) is the kernel's own. + void write_scenario(const std::string& path, std::vector stereo, double trim) { + for (double& s : stereo) { + s *= trim; + } + write_wav(path, stereo, k_r_sr, 2); + } + + double midi_hz(double pitch) { + return 440.0 * std::exp2((pitch - 69.0) / 12.0); + } + + /// A plucked-string-ish source: a decaying harmonic stack with a bright, fast attack. Echo + /// scenarios want transients — a pad would hide the head layout entirely. + double pluck(double t, double hz) { + if (t < 0.0) { + return 0.0; + } + const double attack = 1.0 - std::exp(-t * 900.0); + double sum = 0.0; + for (int k = 1; k <= 6; ++k) { + const double kk = static_cast(k); + const double decay = std::exp(-t * (3.0 + 2.2 * kk)); // higher partials die first + sum += (1.0 / kk) * decay * std::sin(2.0 * k_r_pi * hz * kk * t); + } + return 0.45 * attack * sum; + } + + /// A phrase as a list of (onset seconds, midi pitch) plucks, summed at time t. + struct note { + double onset; + double pitch; + }; + + double phrase(const std::vector& notes, double t) { + double sum = 0.0; + for (const note& n : notes) { + sum += pluck(t - n.onset, midi_hz(n.pitch)); + } + return sum; + } + + /// The house progression for these renders — a slow minor arpeggio with room between the + /// notes for the repeats to be heard against. + const std::vector& demo_phrase() { + static const std::vector notes = {{0.00, 45.0}, {0.75, 52.0}, {1.50, 57.0}, {2.25, 60.0}, + {3.00, 64.0}, {4.50, 57.0}, {6.00, 52.0}}; + return notes; + } + + // ---- scenarios ----------------------------------------------------------------------------- + + void tapecho_heads(const std::string& dir) { + tap::tools::tapecho::machine m; + m.prepare(k_r_sr, 2.0); + m.set_span_ms(480.0); + m.set_heads(4); // the default even spacing: 0.25, 0.5, 0.75, 1.0 of the span + const double pans[4] = {-0.7, 0.5, -0.35, 0.8}; + for (int i = 0; i < 4; ++i) { + m.set_head_pan(i, pans[i]); + m.set_head_level(i, 0.9 - 0.15 * static_cast(i)); // nearer heads a touch louder + } + m.set_regen(0.45); + m.set_drive(0.4); + m.set_darken_hz(4200.0); + m.set_mix(45.0); + + const size_t frames = static_cast(16.0 * k_r_sr); + std::vector stereo(2 * frames); + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + m.process(phrase(demo_phrase(), t), stereo[2 * i], stereo[2 * i + 1]); + } + write_scenario(dir + "/tapecho_heads.wav", stereo, 0.5); + } + + void tapecho_three_head(const std::string& dir) { + tap::tools::tapecho::machine m; + m.prepare(k_r_sr, 2.0); + m.set_span_ms(390.0); + m.set_heads(3); // a Copicat-style three-head layout, set explicitly + for (int i = 0; i < 3; ++i) { + m.set_head_ratio(i, static_cast(i + 1) / 3.0); + m.set_head_pan(i, 0.0); + m.set_head_level(i, 1.0); + } + m.set_regen(0.6); + m.set_drive(0.9); // a hotter record head: the repeats thicken as they recirculate + m.set_darken_hz(2600.0); + m.set_wow(0.9, 0.9); // a tired transport + m.set_flutter(0.06, 13.0); + m.set_mix(50.0); + + const size_t frames = static_cast(16.0 * k_r_sr); + std::vector stereo(2 * frames); + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + m.process(phrase(demo_phrase(), t), stereo[2 * i], stereo[2 * i + 1]); + } + write_scenario(dir + "/tapecho_three_head.wav", stereo, 0.5); + } + + void tapecho_selfosc(const std::string& dir) { + // The kernel's design statement, as a performance: play a phrase, push regeneration past + // unity, fade the input away and let the loop howl on its own — bounded by the saturator, + // not by a feedback cap — then pull regeneration back and let it die. + tap::tools::tapecho::machine m; + m.prepare(k_r_sr, 2.0); + m.set_span_ms(420.0); + m.set_heads(2); + m.set_head_ratio(0, 0.5); + m.set_head_pan(0, -0.5); + m.set_head_ratio(1, 1.0); + m.set_head_pan(1, 0.5); + m.set_regen(0.5); + m.set_drive(0.7); + m.set_darken_hz(3800.0); + m.set_smooth_ms(400.0); // the controls are being *ridden*, so slew them like a fader + m.set_mix(60.0); + + const size_t frames = static_cast(40.0 * k_r_sr); + std::vector stereo(2 * frames); + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + if (i == static_cast(9.0 * k_r_sr)) { + m.set_regen(1.35); // past unity: the loop starts building on itself + } + if (i == static_cast(14.0 * k_r_sr)) { + m.set_input_level(0.0); // hands off the instrument; the machine plays alone + } + if (i == static_cast(26.0 * k_r_sr)) { + m.set_darken_hz(1400.0); // ride the tone control while it howls + } + if (i == static_cast(32.0 * k_r_sr)) { + m.set_regen(0.55); // and bring it home + } + m.process(phrase(demo_phrase(), t), stereo[2 * i], stereo[2 * i + 1]); + } + write_scenario(dir + "/tapecho_selfosc.wav", stereo, 0.35); + } + + void tapecho_varispeed(const std::string& dir) { + // A motor change is a tape-speed change: the repeats already on the tape bend in pitch as + // the heads move. Slow slews make it a dive; there is no crossfaded "digital" mode. + tap::tools::tapecho::machine m; + m.prepare(k_r_sr, 3.0); + m.set_span_ms(200.0); + m.set_heads(2); + m.set_head_ratio(0, 0.5); + m.set_head_pan(0, -0.4); + m.set_head_ratio(1, 1.0); + m.set_head_pan(1, 0.4); + m.set_regen(0.7); + m.set_drive(0.5); + m.set_darken_hz(5000.0); + m.set_mix(65.0); + + const size_t frames = static_cast(24.0 * k_r_sr); + std::vector stereo(2 * frames); + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + if (i == static_cast(8.0 * k_r_sr)) { + m.set_smooth_ms(3000.0); + m.set_span_ms(900.0); // spool out over three seconds: the dive + } + if (i == static_cast(16.0 * k_r_sr)) { + m.set_smooth_ms(1200.0); + m.set_span_ms(200.0); // and back up + } + m.process(phrase(demo_phrase(), t), stereo[2 * i], stereo[2 * i + 1]); + } + write_scenario(dir + "/tapecho_varispeed.wav", stereo, 0.35); + } + +} // namespace + +int main(int argc, char** argv) { + const std::string dir = (argc > 1) ? argv[1] : "."; + tapecho_heads(dir); + tapecho_three_head(dir); + tapecho_selfosc(dir); + tapecho_varispeed(dir); + return 0; +} From 16ab2b517987b55f9975418c9349a59ecfddb451 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 15 Aug 2026 23:16:21 +0000 Subject: [PATCH 03/22] Note the tape echo's Max slice in the family plan The wrapper, its min-api scenarios, the reference page and the help patcher landed in TapTools-Max alongside the pin bump, so the plan's per-object status now reads shipped end-to-end with only the book chapter and the on-Mac validation pass outstanding. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 9e02904..e3a7e5b 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,6 +1,6 @@ # Plan — the Radiohead family -> **Status: in progress — `tap.tapecho~`'s kernel has landed (2026-08-15); the rest is +> **Status: in progress — `tap.tapecho~` has shipped end-to-end (2026-08-15); the rest is > plan.** This is the drafting record of the 2026-08-15 survey ("are there > Radiohead-inspired objects we should consider?"), amended the same day against the Eno > components wave (`d4cf28a`) before any code was written. It stays after the objects ship, @@ -30,7 +30,7 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. | Object | Kernel | Recreates | Standing on | Status | |--------|--------|-----------|-------------|--------| -| `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ kernel shipped 2026-08-15; Max wrapper + chapter pending | +| `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel + Max vertical slice); chapter pending | | `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | planned | | `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | planned — gated on source collection | | `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | planned | @@ -67,14 +67,17 @@ The survey predated the Eno components wave by hours. Five amendments, now assum ## Per-object plans -### 1. `tap.tapecho~` — the multi-head tape echo *(first; small)* — ✅ kernel shipped +### 1. `tap.tapecho~` — the multi-head tape echo *(first; small)* — ✅ shipped > **Shipped 2026-08-15**: `include/taptools/tapecho.h`, `tests/tapecho_test.cpp` (11 > scenarios), the C ABI + ctypes surface (`TapEcho`), the executed `notebooks/tapecho.ipynb`, -> and `tools/render/radiohead_render.cpp` with four performed scenarios. What the plan -> predicted held: the kernel is composition — the null test below is *bitwise*. Still to -> come: the Max wrapper (`tap.tapecho~` vertical slice) in TapTools-Max, and the book -> chapter. Design decisions taken during implementation that this record should carry: +> and `tools/render/radiohead_render.cpp` with four performed scenarios; then the Max +> vertical slice in TapTools-Max (wrapper, six min-api scenarios, maxref, help patcher, +> pin bump — REVIVAL.md entry 18). What the plan predicted held: the kernel is composition +> — the null test below is *bitwise*, and `tape_loop.h` needed no changes at all to serve a +> second topology. Still to come: the book chapter, and the on-Mac validation pass. +> +> Design decisions taken during implementation that this record should carry: > the head layout is `span_ms` (the motor, = a ratio-1.0 head) times a per-head ratio, so > four evenly spaced heads is the default and a three-head Copicat layout is set explicitly > (the "preset + free" open question, resolved toward *free with an even-spacing default* — From 01f23987743129ec792b8995174dd6faa379f7c9 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 15 Aug 2026 23:46:34 +0000 Subject: [PATCH 04/22] Add the live stutter rig: tap.stammer~ The second Radiohead-family kernel, and an original design rather than a port: capture the input continuously, then on a rhythmic grid roll dice and re-fire a slice of what just went past. Brassage tradition (Roads, Microsound); the lineage to the band's own Max rigs informs what the object is for and nothing about what the code does. The planned component split holds: a capture (a tape_loop.h reel with one advancing head) and a slicer that owns every draw and the slice in flight, under a thin machine. Like tapecho.h's head, a slicer needs a capture, so it is documented as a component for composition and testing rather than standalone-external material. The suite and the notebook both lean on a pinned-dice identity: with density 1, whole-step slices, one forward pass and no flank, the machine must reduce to exactly a one-step delay, bitwise. That single identity pins the grid countdown, the slice origin and the playback head together -- much stronger than chasing three off-by-ones separately. Around it: the seeded-performance contract (same seed bit-identical, a different seed changes 89% of samples), the garden.h disabled-generator contract (at density 0 the dice are never rolled, so the seed provably cannot matter and the object is a bitwise bypass at any mix), the repeat invariant, the reverse identity, and the flanks' exact edges. The material contract is measured at its premise rather than asserted: slices of a sustained sine are 1.000 alike by magnitude spectrum, slices of a plucked phrase 0.286 -- re-ordering interchangeable things cannot do much, which is why this object wants transients. Ships the family template: 9 Catch2 scenarios, the C ABI plus ctypes surface (Stammer), the executed stammer.ipynb, and three radiohead_render scenarios including the performed disintegration. The Max wrapper and the chapter are still to come. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 24 +- include/taptools/stammer.h | 433 +++++++++++++++++++++++ include/taptools/taptools.h | 1 + notebooks/stammer.ipynb | 551 ++++++++++++++++++++++++++++++ notebooks/taptools_py.py | 90 ++++- tests/CMakeLists.txt | 1 + tests/stammer_test.cpp | 295 ++++++++++++++++ tools/capi/taptools_capi.cpp | 80 +++++ tools/capi/taptools_capi.h | 24 ++ tools/render/radiohead_render.cpp | 108 +++++- 10 files changed, 1597 insertions(+), 10 deletions(-) create mode 100644 include/taptools/stammer.h create mode 100644 notebooks/stammer.ipynb create mode 100644 tests/stammer_test.cpp diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index e3a7e5b..1973e98 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,7 +1,7 @@ # Plan — the Radiohead family -> **Status: in progress — `tap.tapecho~` has shipped end-to-end (2026-08-15); the rest is -> plan.** This is the drafting record of the 2026-08-15 survey ("are there +> **Status: in progress — `tap.tapecho~` has shipped end-to-end and `tap.stammer~`'s kernel +> has landed (both 2026-08-15); the rest is plan.** This is the drafting record of the 2026-08-15 survey ("are there > Radiohead-inspired objects we should consider?"), amended the same day against the Eno > components wave (`d4cf28a`) before any code was written. It stays after the objects ship, > the plans-directory way; per-chapter drafting records will follow separately when the book @@ -31,7 +31,7 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. | Object | Kernel | Recreates | Standing on | Status | |--------|--------|-----------|-------------|--------| | `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel + Max vertical slice); chapter pending | -| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | planned | +| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ kernel shipped 2026-08-15; Max slice + chapter pending | | `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | planned — gated on source collection | | `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | planned | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | @@ -112,7 +112,23 @@ the C ABI in the notebook. Measured at ship: per-pass generation loss within 0.2 analytic wear transfer on both sides of the corner; wow 10.91 cents measured against 10.88 predicted; every past-unity drive setting plateaus under its analytic ceiling. -### 2. `tap.stammer~` — the live stutter rig *(second; the most "us")* +### 2. `tap.stammer~` — the live stutter rig *(second; the most "us")* — ✅ kernel shipped + +> **Shipped 2026-08-15**: `include/taptools/stammer.h` (the planned `capture` + `slicer` split +> under a thin `machine`), `tests/stammer_test.cpp` (9 scenarios), the C ABI + ctypes surface +> (`Stammer`), the executed `notebooks/stammer.ipynb`, and three more `radiohead_render` +> scenarios. The design decision worth carrying: the suite and the notebook both lean on a +> **pinned-dice identity** — with density 1, whole-step slices, one forward pass and no flank, +> the machine must reduce to *exactly* a one-step delay, bitwise. One identity pins the grid +> countdown, the slice origin and the playback head together, which is far stronger than +> testing three off-by-ones separately. The capture/slicer split is a component boundary for +> composition and testing only: a slicer needs a capture, so (like tapecho.h's `head`) it is +> honestly documented as not standalone-external material. Measured at ship: the identity holds +> bitwise; a seed replays bit-identically while a different seed changes 89% of samples; at +> density 0 the rng is provably untouched and the object is a bitwise bypass at any mix; and the +> material contract is measured at its premise — slices of a sustained sine are 1.000 alike by +> magnitude spectrum, slices of a plucked phrase 0.286. Still to come: the Max vertical slice +> and the book chapter. The disintegrating guitar at the end of *Go To Sleep* and the mangling in *The Gloaming* come from Greenwood's own Max patches: capture the live input, re-fire randomized slices diff --git a/include/taptools/stammer.h b/include/taptools/stammer.h new file mode 100644 index 0000000..f1efa9c --- /dev/null +++ b/include/taptools/stammer.h @@ -0,0 +1,433 @@ +/// @file +/// @brief Portable live buffer-stutter kernel for tap.stammer~ — no Max/Min dependency. +/// @details The second kernel of the Radiohead family (book/PLAN-radiohead-family.md), and the +/// one with the most direct lineage to this package: the live re-firing rig Jonny +/// Greenwood plays through his own Max patches — the guitar coming apart at the end +/// of "Go To Sleep", the mangling in "The Gloaming". Capture the input continuously, +/// then on a rhythmic grid roll dice and re-fire a slice of what just went past. +/// +/// This is an ORIGINAL DESIGN in the brassage / granular tradition (Roads, +/// *Microsound*, MIT Press 2001), not a port and not a reconstruction of anyone's +/// patch. The band's rig is known from published interviews and broadcast films; that +/// record informs *what the object is for* and nothing about what the code does. No +/// preset, timing, or parameter value is taken from any product. +/// +/// Two components and a thin composition, the airport.h / tapecho.h split: +/// - `capture` — the live tape: a tape_loop.h `reel` in delay-line topology with one +/// advancing write head, holding the last `max_history_ms` of input. Reads are at +/// integer positions (slices play at +-1 rate, see the limits), so the family's +/// Hermite read reduces to an exact sample fetch — the same code path a future +/// rate-varying sibling would need. +/// - `slicer` — the dice and the playback head. It owns every random draw and the +/// state of the slice in flight, and reads a capture it does not own. Like +/// tapecho.h's `head` and unlike airport.h's `loop`, a slicer is not independently +/// useful — it is a read pattern, not a machine — so it is a component for +/// composition and testing rather than a standalone external. +/// - `machine` — one capture, one slicer, the input send and the balance. +/// +/// The performance surface, and the family thesis (the control is the instrument): +/// `density` is how often the machine grabs, `divisions` how finely it chops, +/// `repeats` how long it holds on, `reverse` how often a repeat runs backwards, and +/// `jump` how far back it may reach. Riding those four while a part plays is the +/// instrument; none of them is a set-and-forget. +/// +/// Randomness is the family's seeded xorshift64* (tr808::white_noise, via +/// swing_vca.h), consumed in a fixed order, so **a seed is a performance you can +/// replay**: two runs of the same seed and the same moves are bit-identical, and two +/// instances on different seeds decorrelate. At `density` 0 the dice are never rolled +/// at all, so the seed provably cannot matter (pinned by test — the garden.h idle +/// contract, same shape). +/// +/// Geometry: prepare(sr, max_history_ms) buys the capture once (4 s at 48 kHz is +/// ~1.5 MB of double tape). No later call allocates; setters are allocation-free and +/// safe while audio runs. +/// +/// Honest limits: +/// - **Material contract.** This wants transient material — drums, struck or plucked +/// strings, consonants. On a sustained pad a stutter is barely distinguishable from +/// a tremolo: the object re-articulates rhythm that is already in the sound, it +/// does not invent it. Tested with plucks, not sines, for exactly that reason. +/// - Slices play at +-1 rate only. There is no pitch shifting and no varispeed; a +/// performable, pitch-bending playhead over live capture is a different object +/// (tap.scrub~, planned in the same family) and sharing this capture is the plan. +/// - A slice reads from the ring rather than a private copy (a copy would be a burst +/// memcpy in the audio thread). If a repeat train outlives the buffered history — +/// `repeats * length + jump` beyond `max_history_ms` — its tail reads fresher +/// material as the write head laps the origin. Size the history to the longest +/// train you intend to fire. +/// - A grid point can only start a slice while the machine is idle: a slice in flight +/// is never interrupted, so `repeats` (not `density`) is what decides how long the +/// machine stays busy, and raising density past the point where trains overlap +/// stops having an effect. +/// - `mix` is the balance between the live input and the slice, and it only bites +/// while a slice is firing. When the machine is idle the input passes through +/// untouched and bitwise, at any mix — there is nothing to blend against, and +/// equal-power blending a signal with itself would just make it louder. +/// - Mono. Per-slice stereo scatter is not modeled; wrap in `mc.` for multichannel. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include + +#include "swing_vca.h" // tap::tools::tr808::white_noise — the family's seeded xorshift64* +#include "tape_loop.h" // tap::tools::tape — reel (the capture) + ramp, the shared machinery + +namespace tap::tools { + namespace stammer { + + constexpr int k_max_divisions = 8; // slice = step / k, k in [1, divisions] + constexpr int k_max_repeats = 16; // repeats per fired slice + constexpr long k_min_slice_samples = 16; // below this it is a click, not a slice + constexpr double k_min_step_ms = 1.0; // the grid floor + constexpr double k_default_max_history_ms = 4000.0; // default buy (~1.5 MB @ 48k) + constexpr double k_default_step_ms = 250.0; // a plausible grid out of the box + constexpr double k_default_density = 0.5; // grabs about half the idle grid points + constexpr int k_default_divisions = 4; + constexpr int k_default_repeats = 4; + constexpr double k_default_reverse = 0.25; // a quarter of repeats run backwards + constexpr double k_default_jump_ms = 0.0; // the classic stutter: the material just past + constexpr double k_default_fade_ms = 3.0; // per-repeat flank, click-free + constexpr double k_default_mix = 100.0; + constexpr double k_default_smooth_ms = 20.0; // anti-zipper ramp for the level setters + constexpr uint64_t k_default_seed = 1; + + /// The live tape: the last `max_history_ms` of input under one advancing write head. + class capture { + public: + /// Buy the history once. Not real-time-safe. + void prepare(double sr, double max_history_ms) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_reel.prepare(m_sr, std::max(k_min_step_ms, max_history_ms) * 0.001); + clear(); + } + + /// Erase the tape and rewind the write head. + void clear() { + m_reel.clear(); + m_write = 0; + } + + bool prepared() const { return m_reel.prepared(); } + long capacity() const { return m_reel.capacity(); } + long position() const { return m_write; } // absolute position of the NEXT write + double samplerate() const { return m_sr; } + double history_ms() const { return static_cast(capacity()) * 1000.0 / m_sr; } + + /// Record one sample and advance the head. + void write(double x) { + m_reel.write(m_write, x); + if (++m_write >= m_reel.capacity()) { // keep the head in [0, capacity): a long can + m_write = 0; // overflow in half a day of audio on LLP64 + } + } + + /// Read at an absolute position (wraps). Positions are integers here, so the family's + /// Hermite read returns the stored sample exactly (fraction 0 reads x0). + double read(long pos) const { return m_reel.read_hermite(static_cast(pos)); } + + private: + double m_sr{48000.0}; + long m_write{0}; + tape::reel m_reel; + }; + + /// The dice and the playback head: decides when to grab, how much, how many times, and + /// which way round, then plays it back out of a capture it does not own. + class slicer { + public: + struct out { + double value{0.0}; // the slice sample (0 when idle) + bool firing{false}; // whether a slice was sounding for this sample + }; + + slicer() { m_rng.set_seed(k_default_seed); } + + /// Reset the grid, drop any slice in flight, and re-seed — so a restart replays the + /// same performance. Not a parameter move. + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + clear(); + } + + void clear() { + m_rng.reset(); + m_countdown = 0; + m_playing = false; + m_pos = 0; + m_len = 0; + m_left = 0; + m_reverse_now = false; + } + + // -- the performance surface (allocation-free, safe while audio runs) ---------------- + + /// The rhythmic grid in ms: how often the machine may decide to grab. Takes effect at + /// the next grid point (it is a rhythm, not a level — nothing to zipper). + void set_step_ms(double ms) { m_step_ms = std::max(k_min_step_ms, ms); } + + /// Probability in [0, 1] of firing at an idle grid point. At exactly 0 the dice are + /// never rolled, so the seed cannot matter. + void set_density(double p) { m_density = std::clamp(p, 0.0, 1.0); } + + /// How finely the grid may be chopped: a slice is step / k with k drawn uniformly + /// from [1, divisions]. 1 means whole-step slices only. + void set_divisions(int n) { m_divisions = std::clamp(n, 1, k_max_divisions); } + + /// Upper bound on how many times a fired slice repeats; the count is drawn uniformly + /// from [1, repeats]. + void set_repeats(int n) { m_repeats = std::clamp(n, 1, k_max_repeats); } + + /// Probability in [0, 1] that any given repeat plays backwards. Drawn per repeat, so + /// a train can stagger forwards and back. + void set_reverse(double p) { m_reverse = std::clamp(p, 0.0, 1.0); } + + /// How far back beyond the immediately-past material a slice may reach, in ms; the + /// actual reach is drawn uniformly from [0, jump]. 0 is the classic stutter. + void set_jump_ms(double ms) { m_jump_ms = std::max(0.0, ms); } + + /// Raised-sine flank width per repeat, in ms — the anti-click. Clamped per slice to + /// half the slice so the flanks never overlap. + void set_fade_ms(double ms) { m_fade_ms = std::max(0.0, ms); } + + /// The performance seed. Instant; takes effect on the next draw (clear() restarts the + /// stream from it). + void set_seed(uint64_t seed) { m_rng.set_seed(seed); } + + // -- introspection ------------------------------------------------------------------- + + double step_ms() const { return m_step_ms; } + double density() const { return m_density; } + int divisions() const { return m_divisions; } + int repeats() const { return m_repeats; } + double reverse() const { return m_reverse; } + double jump_ms() const { return m_jump_ms; } + double fade_ms() const { return m_fade_ms; } + uint64_t seed() const { return m_rng.seed(); } + bool playing() const { return m_playing; } + + // -- audio --------------------------------------------------------------------------- + + /// Advance one sample: tick the grid, maybe fire, and play whatever is in flight. + /// Call once per sample AFTER the capture has recorded this sample. + out process(const capture& tape) { + if (--m_countdown <= 0) { + m_countdown = std::max(1L, static_cast(m_step_ms * 0.001 * m_sr)); + if (!m_playing) { + maybe_fire(tape); + } + } + if (!m_playing) { + return {}; + } + + const long read_at = m_reverse_now ? (m_origin + m_len - 1 - m_pos) : (m_origin + m_pos); + const double value = tape.read(read_at) * envelope(m_pos, m_len, m_fade); + + if (++m_pos >= m_len) { // this repeat is done + m_pos = 0; + if (--m_left <= 0) { + m_playing = false; + } + else { + m_reverse_now = (uniform() < m_reverse); // each repeat rolls its own way round + } + } + return {value, true}; + } + + private: + /// [0, 1) from the family's seeded xorshift64* (which returns [-1, 1)). + double uniform() { return 0.5 * (m_rng.process() + 1.0); } + + /// Raised-sine flanks: exactly 0 at both edges, exactly 1 across the plateau. Repeats + /// are sequential rather than overlapped, so each junction dips to zero — that is the + /// articulation of a stutter, not a defect. + static double envelope(long i, long len, long fade) { + if (fade <= 0) { + return 1.0; + } + const double half_pi = tape::k_pi * 0.5; + double g = 1.0; + if (i < fade) { + g = std::sin(half_pi * static_cast(i) / static_cast(fade)); + } + const long from_end = len - 1 - i; + if (from_end < fade) { + g = std::min(g, std::sin(half_pi * static_cast(from_end) / static_cast(fade))); + } + return g; + } + + /// Roll for a slice. The draw order is fixed — fire, division, repeats, jump, reverse + /// — because it is what makes a seed reproducible. + void maybe_fire(const capture& tape) { + if (m_density <= 0.0) { + return; // the dice are never rolled, so the seed provably cannot matter + } + if (uniform() >= m_density) { + return; + } + + const long step_samples = std::max(1L, static_cast(m_step_ms * 0.001 * m_sr)); + const int k = 1 + static_cast(uniform() * static_cast(m_divisions)); + const long divisor = std::clamp(static_cast(k), 1L, static_cast(m_divisions)); + long len = std::max(k_min_slice_samples, step_samples / divisor); + + const int n = 1 + static_cast(uniform() * static_cast(m_repeats)); + const long jump = static_cast(uniform() * m_jump_ms * 0.001 * m_sr); + + // The slice must fit the bought history, origin and reach together. + const long room = tape.capacity() - jump - 2; + len = std::clamp(len, k_min_slice_samples, std::max(k_min_slice_samples, room)); + + m_origin = tape.position() - len - jump; + m_len = len; + m_fade = std::min(static_cast(m_fade_ms * 0.001 * m_sr), len / 2); + m_left = std::clamp(n, 1, m_repeats); + m_pos = 0; + m_reverse_now = (uniform() < m_reverse); + m_playing = true; + } + + double m_sr{48000.0}; + + // performance surface + double m_step_ms{k_default_step_ms}; + double m_density{k_default_density}; + int m_divisions{k_default_divisions}; + int m_repeats{k_default_repeats}; + double m_reverse{k_default_reverse}; + double m_jump_ms{k_default_jump_ms}; + double m_fade_ms{k_default_fade_ms}; + + // the slice in flight + bool m_playing{false}; + bool m_reverse_now{false}; + long m_origin{0}; + long m_len{0}; + long m_fade{0}; + long m_pos{0}; + long m_left{0}; + long m_countdown{0}; + + tr808::white_noise m_rng; + }; + + /// The machine: one capture, one slicer, the input send and the balance. + class machine { + public: + machine() { + m_input_level.snap(1.0); + m_mix.snap(k_default_mix); + } + + // -- lifecycle ----------------------------------------------------------------------- + + /// (Re)allocate the capture for `max_history_ms` at `sr`, snap the ramps, reset the + /// grid and re-seed. Not real-time-safe. + void prepare(double sr, double max_history_ms = k_default_max_history_ms) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_capture.prepare(m_sr, max_history_ms); + m_slicer.prepare(m_sr); + m_input_level.snap(m_input_level.target()); + m_mix.snap(m_mix.target()); + } + + /// Erase the capture, drop any slice in flight, and restart the seeded stream. + void clear() { + m_capture.clear(); + m_slicer.clear(); + } + + bool prepared() const { return m_capture.prepared(); } + + // -- parameters ---------------------------------------------------------------------- + + void set_step_ms(double ms) { m_slicer.set_step_ms(ms); } + void set_density(double p) { m_slicer.set_density(p); } + void set_divisions(int n) { m_slicer.set_divisions(n); } + void set_repeats(int n) { m_slicer.set_repeats(n); } + void set_reverse(double p) { m_slicer.set_reverse(p); } + void set_jump_ms(double ms) { m_slicer.set_jump_ms(ms); } + void set_fade_ms(double ms) { m_slicer.set_fade_ms(ms); } + void set_seed(uint64_t seed) { m_slicer.set_seed(seed); } + + /// Input level into the capture, linear, slewed. + void set_input_level(double lin) { m_input_level.to(lin, smooth_samples()); } + + /// Balance between the live input and the slice, 0..100, equal-power — and it only + /// bites while a slice is firing (see the header's limits). + void set_mix(double pct) { m_mix.to(std::clamp(pct, 0.0, 100.0), smooth_samples()); } + + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + double step_ms() const { return m_slicer.step_ms(); } + double density() const { return m_slicer.density(); } + int divisions() const { return m_slicer.divisions(); } + int repeats() const { return m_slicer.repeats(); } + double reverse() const { return m_slicer.reverse(); } + double jump_ms() const { return m_slicer.jump_ms(); } + double fade_ms() const { return m_slicer.fade_ms(); } + uint64_t seed() const { return m_slicer.seed(); } + bool playing() const { return m_slicer.playing(); } + double input_level() const { return m_input_level.target(); } + double mix() const { return m_mix.target(); } + double smooth_ms() const { return m_smooth_ms; } + double max_history_ms() const { return m_capture.history_ms(); } + double samplerate() const { return m_sr; } + + // -- audio --------------------------------------------------------------------------- + + double process(double in) { + if (!prepared()) { + return in; + } + const double send = m_input_level.tick(); + const double mix = m_mix.tick(); + + m_capture.write(send * in); + const slicer::out s = m_slicer.process(m_capture); + + // Idle is a bitwise passthrough at any mix: there is nothing to blend against, + // and equal-power blending a signal with itself would only make it louder. + if (!s.firing) { + return in; + } + if (mix <= 0.0) { + return in; + } + if (mix >= 100.0) { + return s.value; + } + const double theta = mix * 0.01 * (tape::k_pi * 0.5); + return std::cos(theta) * in + std::sin(theta) * s.value; + } + + /// Block form: the trivial loop over the scalar path. + void process(const double* in, double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(in[i]); + } + } + + private: + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double m_sr{48000.0}; + double m_smooth_ms{k_default_smooth_ms}; + capture m_capture; + slicer m_slicer; + tape::ramp m_input_level; // linear + tape::ramp m_mix; // 0..100 + }; + + } // namespace stammer +} // namespace tap::tools diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index b6a1835..fbd71ec 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -22,6 +22,7 @@ #include "nr.h" #include "overdrive.h" #include "spectra.h" +#include "stammer.h" #include "stft.h" #include "svf.h" #include "swing_vca.h" diff --git a/notebooks/stammer.ipynb b/notebooks/stammer.ipynb new file mode 100644 index 0000000..3862c03 --- /dev/null +++ b/notebooks/stammer.ipynb @@ -0,0 +1,551 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "76a3e29d", + "metadata": {}, + "source": [ + "# tap.stammer~ — the stutter, measured\n", + "\n", + "The live buffer-stutter rig (`taptools/stammer.h`): the input is captured continuously, and on a\n", + "rhythmic grid the machine rolls dice and re-fires a slice of what just went past. It is an\n", + "original design in the brassage tradition (Roads, *Microsound*, MIT Press 2001) — the lineage to\n", + "Jonny Greenwood's own Max patches is about *what the object is for*, not about anything in the\n", + "code.\n", + "\n", + "Two contracts carry it. The first is an identity: pin the dice to a single outcome and the whole\n", + "machine must reduce to **exactly a one-step delay**, bitwise — which is how the grid timing, the\n", + "slice origin arithmetic and the playback head get pinned together rather than one at a time. The\n", + "second is the family's seeded-randomness convention: **a seed is a performance you can replay**,\n", + "and at `density` 0 the dice are never rolled at all, so the seed provably cannot matter.\n", + "\n", + "Every trace drives the **shipping C++** through `tools/capi` via ctypes.\n", + "\n", + "Sections: **1** the pinned-dice identity · **2** what the dials do · **3** a seed is a performance\n", + "· **4** the disabled-generator contract · **5** the per-repeat flanks · **6** the material contract" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cbf3fc13", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T23:45:21.310820Z", + "iopub.status.busy": "2026-08-15T23:45:21.310609Z", + "iopub.status.idle": "2026-08-15T23:45:21.804915Z", + "shell.execute_reply": "2026-08-15T23:45:21.803919Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def stammer(**params):\n", + " # Instant setters and a full-wet balance; sections opt into the dice.\n", + " base = dict(smooth_ms=0, mix=100, input_level=1.0)\n", + " base.update(params)\n", + " return tap.Stammer(sr, 4000.0, **base)\n", + "\n", + "def pluck_train(seconds, period=0.31):\n", + " # The documented material: transients, and a phrase rather than one note repeating — real\n", + " # playing is what this object is for, and a single repeated note would flatter it.\n", + " pitches = np.array([196.0, 233.1, 261.6, 349.2, 293.7])\n", + " t = np.arange(int(seconds * sr)) / sr\n", + " phi = np.mod(t, period)\n", + " hz = pitches[(t // period).astype(int) % pitches.size]\n", + " out = np.zeros_like(t)\n", + " for k in range(1, 6):\n", + " out += (1.0 / k) * np.exp(-phi * (4.0 + 3.0 * k)) * np.sin(2 * np.pi * hz * k * phi)\n", + " return 0.5 * out" + ] + }, + { + "cell_type": "markdown", + "id": "259288df", + "metadata": {}, + "source": [ + "## 1 · The pinned-dice identity\n", + "\n", + "Set the dice so only one outcome is possible — always fire (`density` 1), whole-step slices\n", + "(`divisions` 1), a single pass (`repeats` 1), forwards (`reverse` 0), no reach-back (`jump` 0), no\n", + "flank (`fade` 0) — and every grid point grabs exactly the step that just went past and plays it\n", + "once. That is a pure delay of one step less one sample, and it holds sample for sample.\n", + "\n", + "The value of this as a test is that three separate mechanisms fail it: an off-by-one in the grid\n", + "countdown, in the slice origin, or in the playback head. (Pinned by the kernel scenario *\"with the\n", + "dice pinned, the machine is exactly a one-step delay\"*.)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2bdd2343", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T23:45:21.808200Z", + "iopub.status.busy": "2026-08-15T23:45:21.807853Z", + "iopub.status.idle": "2026-08-15T23:45:22.102204Z", + "shell.execute_reply": "2026-08-15T23:45:22.101106Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "bitwise a one-step delay: True\n", + "max |difference|: 0.0\n", + "and not a bypass: True\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "step_ms = 100.0\n", + "step = int(step_ms * 0.001 * sr)\n", + "x = pluck_train(1.5)\n", + "\n", + "m = stammer(step_ms=step_ms, density=1.0, divisions=1, repeats=1,\n", + " reverse=0.0, jump_ms=0.0, fade_ms=0.0)\n", + "y = m.process(x)\n", + "\n", + "print(f\"bitwise a one-step delay: {np.array_equal(y[step:], x[1:x.size - step + 1])}\")\n", + "print(f\"max |difference|: {np.max(np.abs(y[step:] - x[1:x.size - step + 1]))}\")\n", + "print(f\"and not a bypass: {not np.array_equal(y[step:], x[step:])}\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "w = slice(int(0.30 * sr), int(0.75 * sr))\n", + "t = np.arange(x.size)[w] / sr\n", + "ax.plot(t, x[w], color=C[0], lw=0.8, label=\"input\")\n", + "ax.plot(t, y[w], color=C[2], lw=0.8, label=\"output\")\n", + "for g in range(3, 8):\n", + " ax.axvline(g * step / sr, color=C[3], lw=0.8, ls=\":\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"amplitude\")\n", + "ax.set_title(\"dice pinned: each grid point (dotted) replays the step just past\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7caabf1d", + "metadata": {}, + "source": [ + "## 2 · What the dials do\n", + "\n", + "`density` is how often the machine grabs at an idle grid point; `repeats` is how many passes it\n", + "holds on for once it has. They are not interchangeable — a slice in flight is never interrupted,\n", + "so `repeats` is what actually decides how long the machine stays busy, and past the point where\n", + "trains overlap, raising density stops having an effect.\n", + "\n", + "Below, the busy fraction measured directly off the object's `playing` flag, sample by sample." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "19c9b151", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T23:45:22.104415Z", + "iopub.status.busy": "2026-08-15T23:45:22.104213Z", + "iopub.status.idle": "2026-08-15T23:45:34.038274Z", + "shell.execute_reply": "2026-08-15T23:45:34.037113Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " density 0.3, repeats 1: busy 41.0% of the time (100 grid points)\n", + " density 0.3, repeats 6: busy 76.0% of the time (100 grid points)\n", + " density 0.9, repeats 1: busy 90.0% of the time (100 grid points)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " density 0.9, repeats 6: busy 96.0% of the time (100 grid points)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def occupancy(seconds=6.0, **params):\n", + " m = stammer(**params)\n", + " src = pluck_train(seconds)\n", + " flags = np.zeros(src.size, dtype=bool)\n", + " for i, v in enumerate(src):\n", + " m.process(np.array([v]))\n", + " flags[i] = m.playing\n", + " return flags\n", + "\n", + "step_ms = 60.0 # 100 grid points across the 6 s render: enough for the fractions to mean something\n", + "runs = {\n", + " \"density 0.3, repeats 1\": dict(step_ms=step_ms, density=0.3, divisions=1, repeats=1, seed=7),\n", + " \"density 0.3, repeats 6\": dict(step_ms=step_ms, density=0.3, divisions=1, repeats=6, seed=7),\n", + " \"density 0.9, repeats 1\": dict(step_ms=step_ms, density=0.9, divisions=1, repeats=1, seed=7),\n", + " \"density 0.9, repeats 6\": dict(step_ms=step_ms, density=0.9, divisions=1, repeats=6, seed=7),\n", + "}\n", + "flags = {k: occupancy(**v) for k, v in runs.items()}\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 2.6))\n", + "for n, (label, f) in enumerate(flags.items()):\n", + " ax.fill_between(np.arange(f.size) / sr, n, n + f * 0.8, color=C[n], step=\"mid\", lw=0)\n", + " print(f\"{label:>24}: busy {100.0 * f.mean():5.1f}% of the time \"\n", + " f\"({int(6.0 * 1000.0 / step_ms)} grid points)\")\n", + "ax.set_yticks([n + 0.4 for n in range(len(flags))]); ax.set_yticklabels(list(flags))\n", + "ax.set_xlabel(\"time (s)\")\n", + "ax.set_title(\"when a slice is in flight — repeats, not density, is the hold\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8485f15f", + "metadata": {}, + "source": [ + "## 3 · A seed is a performance you can replay\n", + "\n", + "Every draw — fire, division, repeat count, reach-back, and the per-repeat coin for reverse —\n", + "comes from the family's seeded xorshift64* in a fixed order. Two runs of the same seed and the\n", + "same moves are bit-identical; two seeds are genuinely different performances, not a cosmetic\n", + "reshuffle. That is what makes a render reproducible and what lets two instances decorrelate." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2dfbd5f0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T23:45:34.040510Z", + "iopub.status.busy": "2026-08-15T23:45:34.040319Z", + "iopub.status.idle": "2026-08-15T23:45:34.255241Z", + "shell.execute_reply": "2026-08-15T23:45:34.254328Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "same seed, bitwise identical: True\n", + "different seed, differs in: 89.4% of samples\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def run(seed):\n", + " m = stammer(step_ms=70.0, density=0.6, divisions=4, repeats=6,\n", + " reverse=0.4, jump_ms=120.0, fade_ms=3.0, seed=seed)\n", + " return m.process(pluck_train(3.0))\n", + "\n", + "a, b, cc = run(12345), run(12345), run(999)\n", + "print(f\"same seed, bitwise identical: {np.array_equal(a, b)}\")\n", + "print(f\"different seed, differs in: {100.0 * np.mean(a != cc):.1f}% of samples\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "w = slice(int(1.0 * sr), int(1.8 * sr))\n", + "t = np.arange(a.size)[w] / sr\n", + "ax.plot(t, a[w], color=C[0], lw=0.8, label=\"seed 12345\")\n", + "ax.plot(t, cc[w] - 1.2, color=C[2], lw=0.8, label=\"seed 999 (offset)\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_yticks([])\n", + "ax.set_title(\"same settings, same material, two seeds\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "734d51c8", + "metadata": {}, + "source": [ + "## 4 · The disabled-generator contract\n", + "\n", + "`garden.h` established the shape: a generator that is switched off must not consume its random\n", + "stream, so the seed provably cannot matter. Here `density` 0 means the dice are never rolled —\n", + "and because nothing ever fires, the object is also a bitwise bypass at any mix (there is nothing\n", + "to blend against, and equal-power blending a signal with itself would only make it louder)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "82ab67e0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T23:45:34.257291Z", + "iopub.status.busy": "2026-08-15T23:45:34.257110Z", + "iopub.status.idle": "2026-08-15T23:45:34.275807Z", + "shell.execute_reply": "2026-08-15T23:45:34.274843Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "two seeds give identical output: True\n", + "and it is a bitwise bypass: True\n", + "still bitwise at mix 50: True\n" + ] + } + ], + "source": [ + "src = pluck_train(1.0)\n", + "quiet_a = stammer(step_ms=70.0, density=0.0, seed=1).process(src)\n", + "quiet_b = stammer(step_ms=70.0, density=0.0, seed=0xfeedface).process(src)\n", + "mid_mix = tap.Stammer(sr, 4000.0, smooth_ms=0, mix=50, step_ms=70.0, density=0.0).process(src)\n", + "\n", + "print(f\"two seeds give identical output: {np.array_equal(quiet_a, quiet_b)}\")\n", + "print(f\"and it is a bitwise bypass: {np.array_equal(quiet_a, src)}\")\n", + "print(f\"still bitwise at mix 50: {np.array_equal(mid_mix, src)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ea3bfc96", + "metadata": {}, + "source": [ + "## 5 · The per-repeat flanks\n", + "\n", + "Each repeat gets a raised-sine flank at both edges: exactly zero at the edges, exactly unity\n", + "across the plateau. Repeats are sequential rather than overlapped, so every junction dips to\n", + "zero — that is the articulation of a stutter, and it is deliberate rather than a crossfade that\n", + "failed.\n", + "\n", + "Driving the machine with a held DC input makes the slice material exactly 1.0, so the output *is*\n", + "the envelope." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e8cfb939", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T23:45:34.278300Z", + "iopub.status.busy": "2026-08-15T23:45:34.278102Z", + "iopub.status.idle": "2026-08-15T23:45:34.378805Z", + "shell.execute_reply": "2026-08-15T23:45:34.377752Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "opens at exactly zero: True\n", + "closes at exactly zero: True\n", + "plateau is exactly one: True\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "step_ms, fade_ms = 50.0, 2.0\n", + "step, fade = int(step_ms * 0.001 * sr), int(fade_ms * 0.001 * sr)\n", + "m = stammer(step_ms=step_ms, density=1.0, divisions=1, repeats=1,\n", + " reverse=0.0, jump_ms=0.0, fade_ms=fade_ms)\n", + "env = m.process(np.ones(int(0.5 * sr)))\n", + "\n", + "base = 2 * step\n", + "print(f\"opens at exactly zero: {env[base] == 0.0}\")\n", + "print(f\"closes at exactly zero: {env[base + step - 1] == 0.0}\")\n", + "print(f\"plateau is exactly one: {env[base + fade] == 1.0 and env[base + step // 2] == 1.0}\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "seg = env[base - step // 4 : base + step + step // 4]\n", + "ax.plot(np.arange(seg.size) / sr * 1000.0, seg, color=C[0], lw=1.0)\n", + "ax.set_xlabel(\"time (ms)\"); ax.set_ylabel(\"gain\")\n", + "ax.set_title(f\"one repeat's envelope: {fade_ms:.0f} ms raised-sine flanks, unity plateau\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f02225c3", + "metadata": {}, + "source": [ + "## 6 · The material contract, measured\n", + "\n", + "The header states it plainly: this object wants transient material, and on a sustained tone a\n", + "stutter is barely distinguishable from a tremolo. That is not a taste claim — it is a property of\n", + "self-similarity. Every slice of a steady sine looks like every other slice, so re-ordering them\n", + "changes almost nothing; slices of a plucked phrase are all different, so re-ordering them is the\n", + "whole effect.\n", + "\n", + "What is measurable here is the premise, and it is a property of the *material*, not of the\n", + "machine: how alike are two arbitrary slices of it? Below, many random slices of each material are\n", + "compared by magnitude spectrum (phase-free, since a stutter re-orders slices without regard to\n", + "phase) and averaged pairwise. A number near 1 means every slice looks like every other one — and\n", + "re-ordering interchangeable things cannot do much." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ca624766", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-15T23:45:34.381491Z", + "iopub.status.busy": "2026-08-15T23:45:34.381296Z", + "iopub.status.idle": "2026-08-15T23:45:34.755850Z", + "shell.execute_reply": "2026-08-15T23:45:34.754564Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " sustained sine (196 Hz): slices are 1.000 alike\n", + " plucked phrase: slices are 0.286 alike\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def slice_similarity(x, win_ms=60.0, n=96, seed=0):\n", + " # Mean pairwise cosine similarity of the magnitude spectra of n random slices.\n", + " rng = np.random.default_rng(seed)\n", + " w = int(win_ms * 0.001 * sr)\n", + " window = np.hanning(w)\n", + " specs = []\n", + " for start in rng.integers(0, x.size - w, n):\n", + " s = np.abs(np.fft.rfft(x[start:start + w] * window))\n", + " norm = np.linalg.norm(s)\n", + " if norm > 0:\n", + " specs.append(s / norm)\n", + " specs = np.array(specs)\n", + " gram = specs @ specs.T\n", + " iu = np.triu_indices(specs.shape[0], 1)\n", + " return float(gram[iu].mean())\n", + "\n", + "t = np.arange(int(3.0 * sr)) / sr\n", + "materials = {\n", + " \"sustained sine (196 Hz)\": 0.5 * np.sin(2 * np.pi * 196.0 * t),\n", + " \"plucked phrase\": pluck_train(3.0),\n", + "}\n", + "for label, src in materials.items():\n", + " print(f\"{label:>24}: slices are {slice_similarity(src):.3f} alike\")\n", + "\n", + "# What the machine does with each is the consequence, not a second measurement: the same seeded\n", + "# performance, plotted on both materials.\n", + "settings = dict(step_ms=120.0, density=0.8, divisions=4, repeats=5,\n", + " reverse=0.4, jump_ms=250.0, fade_ms=3.0, seed=5)\n", + "fig, axes = plt.subplots(2, 1, figsize=(9, 4.4), sharex=True)\n", + "for ax, (label, src) in zip(axes, materials.items()):\n", + " out = stammer(**settings).process(src)\n", + " w = slice(int(1.0 * sr), int(2.4 * sr))\n", + " ax.plot(np.arange(src.size)[w] / sr, src[w], color=C[3], lw=0.7, alpha=0.7, label=\"input\")\n", + " ax.plot(np.arange(out.size)[w] / sr, out[w], color=C[0], lw=0.7, label=\"stammered\")\n", + " ax.set_title(label, fontsize=10); ax.legend(loc=\"upper right\", fontsize=8)\n", + "axes[-1].set_xlabel(\"time (s)\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "821a4c0b", + "metadata": {}, + "source": [ + "## Checkpoint\n", + "\n", + "- With the dice pinned to one outcome the machine is **bitwise** a one-step delay — grid, origin\n", + " and playback head all pinned by one identity.\n", + "- `repeats`, not `density`, is what holds the machine busy; a slice in flight is never\n", + " interrupted.\n", + "- A seed is a performance: same seed, bit-identical render; different seed, a different\n", + " performance.\n", + "- At `density` 0 the dice are never rolled, and the object is a bitwise bypass at any mix.\n", + "- Each repeat's flanks reach exactly zero and its plateau is exactly unity.\n", + "- The material contract rests on a measurable property of the material itself: slices of a\n", + " sustained sine are nearly interchangeable, slices of a plucked phrase are not — and re-ordering\n", + " interchangeable things is close to a no-op. Feed this object transients." + ] + } + ], + "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 2d067d6..386af87 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -16,7 +16,8 @@ tap.303.seq~ (`TriggerRow`, `NoteRow`), tap.808.kick~ (`Kick`), tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), the Discreet Music two-machine tape loop tap.discreet~ (`Discreet`), the multi-head tape echo -tap.tapecho~ (`TapEcho`), the Music for Airports +tap.tapecho~ (`TapEcho`), the live buffer-stutter rig tap.stammer~ +(`Stammer`), the Music for Airports incommensurate loop bank tap.airport~ (`Airport`), the generative event loop tap.garden~ (`Garden`), and tap.tune~'s pitch corrector (`Tune`, with the shared DspTap detector passed through as `Yin` for the notebooks' @@ -303,6 +304,24 @@ def load() -> ctypes.CDLL: "taptools_tapecho_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), "taptools_tapecho_clear": ([vp], ctypes.c_int), "taptools_tapecho_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + + "taptools_stammer_create": ([], vp), + "taptools_stammer_destroy": ([vp], None), + "taptools_stammer_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_step_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_density": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_divisions": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_stammer_set_repeats": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_stammer_set_reverse": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_jump_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_fade_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_seed": ([vp, ctypes.c_ulonglong], ctypes.c_int), + "taptools_stammer_set_input_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_mix": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_stammer_clear": ([vp], ctypes.c_int), + "taptools_stammer_playing": ([vp], ctypes.c_int), + "taptools_stammer_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), "taptools_airport_create": ([], vp), "taptools_airport_destroy": ([vp], None), "taptools_airport_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), @@ -1340,6 +1359,75 @@ def __del__(self): self._h = None +class Stammer: + """tap.stammer~'s kernel (tap::tools::stammer::machine): the live + buffer-stutter rig. The input is captured continuously; on a `step_ms` + grid the machine rolls dice and re-fires a slice of what just went past + — `density` how often it grabs, `divisions` how finely it chops (slice = + step / [1, divisions]), `repeats` how many passes it holds on for, + `reverse` the per-repeat chance of running backwards, `jump_ms` how far + further back it may reach. Every draw comes from the family's seeded + xorshift64*, so a seed is a performance you can replay; at density 0 the + dice are never rolled and the object is a bitwise bypass. Mono.""" + + def __init__(self, sr: float = 48000.0, max_history_ms: float = 4000.0, **params): + self._h = _LIB.taptools_stammer_create() + _check(_LIB.taptools_stammer_prepare(self._h, float(sr), float(max_history_ms)), + "prepare") + self.set(**params) + + def set(self, *, step_ms=None, density=None, divisions=None, repeats=None, reverse=None, + jump_ms=None, fade_ms=None, seed=None, input_level=None, mix=None, + smooth_ms=None) -> "Stammer": + # configuration first, so ramped targets in the same call honor the new slew + if smooth_ms is not None: + _check(_LIB.taptools_stammer_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + if seed is not None: + _check(_LIB.taptools_stammer_set_seed(self._h, int(seed)), "seed") + if step_ms is not None: + _check(_LIB.taptools_stammer_set_step_ms(self._h, float(step_ms)), "step_ms") + if density is not None: + _check(_LIB.taptools_stammer_set_density(self._h, float(density)), "density") + if divisions is not None: + _check(_LIB.taptools_stammer_set_divisions(self._h, int(divisions)), "divisions") + if repeats is not None: + _check(_LIB.taptools_stammer_set_repeats(self._h, int(repeats)), "repeats") + if reverse is not None: + _check(_LIB.taptools_stammer_set_reverse(self._h, float(reverse)), "reverse") + if jump_ms is not None: + _check(_LIB.taptools_stammer_set_jump_ms(self._h, float(jump_ms)), "jump_ms") + if fade_ms is not None: + _check(_LIB.taptools_stammer_set_fade_ms(self._h, float(fade_ms)), "fade_ms") + if input_level is not None: + _check(_LIB.taptools_stammer_set_input_level(self._h, float(input_level)), + "input_level") + if mix is not None: + _check(_LIB.taptools_stammer_set_mix(self._h, float(mix)), "mix") + return self + + @property + def playing(self) -> bool: + """True while a slice is sounding.""" + return bool(_LIB.taptools_stammer_playing(self._h)) + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_stammer_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + """Erase the capture, drop the slice in flight, and rewind the seeded + stream — the same seed replays the same performance.""" + _check(_LIB.taptools_stammer_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_stammer_destroy(h) + self._h = None + + class Airport: """tap.airport~'s kernel (tap::tools::airport::loop_bank): up to eight free-running tape loops of unequal, incommensurate lengths, each with a diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 5d32282..64d32a7 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -25,6 +25,7 @@ add_executable(taptools_kernel_tests overdrive_test.cpp spectra_test.cpp step_seq_test.cpp + stammer_test.cpp tapecho_test.cpp tune_test.cpp tr808_clap_test.cpp diff --git a/tests/stammer_test.cpp b/tests/stammer_test.cpp new file mode 100644 index 0000000..6b23144 --- /dev/null +++ b/tests/stammer_test.cpp @@ -0,0 +1,295 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.stammer~ kernel (stammer.h). +/// @details The suite leans on a configuration that is fully deterministic *regardless of the +/// seed* — density 1, whole-step slices, one repeat, no reverse, no jump, no fade — +/// because in that corner the machine must reduce to an exact one-step delay, and +/// that single identity pins the grid timing, the origin arithmetic, and the playback +/// head together, bitwise. Around it: the seeded-performance contract (same seed, +/// same render; different seeds, different renders; density 0 never touches the rng +/// at all — the garden.h idle contract), the repeat invariant, the reverse identity, +/// and the envelope's exact edges. +/// +/// Material contract, per the header: the musical scenarios drive plucks, not sines. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + constexpr double k_pi = 3.14159265358979323846; + + using tap::tools::stammer::machine; + + size_t at(double seconds) { + return static_cast(seconds * k_sr); + } + + /// A machine with everything the tests care about pinned; scenarios opt into the dice. + machine make(double max_history_ms = 2000.0) { + machine m; + m.prepare(k_sr, max_history_ms); + m.set_smooth_ms(0.0); + m.set_input_level(1.0); + m.set_mix(100.0); + m.set_fade_ms(0.0); // bitwise comparisons want the raw material + m.set_jump_ms(0.0); + m.set_reverse(0.0); + m.set_divisions(1); + m.set_repeats(1); + m.set_density(1.0); + return m; + } + + /// The documented material: a train of decaying plucks, not a sine. Transients are what this + /// object is for, and what makes a wrong slice boundary audible in a render. + std::vector pluck_train(size_t n, double period_s = 0.31) { + std::vector x(n, 0.0); + for (size_t i = 0; i < n; ++i) { + const double t = static_cast(i) / k_sr; + const double phi = std::fmod(t, period_s); + const double hz = 196.0; + double sum = 0.0; + for (int k = 1; k <= 5; ++k) { + const double kk = static_cast(k); + sum += (1.0 / kk) * std::exp(-phi * (4.0 + 3.0 * kk)) * std::sin(2.0 * k_pi * hz * kk * phi); + } + x[i] = 0.5 * sum; + } + return x; + } + + std::vector render(machine& m, const std::vector& x) { + std::vector y(x.size(), 0.0); + for (size_t i = 0; i < x.size(); ++i) { + y[i] = m.process(x[i]); + } + return y; + } + +} // namespace + +// The load-bearing identity. With the dice pinned to a single outcome — always fire, whole-step +// slices, one pass, forwards, no reach-back, no flank — every grid point grabs exactly the step +// that just went past and plays it once. That is a pure delay of one step less one sample, and it +// must hold sample for sample. Grid timing, origin arithmetic and the playback head all fail this +// test if any of them is off by one. +SCENARIO("with the dice pinned, the machine is exactly a one-step delay") { + const double step_ms = 100.0; + const size_t step = static_cast(step_ms * 0.001 * k_sr); + + machine m = make(); + m.set_step_ms(step_ms); + + const std::vector x = pluck_train(at(1.5)); + const std::vector y = render(m, x); + + bool exact = true; + for (size_t i = step; i < y.size(); ++i) { + exact = exact && (y[i] == x[i - step + 1]); // bitwise, not approximately + } + REQUIRE(exact); + + // Not vacuous: the material is live, and the delay really did move it. + REQUIRE(std::any_of(y.begin() + static_cast(step), y.end(), [](double v) { return std::abs(v) > 0.01; })); + REQUIRE(!std::equal(x.begin() + static_cast(step), x.end(), y.begin() + static_cast(step))); +} + +SCENARIO("a reversed slice plays the same step backwards") { + const double step_ms = 100.0; + const size_t step = static_cast(step_ms * 0.001 * k_sr); + + machine m = make(); + m.set_step_ms(step_ms); + m.set_reverse(1.0); // every repeat runs backwards + + const std::vector x = pluck_train(at(1.0)); + const std::vector y = render(m, x); + + // Forwards the grab at grid point k reads x[k*step + 1 + j]; backwards it reads the same + // window end-first. + bool exact = true; + for (size_t k = 1; k * step + step <= y.size(); ++k) { + for (size_t j = 0; j < step; ++j) { + exact = exact && (y[k * step + j] == x[k * step - j]); + } + } + REQUIRE(exact); +} + +// Repeats are the only thing that keeps the machine busy past one pass, and a slice in flight is +// never interrupted. So every output sample is either a fresh grab (the one-step delay above) or +// a bit-exact copy of the block one slice-length earlier. Nothing else is legal. +SCENARIO("every sample is either a fresh grab or an exact repeat of the block before it") { + const double step_ms = 80.0; + const size_t step = static_cast(step_ms * 0.001 * k_sr); + + machine m = make(); + m.set_step_ms(step_ms); + m.set_repeats(4); // draws 1..4 passes per fired slice + m.set_seed(20260815); + + const std::vector x = pluck_train(at(2.0)); + const std::vector y = render(m, x); + + size_t fresh = 0, repeated = 0; + bool legal = true; + for (size_t i = 2 * step; i < y.size(); ++i) { + const bool is_fresh = (y[i] == x[i - step + 1]); + const bool is_repeat = (y[i] == y[i - step]); + if (is_fresh) { + ++fresh; + } + else if (is_repeat) { + ++repeated; + } + else { + legal = false; + } + } + INFO("fresh grabs " << fresh << ", repeated samples " << repeated); + REQUIRE(legal); + REQUIRE(fresh > 0); // it does grab new material + REQUIRE(repeated > 0); // and it does hold on: repeats are reaching the output +} + +SCENARIO("a seed is a performance you can replay") { + auto run = [](uint64_t seed) { + machine m = make(); + m.set_step_ms(70.0); + m.set_density(0.6); + m.set_divisions(4); + m.set_repeats(6); + m.set_reverse(0.4); + m.set_jump_ms(120.0); + m.set_fade_ms(3.0); + m.set_seed(seed); + return render(m, pluck_train(at(3.0))); + }; + + const std::vector a = run(12345); + const std::vector b = run(12345); + const std::vector c = run(999); + + bool same = true; + for (size_t i = 0; i < a.size(); ++i) { + same = same && (a[i] == b[i]); // bitwise: the dice are deterministic + } + REQUIRE(same); + + // And a different seed is a different performance, not a cosmetic reshuffle. + size_t differing = 0; + for (size_t i = 0; i < a.size(); ++i) { + if (a[i] != c[i]) { + ++differing; + } + } + INFO("samples differing between seeds: " << differing << " of " << a.size()); + REQUIRE(differing > a.size() / 20); +} + +// The garden.h idle contract, same shape: a disabled generator must not consume its stream, so +// the seed provably cannot matter. Here that also means the object is a bitwise bypass. +SCENARIO("at density 0 the dice are never rolled, so the seed cannot matter") { + auto run = [](uint64_t seed) { + machine m = make(); + m.set_step_ms(70.0); + m.set_density(0.0); + m.set_seed(seed); + return render(m, pluck_train(at(1.0))); + }; + + const std::vector a = run(1); + const std::vector b = run(0xfeedface); + const std::vector x = pluck_train(at(1.0)); + + bool identical = true, passthrough = true; + for (size_t i = 0; i < a.size(); ++i) { + identical = identical && (a[i] == b[i]); + passthrough = passthrough && (a[i] == x[i]); + } + REQUIRE(identical); + REQUIRE(passthrough); // and idle is a bitwise bypass +} + +SCENARIO("an idle machine passes the input through bitwise at any mix") { + machine m = make(); + m.set_step_ms(70.0); + m.set_density(0.0); + m.set_mix(50.0); // mid-mix: there is nothing to blend against, so it must not change the level + + const std::vector x = pluck_train(at(0.5)); + const std::vector y = render(m, x); + + bool exact = true; + for (size_t i = 0; i < y.size(); ++i) { + exact = exact && (y[i] == x[i]); + } + REQUIRE(exact); +} + +SCENARIO("the per-repeat flanks reach exactly zero at both edges") { + const double step_ms = 50.0; + const size_t step = static_cast(step_ms * 0.001 * k_sr); + const double fade_ms = 2.0; + const size_t fade = static_cast(fade_ms * 0.001 * k_sr); + + machine m = make(); + m.set_step_ms(step_ms); + m.set_fade_ms(fade_ms); + + // A held DC input makes the slice material exactly 1.0, so the output IS the envelope. (A + // mechanism check, not a musical one — the material contract is about what the object is for.) + std::vector x(at(0.5), 1.0); + const std::vector y = render(m, x); + + // The second grid point onward grabs fully-recorded material, so the envelope stands alone. + const size_t base = 2 * step; + INFO("slice length " << step << ", flank " << fade); + REQUIRE(y[base] == 0.0); // opens from silence + REQUIRE(y[base + step - 1] == 0.0); // and closes to it + REQUIRE(y[base + fade] == 1.0); // the plateau is unity, exactly + REQUIRE(y[base + step / 2] == 1.0); + + // Monotonic rise across the flank: no ripple, no overshoot. + bool rising = true; + for (size_t i = 1; i <= fade; ++i) { + rising = rising && (y[base + i] >= y[base + i - 1]); + } + REQUIRE(rising); +} + +SCENARIO("clear drops the slice in flight and restarts the seeded stream") { + machine m = make(); + m.set_step_ms(60.0); + m.set_density(0.7); + m.set_repeats(6); + m.set_seed(4242); + + const std::vector x = pluck_train(at(1.0)); + const std::vector a = render(m, x); + + m.clear(); + const std::vector b = render(m, x); + + bool same = true; + for (size_t i = 0; i < a.size(); ++i) { + same = same && (a[i] == b[i]); // clear rewinds the performance exactly + } + REQUIRE(same); +} + +SCENARIO("unprepared, the stammer passes input through") { + machine m; + REQUIRE(m.process(0.7) == 0.7); + REQUIRE(m.process(-0.3) == -0.3); +} diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index ec93a88..c60fd4b 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -1227,6 +1228,85 @@ int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, return with(h, [&](tapecho_machine& m) { m.process(in, outL, outR, static_cast(n)); }); } +// ---- tap.stammer~ -------------------------------------------------------------------------------- + +using stammer_machine = tap::tools::stammer::machine; + +taptools_stammer taptools_stammer_create(void) { + return static_cast(new stammer_machine()); +} + +void taptools_stammer_destroy(taptools_stammer h) { + delete static_cast(h); +} + +int taptools_stammer_prepare(taptools_stammer h, double sr, double max_history_ms) { + if (max_history_ms <= 0.0) { + return -1; + } + return with(h, [&](stammer_machine& m) { m.prepare(sr, max_history_ms); }); +} + +int taptools_stammer_set_step_ms(taptools_stammer h, double ms) { + return with(h, [&](stammer_machine& m) { m.set_step_ms(ms); }); +} + +int taptools_stammer_set_density(taptools_stammer h, double p) { + return with(h, [&](stammer_machine& m) { m.set_density(p); }); +} + +int taptools_stammer_set_divisions(taptools_stammer h, int n) { + return with(h, [&](stammer_machine& m) { m.set_divisions(n); }); +} + +int taptools_stammer_set_repeats(taptools_stammer h, int n) { + return with(h, [&](stammer_machine& m) { m.set_repeats(n); }); +} + +int taptools_stammer_set_reverse(taptools_stammer h, double p) { + return with(h, [&](stammer_machine& m) { m.set_reverse(p); }); +} + +int taptools_stammer_set_jump_ms(taptools_stammer h, double ms) { + return with(h, [&](stammer_machine& m) { m.set_jump_ms(ms); }); +} + +int taptools_stammer_set_fade_ms(taptools_stammer h, double ms) { + return with(h, [&](stammer_machine& m) { m.set_fade_ms(ms); }); +} + +int taptools_stammer_set_seed(taptools_stammer h, unsigned long long seed) { + return with(h, [&](stammer_machine& m) { m.set_seed(static_cast(seed)); }); +} + +int taptools_stammer_set_input_level(taptools_stammer h, double lin) { + return with(h, [&](stammer_machine& m) { m.set_input_level(lin); }); +} + +int taptools_stammer_set_mix(taptools_stammer h, double pct) { + return with(h, [&](stammer_machine& m) { m.set_mix(pct); }); +} + +int taptools_stammer_set_smooth_ms(taptools_stammer h, double ms) { + return with(h, [&](stammer_machine& m) { m.set_smooth_ms(ms); }); +} + +int taptools_stammer_clear(taptools_stammer h) { + return with(h, [&](stammer_machine& m) { m.clear(); }); +} + +int taptools_stammer_playing(taptools_stammer h) { + stammer_machine* m = static_cast(h); + return m ? (m->playing() ? 1 : 0) : -1; +} + +int taptools_stammer_process(taptools_stammer h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](stammer_machine& m) { m.process(in, out, static_cast(n)); }); +} + // ---- tap.airport~ -------------------------------------------------------------------------------- using airport_bank = tap::tools::airport::loop_bank; diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 6885bf5..adbfc41 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -393,6 +393,30 @@ TAPTOOLS_API int taptools_tapecho_clear(taptools_tapecho h); /// Process n samples mono-in / stereo-out (the dry path is mixed to both busses). TAPTOOLS_API int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, double* outR, int n); +// ---- tap.stammer~ (tap::tools::stammer::machine) ------------------------------------------------- + +typedef void* taptools_stammer; + +TAPTOOLS_API taptools_stammer taptools_stammer_create(void); +TAPTOOLS_API void taptools_stammer_destroy(taptools_stammer h); +/// Buy the capture for `max_history_ms` at `sr`; resets the grid and re-seeds. +TAPTOOLS_API int taptools_stammer_prepare(taptools_stammer h, double sr, double max_history_ms); +TAPTOOLS_API int taptools_stammer_set_step_ms(taptools_stammer h, double ms); // the grid +TAPTOOLS_API int taptools_stammer_set_density(taptools_stammer h, double p); // 0..1; 0 never rolls +TAPTOOLS_API int taptools_stammer_set_divisions(taptools_stammer h, int n); // slice = step / [1, n] +TAPTOOLS_API int taptools_stammer_set_repeats(taptools_stammer h, int n); // passes per fired slice +TAPTOOLS_API int taptools_stammer_set_reverse(taptools_stammer h, double p); // 0..1, drawn per repeat +TAPTOOLS_API int taptools_stammer_set_jump_ms(taptools_stammer h, double ms); // extra reach-back +TAPTOOLS_API int taptools_stammer_set_fade_ms(taptools_stammer h, double ms); // per-repeat flank +TAPTOOLS_API int taptools_stammer_set_seed(taptools_stammer h, unsigned long long seed); +TAPTOOLS_API int taptools_stammer_set_input_level(taptools_stammer h, double lin); +TAPTOOLS_API int taptools_stammer_set_mix(taptools_stammer h, double pct); // only bites while firing +TAPTOOLS_API int taptools_stammer_set_smooth_ms(taptools_stammer h, double ms); +TAPTOOLS_API int taptools_stammer_clear(taptools_stammer h); +/// 1 while a slice is sounding, else 0 (-1 on a bad handle). +TAPTOOLS_API int taptools_stammer_playing(taptools_stammer h); +TAPTOOLS_API int taptools_stammer_process(taptools_stammer h, const double* in, double* out, int n); + // ---- tap.airport~ (tap::tools::airport::loop_bank) ----------------------------------------------- typedef void* taptools_airport; diff --git a/tools/render/radiohead_render.cpp b/tools/render/radiohead_render.cpp index b49a2c9..5d2bee4 100644 --- a/tools/render/radiohead_render.cpp +++ b/tools/render/radiohead_render.cpp @@ -1,6 +1,6 @@ /// @file /// @brief Offline renderer for the Radiohead family — writes demo WAVs for listening checks. -/// @details Exercises tapecho.h with no Max involved (the kernels' portability, demonstrated). +/// @details Exercises tapecho.h and stammer.h with no Max involved (the kernels' portability, demonstrated). /// The tape echo is a *performed* effect, so these scenarios move the controls while /// they render rather than auditioning static settings — that is the only way to hear /// what the kernel is actually for. @@ -12,7 +12,12 @@ /// howl with the saturator holding it bounded, the input faded out under it, then /// regeneration pulled back to let it decay), and `tapecho_varispeed` (the motor /// slewed from a short span to a long one mid-phrase — the doppler that a tape -/// machine's speed change *is*). +/// machine's speed change *is*); then `stammer_grid` (the stutter's five dials held +/// still so the mechanism is audible), `stammer_disintegrate` (the performance the +/// object exists for — density, chop, hold and reversal all ridden up until the part +/// comes apart, then the reach-back opened so it quotes material from seconds ago), +/// and `stammer_two_seeds` (the same settings on two seeds back to back: a seed is a +/// performance). /// /// Usage: radiohead_render [output-directory] (default: current directory) /// @author Timothy Place @@ -26,6 +31,7 @@ #include #include +#include #include namespace { @@ -73,11 +79,11 @@ namespace { /// these renders this tool is the caller. Each scenario carries an explicit trim chosen so the /// file peaks below unity on playback; nothing here is normalized after the fact, so the /// relative loudness *within* a render (a howl building over a phrase) is the kernel's own. - void write_scenario(const std::string& path, std::vector stereo, double trim) { - for (double& s : stereo) { + void write_scenario(const std::string& path, std::vector samples, double trim, uint16_t channels = 2) { + for (double& s : samples) { s *= trim; } - write_wav(path, stereo, k_r_sr, 2); + write_wav(path, samples, k_r_sr, channels); } double midi_hz(double pitch) { @@ -122,6 +128,12 @@ namespace { return notes; } + /// The phrase, looped — the stammer scenarios run long enough that seven notes would leave + /// the machine chewing on silence. + double looping_phrase(double t) { + return phrase(demo_phrase(), std::fmod(t, 7.5)); + } + // ---- scenarios ----------------------------------------------------------------------------- void tapecho_heads(const std::string& dir) { @@ -246,6 +258,89 @@ namespace { write_scenario(dir + "/tapecho_varispeed.wav", stereo, 0.35); } + // ---- tap.stammer~ ---------------------------------------------------------------------------- + + /// The five dials that are the instrument, held still so the mechanism is audible on its own. + void stammer_grid(const std::string& dir) { + tap::tools::stammer::machine m; + m.prepare(k_r_sr, 2000.0); + m.set_step_ms(250.0); + m.set_density(0.55); + m.set_divisions(4); + m.set_repeats(4); + m.set_reverse(0.2); + m.set_fade_ms(3.0); + m.set_seed(1999); // the year the first TapTools shipped + m.set_mix(100.0); + + const size_t frames = static_cast(24.0 * k_r_sr); + std::vector mono(frames); + for (size_t i = 0; i < frames; ++i) { + mono[i] = m.process(looping_phrase(static_cast(i) / k_r_sr)); + } + write_scenario(dir + "/stammer_grid.wav", mono, 0.8, 1); + } + + /// The performance the object exists for: a part that comes apart in your hands. Density, + /// chop, hold and reversal all ride up over the render, and the reach-back opens at the end so + /// the machine starts quoting material from seconds ago rather than the bar just played. + void stammer_disintegrate(const std::string& dir) { + tap::tools::stammer::machine m; + m.prepare(k_r_sr, 4000.0); + m.set_step_ms(250.0); + m.set_density(0.15); + m.set_divisions(1); + m.set_repeats(1); + m.set_reverse(0.0); + m.set_fade_ms(4.0); + m.set_seed(2003); // Hail to the Thief + m.set_mix(100.0); + + const double seconds = 40.0; + const size_t frames = static_cast(seconds * k_r_sr); + std::vector mono(frames); + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + const double u = t / seconds; // 0 -> 1 across the render: the hands on the machine + m.set_density(0.15 + 0.8 * u); + m.set_divisions(1 + static_cast(u * 7.99)); + m.set_repeats(1 + static_cast(u * 9.99)); + m.set_reverse(0.6 * u); + m.set_step_ms(250.0 - 130.0 * u); + if (t > 0.75 * seconds) { + m.set_jump_ms(1500.0); // and now it reaches back past the bar + } + mono[i] = m.process(looping_phrase(t)); + } + write_scenario(dir + "/stammer_disintegrate.wav", mono, 0.8, 1); + } + + /// A seed is a performance: the same settings on two seeds, back to back in one file, so the + /// difference is the dice and nothing else. Each half is bit-reproducible on its own. + void stammer_two_seeds(const std::string& dir) { + const double half = 12.0; + const size_t frames = static_cast(half * k_r_sr); + std::vector mono; + mono.reserve(2 * frames); + + for (uint64_t seed : {uint64_t{1}, uint64_t{2}}) { + tap::tools::stammer::machine m; + m.prepare(k_r_sr, 2000.0); + m.set_step_ms(200.0); + m.set_density(0.7); + m.set_divisions(4); + m.set_repeats(5); + m.set_reverse(0.35); + m.set_fade_ms(3.0); + m.set_seed(seed); + m.set_mix(100.0); + for (size_t i = 0; i < frames; ++i) { + mono.push_back(m.process(looping_phrase(static_cast(i) / k_r_sr))); + } + } + write_scenario(dir + "/stammer_two_seeds.wav", mono, 0.8, 1); + } + } // namespace int main(int argc, char** argv) { @@ -254,5 +349,8 @@ int main(int argc, char** argv) { tapecho_three_head(dir); tapecho_selfosc(dir); tapecho_varispeed(dir); + stammer_grid(dir); + stammer_disintegrate(dir); + stammer_two_seeds(dir); return 0; } From a150615d9cebed538278917ebf3d0fc06c9b6ec4 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 15 Aug 2026 23:50:42 +0000 Subject: [PATCH 05/22] Note the stutter rig's Max slice in the family plan The wrapper, its min-api scenarios, the reference page and the help patcher landed in TapTools-Max alongside the pin bump, so two of the family's five objects now read shipped end-to-end. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 1973e98..8259ccd 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,7 +1,7 @@ # Plan — the Radiohead family -> **Status: in progress — `tap.tapecho~` has shipped end-to-end and `tap.stammer~`'s kernel -> has landed (both 2026-08-15); the rest is plan.** This is the drafting record of the 2026-08-15 survey ("are there +> **Status: in progress — `tap.tapecho~` and `tap.stammer~` have both shipped end-to-end +> (2026-08-15); the rest is plan.** This is the drafting record of the 2026-08-15 survey ("are there > Radiohead-inspired objects we should consider?"), amended the same day against the Eno > components wave (`d4cf28a`) before any code was written. It stays after the objects ship, > the plans-directory way; per-chapter drafting records will follow separately when the book @@ -31,7 +31,7 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. | Object | Kernel | Recreates | Standing on | Status | |--------|--------|-----------|-------------|--------| | `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel + Max vertical slice); chapter pending | -| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ kernel shipped 2026-08-15; Max slice + chapter pending | +| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel + Max vertical slice); chapter pending | | `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | planned — gated on source collection | | `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | planned | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | @@ -112,7 +112,7 @@ the C ABI in the notebook. Measured at ship: per-pass generation loss within 0.2 analytic wear transfer on both sides of the corner; wow 10.91 cents measured against 10.88 predicted; every past-unity drive setting plateaus under its analytic ceiling. -### 2. `tap.stammer~` — the live stutter rig *(second; the most "us")* — ✅ kernel shipped +### 2. `tap.stammer~` — the live stutter rig *(second; the most "us")* — ✅ shipped > **Shipped 2026-08-15**: `include/taptools/stammer.h` (the planned `capture` + `slicer` split > under a thin `machine`), `tests/stammer_test.cpp` (9 scenarios), the C ABI + ctypes surface @@ -127,8 +127,9 @@ predicted; every past-unity drive setting plateaus under its analytic ceiling. > bitwise; a seed replays bit-identically while a different seed changes 89% of samples; at > density 0 the rng is provably untouched and the object is a bitwise bypass at any mix; and the > material contract is measured at its premise — slices of a sustained sine are 1.000 alike by -> magnitude spectrum, slices of a plucked phrase 0.286. Still to come: the Max vertical slice -> and the book chapter. +> magnitude spectrum, slices of a plucked phrase 0.286. The Max vertical slice followed the +> same day (wrapper, five min-api scenarios, maxref, help patcher, pin bump — REVIVAL.md entry +> 19). Still to come: the book chapter and the on-Mac validation pass. The disintegrating guitar at the end of *Go To Sleep* and the mangling in *The Gloaming* come from Greenwood's own Max patches: capture the live input, re-fire randomized slices @@ -232,7 +233,8 @@ is to make that sharing literal, not copied. `tape_loop.h` as the library the components chapter claims it is. ✅ *Kernel done; the stress test passed — the shared machinery needed no changes to serve a second topology.* 2. **`tap.stammer~`** — original design (no sourcing gate), highest Max-lineage - resonance, establishes the family's capture + seeded-performance conventions. + resonance, establishes the family's capture + seeded-performance conventions. ✅ *Done; both + conventions are now in place for `tap.scrub~` to inherit.* 3. **`tap.ondes~`** — the flagship; source collection starts immediately (it parallelizes with 1–2), implementation begins when the gate clears. 4. **`tap.fuzz~`** — small and independent; slots into any gap. From 1e04e6502a5a446c56e616c575ece38e95d231c6 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 02:44:21 +0000 Subject: [PATCH 06/22] Write the Radiohead-family chapters Four chapters in a new Part V, "The machines you ride" -- the name the family thesis earned: where the Eno part is systems you set up and walk away from, these are objects whose point is the performance surface. User-facing: "Four heads and a motor" (tap.tapecho~) opens on that posture difference and treats the bitwise null test against delay.h as the design claim rather than a curiosity; "The part that comes apart" (tap.stammer~) leads with the thing to internalize before patching -- density grabs, repeats holds -- and presents the material contract as a measurement. Machine appendices: tapecho.h is deliberately the book's shortest, because its content is that tape_loop.h needed no changes at all to serve a second topology; stammer.h spends its space on how to pin three interacting integer clocks with one identity, plus the draw order as contract and why not every class boundary is a seam. Figures are measured through the C ABI per the eno.py rule. The occupancy figure's first draft emitted a 117 MB SVG from a per-sample fill_between at 48 kHz; busy stretches are now drawn as spans computed from run boundaries, same picture at 44 KB. Also fixes introduction.md, whose part list had been stale since the Eno wave landed -- it still called Part IV "The spectral set" and stopped at Part IX. It now matches the eleven parts that exist. The drafting record notes that the list is an unchecked second copy of SUMMARY's structure. mdbook builds clean with create-missing = false. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-chapters.md | 151 ++ book/PLAN-radiohead-family.md | 30 +- book/figures/radiohead.py | 206 +++ book/src/SUMMARY.md | 19 +- book/src/images/stammer/material.svg | 209 +++ book/src/images/stammer/occupancy.svg | 1333 ++++++++++++++++++ book/src/images/tapecho/head-layout.svg | 283 ++++ book/src/images/tapecho/self-oscillation.svg | 326 +++++ book/src/introduction.md | 21 +- book/src/machine/stammer.md | 147 ++ book/src/machine/tapecho.md | 114 ++ book/src/stammer.md | 140 ++ book/src/tapecho.md | 151 ++ 13 files changed, 3103 insertions(+), 27 deletions(-) create mode 100644 book/PLAN-radiohead-chapters.md create mode 100644 book/figures/radiohead.py create mode 100644 book/src/images/stammer/material.svg create mode 100644 book/src/images/stammer/occupancy.svg create mode 100644 book/src/images/tapecho/head-layout.svg create mode 100644 book/src/images/tapecho/self-oscillation.svg create mode 100644 book/src/machine/stammer.md create mode 100644 book/src/machine/tapecho.md create mode 100644 book/src/stammer.md create mode 100644 book/src/tapecho.md diff --git a/book/PLAN-radiohead-chapters.md b/book/PLAN-radiohead-chapters.md new file mode 100644 index 0000000..299956e --- /dev/null +++ b/book/PLAN-radiohead-chapters.md @@ -0,0 +1,151 @@ +# Plan — the Radiohead-family chapters + +> **Status: drafted.** All four chapters are written and live in `src/` per the placement +> below (2026-08-15). This file remains as the drafting record, the plans-directory way. The +> object-level plan is `PLAN-radiohead-family.md`; this one covers only the book. + +Planning document for the *Tools on Tap* chapters covering the first two Radiohead-family +objects (`tap.tapecho~`, `tap.stammer~`; `taptools/tapecho.h`, `stammer.h`). Four chapters: +two user-facing, two machine appendices. It is not part of the built book. + +Every measured claim below already exists as an executed notebook cell or a pinned test — +each section lists its evidence, so the chapters keep the book's "measured, not remembered" +promise without new lab work. + +The family's thesis, which every chapter serves and none re-derives: where the Eno family's +spine was *degradation is the stability mechanism*, this family's is **the control is the +instrument**. These are objects you ride, not systems you set up and walk away from — which +is what the new part is named for, and what justifies a part boundary rather than filing the +tape echo next to `tap.discreet~` on topology grounds. + +## Placement in SUMMARY.md + +A new part after Part IV (Tape and time); Parts V–X renumber to VI–XI. The two machine +entries append to the file-by-file part, keeping its chronological order. + +```md +# Part V — The machines you ride + +- [Four heads and a motor](tapecho.md) +- [The part that comes apart](stammer.md) + +# Part X — The machine, file by file + ...existing entries... +- [Events, not audio: garden.h](machine/garden.md) +- [Composition, not construction: tapecho.h](machine/tapecho.md) +- [Dice you can replay: stammer.h](machine/stammer.md) +``` + +**Found while renumbering:** `introduction.md`'s part list had been stale since the Eno wave +landed — it still described Part IV as "The spectral set" and stopped at Part IX. It is now +rewritten to match the eleven parts that actually exist. Worth a standing note: the +introduction's list is a second copy of SUMMARY's structure and nothing checks the two +against each other, so any future part insertion has to touch both by hand. + +## Figures + +Measured figures generated by `book/figures/radiohead.py` — the `eno.py` regeneration +contract, driving the shipping kernels through the C ABI rather than illustrating them: + +- `images/tapecho/head-layout.svg` — one impulse, four heads, returns on the `span × ratio` + grid. +- `images/tapecho/self-oscillation.svg` — measured peak against drive at regen 1.4, under + the analytic ceiling at every point. +- `images/stammer/occupancy.svg` — when a slice is in flight, four density/repeat pairs. +- `images/stammer/material.svg` — slice similarity for a sustained sine vs a played phrase. + +No hand-authored block diagrams this round. The Eno chapters needed them because their +signal flow is a rig with named machines; these two are a tape line with extra read points +and a buffer with dice, and the measured figures carry more than a box diagram would. If a +diagram is ever added, the obvious one is the stammer's grid/slice/repeat timeline. + +One thing the generator learned the hard way, recorded so it is not re-learned: the +occupancy figure's first draft used `fill_between` over a per-sample boolean at 48 kHz and +emitted a **117 MB SVG**. Busy stretches are now drawn as `broken_barh` spans computed from +the run boundaries — same picture, 44 KB. Any future per-sample state figure should do the +same. + +## Evidence the chapters are allowed to cite + +Everything traces to an executed notebook cell or a pinned scenario. + +`tap.tapecho~` — `notebooks/tapecho.ipynb`, `tests/tapecho_test.cpp`: + +- head returns land exactly on `span × ratio`, at the centre-pan level `cos(π/4)` + (§1; scenario *"each head echoes at its own position along the tape path"*) +- **bitwise** equality with `delay.h`'s multitap when the tape path is neutral, in the kernel + suite and again across the C ABI (§2; *"with the tape path neutral, a one-head echo is + bitwise the multitap of delay.h"*) +- per-pass generation loss 0.2915 measured vs 0.2920 predicted at 6 kHz, 0.8895 vs 0.8898 at + 300 Hz (§3) +- past-unity regeneration plateaus under `|in|max + regen/drive` at every drive measured; + growth ratio 1.007 between late windows; drive 0 caps back to 1.0 (§4; *"regeneration past + unity self-oscillates but stays bounded"*, *"at drive 0 the regeneration cap falls back to + unity"*) +- wow 10.91 cents measured against 10.88 predicted, two runs bit-identical (§5) +- the varispeed glide: 220 Hz mid-glide, 440 Hz within 5 cents settled (*"a span change + glides as tape speed, not a splice"*) + +`tap.stammer~` — `notebooks/stammer.ipynb`, `tests/stammer_test.cpp`: + +- the pinned-dice one-step-delay identity, bitwise (§1; *"with the dice pinned, the machine + is exactly a one-step delay"*) +- occupancy 41 / 76 / 90 / 96 % across the four density/repeat pairs, 100 grid points each + (§2) +- same seed bit-identical, different seed changes 89.4 % of samples (§3) +- density 0: two seeds identical, bitwise bypass, still bitwise at mix 50 (§4) +- flanks exactly 0 at both edges and exactly 1 on the plateau (§5) +- slice similarity 1.000 (sine) vs 0.286 (played phrase) (§6) + +**A measurement that did not survive drafting**, recorded because the lesson generalizes: the +material contract was first measured as the best lag-correlation between output and input, +on the theory that a self-similar material would leave the output looking like a delayed +copy. It measured the opposite of the claim (sine 0.279, plucks 0.450) because the test +material was itself periodic, so aligning envelopes at a matching lag flattered the plucks. +The metric was replaced with slice similarity — which measures the contract's *premise* +(are two arbitrary slices interchangeable?) rather than a downstream consequence — and the +test material was given real pitch variety, since a single repeated note also flatters a +stutter. Prose follows numbers, never the reverse. + +## Structure + +### `src/tapecho.md` — *Four heads and a motor* + +Opens on the posture difference from `tap.discreet~` (a machine you walk away from vs one you +keep your hands on), which is also the part's thesis. Then: the motor and why `span` is +defined at the ratio-1.0 head; the layout and the nominal-not-measured spacing disclaimer; +past-unity regeneration with the drive-dependent cap; the transport; and the null test framed +as the design claim rather than a curiosity. Recipes, when-not-to, checkpoint. + +### `src/stammer.md` — *The part that comes apart* + +Opens on "Go To Sleep" and the odd fact that this is a Max technique arriving as a Max +object — immediately followed by the IP posture (original design; the rig informs what the +object is for, not what the code does). Then the one thing to internalize before patching: +`density` grabs, `repeats` holds, and holding is what fills the timeline. Character +parameters, the seed as a contract, and the material contract as a measurement. + +### `src/machine/tapecho.md` — *Composition, not construction* + +Deliberately the shortest appendix in the book, because its content is that there was almost +nothing to write: `tape_loop.h` needed **no changes** to serve a second topology. Covers the +one-motor geometry, why the regeneration cap lives in the audio path rather than the setter, +and why the null test had to be bitwise to prove anything. Also records the one-ulp +`cos(π/4)` ≠ `sin(π/4)` fact, since it explains the shape of the test. + +### `src/machine/stammer.md` — *Dice you can replay* + +The interesting content is not the DSP but how to pin three interacting integer clocks at +once, so the pinned-dice identity gets the space. Then: the draw order as part of the +contract, the early return at density 0, ring reads vs a burst memcpy (with the failure mode +stated), the deliberate envelope dip, and the corollary to the components chapter — not every +class boundary is a seam. + +## Deliberately not covered + +- **The Max-side surface.** The reference pages and help patchers carry it; the book's + machine appendices are about the kernel. +- **A recipes entry.** The family will earn one once the fuzz and the Ondes land and there is + a signal chain to describe. `recipes/` is for whole patches, and two objects is not a rig. +- **Comparative listening claims** ("sounds like the record"). Not measurable, not the book's + business. diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 8259ccd..c0474fb 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,11 +1,11 @@ # Plan — the Radiohead family -> **Status: in progress — `tap.tapecho~` and `tap.stammer~` have both shipped end-to-end -> (2026-08-15); the rest is plan.** This is the drafting record of the 2026-08-15 survey ("are there -> Radiohead-inspired objects we should consider?"), amended the same day against the Eno -> components wave (`d4cf28a`) before any code was written. It stays after the objects ship, -> the plans-directory way; per-chapter drafting records will follow separately when the book -> chapters are drafted. Per-object status lives in the table below. +> **Status: in progress — `tap.tapecho~` and `tap.stammer~` have both shipped end-to-end, +> chapters included (2026-08-15); the rest is plan.** This is the drafting record of the +> 2026-08-15 survey ("are there Radiohead-inspired objects we should consider?"), amended the +> same day against the Eno components wave (`d4cf28a`) before any code was written. It stays +> after the objects ship, the plans-directory way; the chapters have their own drafting +> record in `PLAN-radiohead-chapters.md`. Per-object status lives in the table below. Planning document for a family of kernels drawn from Radiohead's performed electronics: the Ondes Martenot, the live Max/MSP mangling rigs, the tape echoes, the Kaoss-pad vocal @@ -30,8 +30,8 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. | Object | Kernel | Recreates | Standing on | Status | |--------|--------|-----------|-------------|--------| -| `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel + Max vertical slice); chapter pending | -| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel + Max vertical slice); chapter pending | +| `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | +| `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | planned — gated on source collection | | `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | planned | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | @@ -75,7 +75,8 @@ The survey predated the Eno components wave by hours. Five amendments, now assum > vertical slice in TapTools-Max (wrapper, six min-api scenarios, maxref, help patcher, > pin bump — REVIVAL.md entry 18). What the plan predicted held: the kernel is composition > — the null test below is *bitwise*, and `tape_loop.h` needed no changes at all to serve a -> second topology. Still to come: the book chapter, and the on-Mac validation pass. +> second topology. The chapters shipped the same day (see `PLAN-radiohead-chapters.md`). +> Still to come: the on-Mac validation pass. > > Design decisions taken during implementation that this record should carry: > the head layout is `span_ms` (the motor, = a ratio-1.0 head) times a per-head ratio, so @@ -129,7 +130,8 @@ predicted; every past-unity drive setting plateaus under its analytic ceiling. > material contract is measured at its premise — slices of a sustained sine are 1.000 alike by > magnitude spectrum, slices of a plucked phrase 0.286. The Max vertical slice followed the > same day (wrapper, five min-api scenarios, maxref, help patcher, pin bump — REVIVAL.md entry -> 19). Still to come: the book chapter and the on-Mac validation pass. +> 19), and the chapters with it (see `PLAN-radiohead-chapters.md`). Still to come: the +> on-Mac validation pass. The disintegrating guitar at the end of *Go To Sleep* and the mangling in *The Gloaming* come from Greenwood's own Max patches: capture the live input, re-fire randomized slices @@ -207,10 +209,10 @@ is to make that sharing literal, not copied. performance, the diffuseurs rung by a struck string. - **Oracle-based measurement** where a promise is audible: yin on the echo's wow, yin on the ondes ribbon glide, envelope-power measurement on the stammer slices. -- **Book**: a family part (working titles — *The machine as a band member*; per-object - chapters like *The tape with three heads*, *The patch that stutters*, *Waves and - wire*) plus machine appendices, each with its own PLAN drafting record when drafted, - every number citing an executed cell or pinned test. +- **Book**: a family part — shipped as **Part V, *The machines you ride*** (the title the + family thesis earned), with *Four heads and a motor* and *The part that comes apart* plus + their machine appendices; drafting record in `PLAN-radiohead-chapters.md`. Later objects + join the same part. Every number cites an executed cell or pinned test. ## Provenance and naming (the IP posture, applied) diff --git a/book/figures/radiohead.py b/book/figures/radiohead.py new file mode 100644 index 0000000..cca20be --- /dev/null +++ b/book/figures/radiohead.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""Generate the measured figures for the Radiohead-family book chapters. + +Drives the *shipping* kernels (tapecho.h, stammer.h) through the C ABI via the +notebooks' ctypes bridge — the same rule as eno.py and the verification +notebooks: figures are measurements of the real DSP, never illustrations of +what it should do. The companion notebooks (notebooks/tapecho.ipynb, +stammer.ipynb) carry the same measurements with commentary; this script renders +the book-styled SVGs. + +Regenerate after a kernel behavior change: + + python3 book/figures/radiohead.py # writes book/src/images/{tapecho,stammer}/*.svg + +Colors and rcParams are eno.py's, verbatim in intent: the house categorical +hues with the amber snapped darker so pairs pass the print/CVD lightness-band +checks on a light page, and direct labels everywhere so identity never rides on +color alone. +""" + +import pathlib +import sys + +import numpy as np +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt + +sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[2] / "notebooks")) +import taptools_py as tap + +IMAGES = pathlib.Path(__file__).resolve().parents[1] / "src" / "images" + +BLUE, AMBER, RED = "#4269d0", "#b8890f", "#ff725c" +INK, MUTED = "#1a1a1a", "#666666" + +plt.rcParams.update({ + "figure.dpi": 96, "figure.figsize": (7.2, 3.1), + "svg.fonttype": "none", "font.family": "sans-serif", "font.size": 9.5, + "axes.grid": True, "grid.alpha": 0.22, "grid.linewidth": 0.5, + "axes.spines.top": False, "axes.spines.right": False, + "axes.edgecolor": MUTED, "axes.labelcolor": INK, + "xtick.color": MUTED, "ytick.color": MUTED, + "axes.titlesize": 10, "axes.titlecolor": INK, + "lines.linewidth": 2.0, "legend.frameon": False, "legend.fontsize": 8.5, +}) + +fs = 48000.0 + + +def out_dir(name): + d = IMAGES / name + d.mkdir(parents=True, exist_ok=True) + return d + + +def pluck_train(seconds, period=0.31): + """The family's documented material: transients, and a phrase rather than one + note repeating (a single note would flatter a stutter).""" + pitches = np.array([196.0, 233.1, 261.6, 349.2, 293.7]) + t = np.arange(int(seconds * fs)) / fs + phi = np.mod(t, period) + hz = pitches[(t // period).astype(int) % pitches.size] + out = np.zeros_like(t) + for k in range(1, 6): + out += (1.0 / k) * np.exp(-phi * (4.0 + 3.0 * k)) * np.sin(2 * np.pi * hz * k * phi) + return 0.5 * out + + +def head_layout(): + """tapecho: an impulse returning once per head, on the motor's grid.""" + span = 0.4 + m = tap.TapEcho(fs, 2.0, smooth_ms=0, wow=(0, 0), flutter=(0, 0), regen=0.0, + drive=0.0, darken_hz=20000.0, mix=100, span_ms=span * 1000, heads=4) + x = np.zeros(int(0.55 * fs)) + x[0] = 1.0 + left, _ = m.process(x) + + fig, ax = plt.subplots(figsize=(7.2, 2.5)) + t = np.arange(left.size) / fs * 1000.0 + ax.plot(t, left, color=BLUE, lw=1.0) + for i in range(4): + ms = span * (i + 1) / 4 * 1000.0 + ax.axvline(ms, color=MUTED, lw=0.8, ls=":") + ax.text(ms + 4, 0.60, f"{(i + 1) / 4:.2f}", color=MUTED, fontsize=8.5) + ax.text(150, 0.60, "head position, as a fraction of span", color=MUTED, fontsize=8.5) + ax.set_xlabel("time (ms) — motor span 400 ms") + ax.set_ylabel("output") + ax.set_title("one impulse, four heads: each returns at span × its ratio") + fig.savefig(out_dir("tapecho") / "head-layout.svg", bbox_inches="tight") + plt.close(fig) + + +def self_oscillation(): + """tapecho: past-unity regeneration plateaus under the saturator's ceiling.""" + regen, burst = 1.4, 0.5 + drives = np.array([0.3, 0.5, 0.8, 1.2, 2.0]) + peaks = [] + for d in drives: + m = tap.TapEcho(fs, 2.0, smooth_ms=0, wow=(0, 0), flutter=(0, 0), mix=100, + heads=1, ratios=[1.0], span_ms=250.0, regen=regen, + drive=float(d), darken_hz=6000.0) + x = np.zeros(int(14.0 * fs)) + n = int(burst * fs) + x[:n] = 0.5 * np.random.default_rng(7).uniform(-1, 1, n) + y, _ = m.process(x) + peaks.append(float(np.max(np.abs(y)))) + + # The analytic ceiling on the tape is |in|max + regen/drive (the saturator bounds the + # returned signal by 1/drive; the record head adds the direct send), scaled by the single + # centre-panned head's cos(pi/4). + ceiling = np.cos(np.pi / 4) * (0.5 + regen / drives) + + fig, ax = plt.subplots() + ax.plot(drives, ceiling, "-", color=AMBER, lw=1.2, alpha=0.8) + ax.plot(drives, peaks, "o", color=BLUE, ms=6) + ax.text(0.55, ceiling[1] * 1.06, "ceiling: (|in|max + regen/drive)", color=AMBER) + ax.text(0.55, peaks[1] * 0.72, "measured peak", color=BLUE) + ax.set_xlabel("drive") + ax.set_ylabel("peak |output|") + ax.set_title(f"regen {regen}: self-oscillating, and bounded by the saturator") + fig.savefig(out_dir("tapecho") / "self-oscillation.svg", bbox_inches="tight") + plt.close(fig) + + +def occupancy(): + """stammer: repeats, not density, is what holds the machine busy.""" + step_ms, seconds = 60.0, 6.0 + runs = [ + ("density 0.3, repeats 1", dict(density=0.3, repeats=1), BLUE), + ("density 0.3, repeats 6", dict(density=0.3, repeats=6), AMBER), + ("density 0.9, repeats 1", dict(density=0.9, repeats=1), RED), + ("density 0.9, repeats 6", dict(density=0.9, repeats=6), INK), + ] + src = pluck_train(seconds) + + fig, ax = plt.subplots(figsize=(7.2, 2.6)) + for row, (label, params, color) in enumerate(runs): + m = tap.Stammer(fs, 4000.0, smooth_ms=0, mix=100, step_ms=step_ms, + divisions=1, seed=7, **params) + flags = np.zeros(src.size, dtype=bool) + for i, v in enumerate(src): + m.process(np.array([v])) + flags[i] = m.playing + # Draw the busy stretches as spans, not a per-sample fill: at 48 kHz a fill_between + # over six seconds emits a path with 288k vertices per row (a 117 MB SVG, measured). + edges = np.flatnonzero(np.diff(flags.astype(np.int8))) + bounds = np.concatenate(([0], edges + 1, [flags.size])) + spans = [(lo / fs, (hi - lo) / fs) + for lo, hi in zip(bounds[:-1], bounds[1:]) if flags[lo]] + ax.broken_barh(spans, (row, 0.78), facecolors=color, linewidth=0) + ax.text(seconds + 0.05, row + 0.3, f"{100.0 * flags.mean():.0f}% busy", + color=color, fontsize=8.5) + ax.set_yticks([r + 0.39 for r in range(len(runs))]) + ax.set_yticklabels([r[0] for r in runs], fontsize=8.5) + ax.set_xlim(0, seconds + 1.0) + ax.set_xlabel("time (s)") + ax.set_title("when a slice is in flight — repeats is the hold, not density") + fig.savefig(out_dir("stammer") / "occupancy.svg", bbox_inches="tight") + plt.close(fig) + + +def material(): + """stammer: the material contract, measured at its premise.""" + t = np.arange(int(3.0 * fs)) / fs + materials = [("sustained sine", 0.5 * np.sin(2 * np.pi * 196.0 * t), AMBER), + ("plucked phrase", pluck_train(3.0), BLUE)] + + def similarity(x, win_ms=60.0, n=96, seed=0): + rng = np.random.default_rng(seed) + w = int(win_ms * 0.001 * fs) + window = np.hanning(w) + specs = [] + for start in rng.integers(0, x.size - w, n): + s = np.abs(np.fft.rfft(x[start:start + w] * window)) + norm = np.linalg.norm(s) + if norm > 0: + specs.append(s / norm) + specs = np.array(specs) + gram = specs @ specs.T + return float(gram[np.triu_indices(specs.shape[0], 1)].mean()) + + scores = [similarity(x) for _, x, _ in materials] + + fig, ax = plt.subplots(figsize=(7.2, 2.2)) + ypos = np.arange(len(materials)) + for y, (label, _, color), score in zip(ypos, materials, scores): + ax.barh(y, score, height=0.5, color=color) + ax.text(score + 0.015, y, f"{score:.3f}", color=color, va="center", fontsize=9) + ax.set_yticks(ypos) + ax.set_yticklabels([m[0] for m in materials]) + ax.set_xlim(0, 1.12) + ax.set_xlabel("how alike two arbitrary slices are (1 = interchangeable)") + ax.set_title("the material contract: re-ordering interchangeable things does nothing") + ax.grid(axis="y", visible=False) + fig.savefig(out_dir("stammer") / "material.svg", bbox_inches="tight") + plt.close(fig) + + +if __name__ == "__main__": + head_layout() + self_oscillation() + occupancy() + material() + print("wrote the Radiohead-family figures") diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index 271cb21..82c08e5 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -25,26 +25,31 @@ - [The garden that plays itself](garden.md) - [The same machine, in pieces](components.md) -# Part V — The spectral set +# Part V — The machines you ride + +- [Four heads and a motor](tapecho.md) +- [The part that comes apart](stammer.md) + +# Part VI — The spectral set - [Making the machine talk](vocoder.md) - [A gate for every bin](nr.md) - [The spectrum, re-plumbed](spectra.md) -# Part VI — The rhythm section +# Part VII — The rhythm section - [The acid machine](acid.md) - [The drum machine](drums.md) -# Part VII — Staying in tune +# Part VIII — Staying in tune - [The note you meant](tune.md) -# Part VIII — The pedalboard +# Part IX — The pedalboard - [Distortion with a memory](overdrive.md) -# Part IX — The machine, file by file +# Part X — The machine, file by file - [Solving the filter on paper: svf.h](machine/svf.md) - [The nonlinear loop: ladder.h](machine/ladder.md) @@ -65,8 +70,10 @@ - [Wear as the stabilizer: tape_loop.h and discreet.h](machine/tape.md) - [Free-running heads, one shared clock: airport.h](machine/airport.md) - [Events, not audio: garden.h](machine/garden.md) +- [Composition, not construction: tapecho.h](machine/tapecho.md) +- [Dice you can replay: stammer.h](machine/stammer.md) -# Part X — Recipes +# Part XI — Recipes - [How to read a recipe](recipes/cookbook.md) - [One machine, four decades](recipes/808-classics.md) diff --git a/book/src/images/stammer/material.svg b/book/src/images/stammer/material.svg new file mode 100644 index 0000000..3eb5c74 --- /dev/null +++ b/book/src/images/stammer/material.svg @@ -0,0 +1,209 @@ + + + + + + + + 2026-08-16T02:37:59.767584 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.4 + + + + + + + + + + + + + 0.6 + + + + + + + + + + + + + 0.8 + + + + + + + + + + + + + 1.0 + + + + how alike two arbitrary slices are (1 = interchangeable) + + + + + + + + + + + + + + sustained sine + + + + + + + + + + plucked phrase + + + + + + + + + + + 1.000 + + + 0.286 + + + the material contract: re-ordering interchangeable things does nothing + + + + + + + + + diff --git a/book/src/images/stammer/occupancy.svg b/book/src/images/stammer/occupancy.svg new file mode 100644 index 0000000..28906e9 --- /dev/null +++ b/book/src/images/stammer/occupancy.svg @@ -0,0 +1,1333 @@ + + + + + + + + 2026-08-16T02:37:59.682231 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 1 + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 3 + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 5 + + + + + + + + + + + + + 6 + + + + + + + + + + + + + 7 + + + + time (s) + + + + + + + + + + + + + + + + + density 0.3, repeats 1 + + + + + + + + + + + + + density 0.3, repeats 6 + + + + + + + + + + + + + density 0.9, repeats 1 + + + + + + + + + + + + + density 0.9, repeats 6 + + + + + + + + + + + 41% busy + + + 76% busy + + + 90% busy + + + 96% busy + + + when a slice is in flight — repeats is the hold, not density + + + + + + + + + diff --git a/book/src/images/tapecho/head-layout.svg b/book/src/images/tapecho/head-layout.svg new file mode 100644 index 0000000..9933a32 --- /dev/null +++ b/book/src/images/tapecho/head-layout.svg @@ -0,0 +1,283 @@ + + + + + + + + 2026-08-16T02:37:50.240937 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 100 + + + + + + + + + + + + + 200 + + + + + + + + + + + + + 300 + + + + + + + + + + + + + 400 + + + + + + + + + + + + + 500 + + + + time (ms) — motor span 400 ms + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.4 + + + + + + + + + + + + + 0.6 + + + + output + + + + + + + + + + + + + + + + + + + + + + + + + 0.25 + + + 0.50 + + + 0.75 + + + 1.00 + + + head position, as a fraction of span + + + one impulse, four heads: each returns at span × its ratio + + + + + + + + + diff --git a/book/src/images/tapecho/self-oscillation.svg b/book/src/images/tapecho/self-oscillation.svg new file mode 100644 index 0000000..4d760f8 --- /dev/null +++ b/book/src/images/tapecho/self-oscillation.svg @@ -0,0 +1,326 @@ + + + + + + + + 2026-08-16T02:37:51.028607 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0.25 + + + + + + + + + + + + + 0.50 + + + + + + + + + + + + + 0.75 + + + + + + + + + + + + + 1.00 + + + + + + + + + + + + + 1.25 + + + + + + + + + + + + + 1.50 + + + + + + + + + + + + + 1.75 + + + + + + + + + + + + + 2.00 + + + + drive + + + + + + + + + + + + + + + + + 1.0 + + + + + + + + + + + + + 1.5 + + + + + + + + + + + + + 2.0 + + + + + + + + + + + + + 2.5 + + + + + + + + + + + + + 3.0 + + + + + + + + + + + + + 3.5 + + + + peak |output| + + + + + + + + + + + + + + + + + + + + + + + + + ceiling: (|in|max + regen/drive) + + + measured peak + + + regen 1.4: self-oscillating, and bounded by the saturator + + + + + + + + + diff --git a/book/src/introduction.md b/book/src/introduction.md index 0470ee1..f9f4e40 100644 --- a/book/src/introduction.md +++ b/book/src/introduction.md @@ -29,23 +29,30 @@ The book is organized the way a patch is: - **Part III — Strings, rooms, and spirals**: exact true-stereo convolution (`tap.convolve~`) and the two GRM Tools recreations — the tuned comb bank (`tap.5comb~`) and the pitch-accumulating shimmer loop (`tap.pitchaccum~`). -- **Part IV — The spectral set**: the 24-band vocoder (`tap.vocoder~`), the +- **Part IV — Tape and time**: the Eno recreations — the *Discreet Music* + two-machine tape loop (`tap.discreet~`), the *Music for Airports* + incommensurate loop bank (`tap.airport~`), the generative event garden + (`tap.garden~`), and the components they decompose into. +- **Part V — The machines you ride**: the Radiohead family — objects whose + point is the performance surface rather than a setting. The multi-head tape + echo (`tap.tapecho~`) and the live buffer-stutter rig (`tap.stammer~`). +- **Part VI — 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 rhythm section**: the Roland recreations — the TB-303 voice, +- **Part VII — 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 — Staying in tune**: the pitch corrector (`tap.tune~`) and the +- **Part VIII — Staying in tune**: the pitch corrector (`tap.tune~`) and the detection/resynthesis machinery it stands on. -- **Part VII — The pedalboard**: the stompbox recreations — the voiced feedback +- **Part IX — The pedalboard**: the stompbox recreations — the voiced feedback overdrive (`tap.overdrive~`), chasing the TS-lineage feedback pedals rather than a waveshaping curve. -- **Part VIII — The machine, file by file**: the SampleRateTap-style deep dives — +- **Part X — 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–VII are for driving the objects; Part VIII is for trusting them — + all. Parts I–IX are for driving the objects; Part X is for trusting them — or changing them. -- **Part IX — Recipes**: whole patches chasing specific sounds — the TR-808 +- **Part XI — Recipes**: whole patches chasing specific sounds — the TR-808 kits behind four decades of records, the three-oscillator Moog voice — with settings you can check against the reference pages and the honest accounting of what each ingredient buys. diff --git a/book/src/machine/stammer.md b/book/src/machine/stammer.md new file mode 100644 index 0000000..a352306 --- /dev/null +++ b/book/src/machine/stammer.md @@ -0,0 +1,147 @@ +# Dice you can replay: `stammer.h` + +Most kernels in this library are hard to get wrong quietly: a filter with a +bad coefficient sounds bad. A stutter is not like that. It has three +interacting integer clocks — a grid countdown, a slice origin, and a +playback head — and if any one of them is off by a sample the object still +sounds *fine*. It stutters. It grooves. It is just wrong in a way no amount +of listening will surface. + +So the interesting content of this appendix is not the DSP, which is a +buffer and some dice. It is how you pin three clocks at once. + +## The pinned-dice identity + +Every random draw in the kernel has a setting at which its outcome is +forced. Fire probability 1 always fires. `divisions` 1 always picks the +whole step. `repeats` 1 always plays one pass. `reverse` 0 never reverses. +`jump` 0 never reaches back. `fade` 0 leaves the material alone. + +Set all six and the machine becomes deterministic *regardless of the seed* — +and what it must then be is not a vague "sensible output" but a specific, +checkable thing: **exactly a one-step delay**. At each grid point it grabs +precisely the step that just went past and plays it once, so + +``` +y[i] == x[i - step + 1] +``` + +for every sample after the first grid point, bitwise. + +That single assertion is worth more than three separate off-by-one tests, +because it fails if the grid countdown fires a sample early, if the origin +arithmetic reaches one sample too far back, if the playback head starts at +the wrong index, *or* if any two of those are wrong in ways that would +cancel in a looser test. It is also cheap to reason about, which matters: +a test you cannot re-derive on a whiteboard is a test you will eventually +delete instead of fixing. + +The `+ 1` in that expression is not a fudge. The write head holds the *next* +write position, so after recording sample `i` the newest available sample +sits at position `i`, and a slice of length `step` grabbed at grid point +`k·step` reads positions `k·step + 1 - step` upward. Getting that constant +right by derivation rather than by nudging until the test passed is the +whole discipline; a test you tune to the implementation pins nothing. + +Two smaller identities sit alongside it. With `reverse` 1 the same grab +reads end-first, so `y[k·step + j] == x[k·step - j]` — the mirror of the +first, which catches a reversed-index off-by-one that the forward test +cannot see. And with `repeats` above 1, every output sample must be *either* +a fresh grab or a bit-exact copy of the block one slice-length earlier; +nothing else is legal, because a slice in flight is never interrupted. That +invariant covers the repeat machinery without needing to know how many +passes the dice chose. + +## The draw order is part of the ABI + +`maybe_fire()` draws in a fixed order: fire, division, repeat count, +reach-back, then the first reverse coin. Each subsequent repeat draws its +own reverse coin as it starts. + +That order is not an implementation detail — it is what "a seed is a +performance" means. Reordering two draws, or adding a draw in the middle, +silently changes every render anyone has ever made with a given seed. +`garden.h` established the same discipline for the gardener; this file +inherits it, and the comment above the function says so in as many words so +the next person to add a parameter knows to append rather than insert. + +The disabled case is the sharp end of it. At `density` 0 the function +returns *before* drawing anything: + +```cpp +if (m_density <= 0.0) { + return; // the dice are never rolled, so the seed provably cannot matter +} +``` + +The lazier version — draw, then compare against 0 and fail — behaves +identically to the ear, and would be indistinguishable in almost any test. +It would also consume one number per grid point, so the seed *would* matter: +switch density off and on again, and the stream is somewhere else. The +garden made this a family contract, and it is pinned here by a test that +runs two different seeds at density 0 and requires bit-identical output. + +## Reading from the ring, and what it costs + +A slice does not copy its material. It stores an origin and reads from the +capture ring as it plays. + +The alternative — memcpy the slice into a private buffer at fire time — +would be more obviously correct, and it is what a first draft wants to do. +It was rejected because it is a burst copy in the audio thread: half a +second of slice is 24,000 doubles moved inside one `process()` call, a spike +that does nothing for 47,999 other samples. Reading from the ring costs +nothing extra. + +The price is a real failure mode, so the header states it: if a repeat train +outlives the buffered history — `repeats · length + jump` beyond +`max_history_ms` — its tail reads fresher material as the write head laps +the origin. The kernel clamps the slice length against the bought capacity +so it can never read *outside* the buffer, but it does not and cannot +prevent a long train from being overtaken. Sizing the history is the +caller's job, and the object argument exists for exactly that. + +## The envelope, and why the dip stays + +Flanks are raised sine, computed to be exactly 0 at both edges and exactly 1 +across the plateau, clamped per slice to half the slice so the two flanks +never overlap. Repeats are sequential, not overlapped, so each junction dips +to zero rather than crossfading. + +Leaving it that way was a decision. An equal-power crossfade between +consecutive passes is easy from here — the pieces are already in the family — +and it would smooth exactly the articulation that makes a stutter read as +rhythm. The dip is the transient the ear locks onto. So the file documents +it as intentional, and the test asserts the exact edges, so nobody later +"fixes" the dip and quietly turns the object into a tremolo. + +## Reuse, and the component that is not a component + +The capture is a `tape::reel` in delay-line topology — the same class the +tape echo uses, the same class `airport.h` runs as a true loop. Reads here +are always at integer positions, so the family's Hermite read reduces to an +exact sample fetch; that is slightly more arithmetic than an integer index +would need, and it is kept anyway because it is one code path and because a +rate-varying sibling (`tap.scrub~`, planned) needs precisely this. + +The randomness is `tr808::white_noise`, the family's seeded xorshift64*, +reached through `swing_vca.h`. Nothing new was written for it. + +Which leaves the split: `capture` and `slicer` are separate classes under a +thin `machine`, per the family's components-first habit. But a `slicer` +needs a `capture` to mean anything, so — like `tapecho.h`'s `head`, and +unlike `airport.h`'s `loop` — it is documented as a component for +composition and testing rather than a candidate for its own external. The +components chapter's lesson is that seams often already exist and only the +monolith can reach them. The corollary, which is easier to forget, is that +not every class boundary is a seam. + +## Checkpoint + +Three clocks, pinned by one identity: force every die and the machine must +be exactly a one-step delay, bitwise. A fixed draw order, because that is +what makes a seed a contract, and an early return at density 0 so a disabled +generator provably cannot consume its stream. Ring reads instead of a burst +copy, with the failure mode written down rather than papered over. And an +envelope dip that is deliberate, tested, and therefore safe from being +helpfully removed. diff --git a/book/src/machine/tapecho.md b/book/src/machine/tapecho.md new file mode 100644 index 0000000..e4b6ce5 --- /dev/null +++ b/book/src/machine/tapecho.md @@ -0,0 +1,114 @@ +# Composition, not construction: `tapecho.h` + +This is the shortest appendix in the book, and that is the point of it. + +`tape_loop.h` was written for the Eno family — one shared header holding a +reel, a transport, and a wear stage, factored out because `discreet.h` and +`airport.h` needed the same four pieces twice. The claim implicit in +factoring it that way was that it is a *library*: machinery that a machine +nobody had written yet could be built out of. `tapecho.h` is the test of +that claim, and the result is worth recording precisely, because "we +extracted a shared header" is easy to say and rarely checked. + +The result: **`tape_loop.h` needed no changes at all.** Not a new method, +not a widened clamp, not a friend declaration. A tape echo — a different +topology, a different number of read points, a different stability regime — +composed out of it exactly as shipped. + +## What the file actually contains + +Two classes and no DSP that was not already in the library. + +`head` is a read position with three ramps: a `ratio` along the tape path, a +`level`, and a `pan`. Its `read()` takes a reel it does not own, the motor +span, and the shared transport offset, and accumulates a panned contribution +onto the stereo busses. It is a component in the airport.h sense — a piece +the monolith is made of, reachable for testing — but honestly labeled as +*not* standalone-external material: a head without a reel is not a machine, +it is an index. That distinction is worth keeping straight, because the +components chapter's lesson ("the monoliths were monoliths by accident") can +be over-applied. Some seams are real and some are arithmetic. + +`machine` owns one reel in delay-line topology, one `tape::wow_flutter`, one +`tape::wear`, and four heads. Its `process()` reads the heads, applies the +regeneration cap, writes the record head, and mixes. There is nothing else +in it. + +## The geometry: one motor + +Each head's delay is `span_samples * ratio - offset`, where `offset` is the +transport error. Two decisions hide in that one line. + +The first is that `span` is defined as the delay of a *ratio-1.0* head +rather than as "the delay time", which is what makes the motor a motor: one +multiply per head and the whole layout scales together, as a tape speed +does. The alternative — per-head absolute times — would have made a speed +change into four coordinated parameter moves and lost the doppler for free. + +The second is that `offset` is subtracted once, shared by every head. That +is physically right for a single transport (one capstan error displaces the +whole tape path) and it is also the cheap answer, so it is worth saying +plainly that the per-head phase differences of a real multi-head transport +are *not* modeled. It is a documented limit, not an accident. + +## The stability inversion, one step further + +`machine/tape.md` derived why `discreet.h` may run regeneration at exactly +1.0: `wear`'s saturator is bounded by 1/drive, so the loop is bounded no +matter the gain. That derivation does not stop at 1.0 — nothing in it does. +So this kernel lets regeneration reach `k_regen_max_driven` (1.5), and the +tape is bounded by `|in|max + regen/drive` at any setting. + +The subtlety is the boundary. That guarantee exists *only while the +saturator is engaged*, and `drive` is a ramped parameter a performer can +take to zero mid-howl. At drive 0 the wear path is exactly linear with +|H| ≤ 1, so regeneration above 1.0 would grow without bound. The kernel +therefore computes the cap **per sample** from the current drive: + +```cpp +const double regen_eff = std::min(regen, (drive > 0.0) ? k_regen_max_driven + : k_regen_max_linear); +``` + +Not in the setter — in the audio path, because `drive` moves during +performance and a setter-time decision would be stale the moment it +mattered. The stored target keeps its high value, so pulling drive to zero +lands the loop at 1.0 and restoring drive brings the howl back. That +asymmetry between *target* and *effective* is the one piece of state in this +kernel that is not obvious from the header's public surface, which is why it +is written down twice: here, and in the file's own banner. + +## Why the null test is the important one + +The suite's load-bearing scenario neutralizes the tape — no transport error, +no regeneration — and asserts that a one-head echo is **bitwise** +`delay.h`'s Hermite multitap. + +It is bitwise rather than approximate because nothing was reimplemented: +both paths compute `time_ms * 0.001 * sr` the same way, both clamp at the +same 2.5-sample Hermite floor, both evaluate the same polynomial at the same +fractional position, and both apply `(pan + 1) * 0.25 * π` to the same +`k_pi`. The multiply by a ratio of exactly 1.0 and the subtraction of an +offset of exactly 0.0 are both exact in IEEE-754, so the arithmetic does not +merely agree — it is the same arithmetic. + +That is what makes the test meaningful. An approximate null test would pass +just as happily over a second implementation that happened to be close. A +bitwise one only passes if the shared code is genuinely shared, which is the +proposition on trial. The notebook runs the same comparison across the C ABI +so the claim also holds at the boundary the externals cross. + +One consequence worth knowing when reading the test: at pan 0 the two busses +are *not* bit-identical to each other, because `cos(π/4)` and `sin(π/4)` +differ by one ulp in IEEE-754 doubles. That is inherited from `delay.h`'s +pan law, it is the same in both objects, and it is exactly why the null test +compares each bus against its counterpart rather than comparing left to +right. + +## Checkpoint + +Two classes, no new DSP, and a shared header that did not move. The motor +geometry buys varispeed with one multiply per head; the regeneration cap +lives in the audio path because the thing it depends on is performed; and +the null test is bitwise because being bitwise is the only version of that +test that proves anything. diff --git a/book/src/stammer.md b/book/src/stammer.md new file mode 100644 index 0000000..518b0fd --- /dev/null +++ b/book/src/stammer.md @@ -0,0 +1,140 @@ +# The part that comes apart + +There is a moment at the end of "Go To Sleep" where the guitar stops being a +guitar. It does not fade, it does not filter — it starts eating itself, +firing fragments of the bar you just heard in an order nobody played. That +sound came out of a Max patch Jonny Greenwood built and performs live. So +`tap.stammer~` has an odd position in this package: it is a Max stutter +object, in a Max package, for a technique that was invented in Max. + +None of which means anything was copied. This is an **original design** in +the brassage tradition (Roads, *Microsound*) — a continuously recorded +buffer, a rhythmic grid, and dice. What the band's rig contributes is the +knowledge of what the object is *for*, which turns out to be the hard part +of designing one. + +Companion material: the executed notebook `stammer.ipynb`, and the +`radiohead_render` scenarios `stammer_grid` (the dials held still so the +mechanism is audible), `stammer_disintegrate` (forty seconds of the +performance the object exists for), and `stammer_two_seeds`. + +## How it works, in one paragraph + +The input is captured continuously into the last few seconds of history. On +a `step` grid, if the machine is idle, it rolls: with probability `density` +it grabs the material that just went past, chops it to `step` divided by +something between 1 and `divisions`, and plays it back between 1 and +`repeats` times, each pass with a `reverse` chance of running backwards. If +`jump` is open it may reach further back than the bar just played. While a +slice fires you hear the slice; when nothing is firing you hear the input, +untouched. + +## `density` and `repeats` — they are not the same dial + +This is the one thing worth internalizing before you patch it. `density` is +how often the machine *grabs*; `repeats` is how long it *holds on* once it +has. A slice in flight is never interrupted, so `repeats` is what actually +decides how busy the machine is — and once trains start overlapping, raising +density stops doing anything at all. + +![Four runs showing when a slice is in flight: raising repeats from 1 to 6 fills the timeline far more than raising density from 0.3 to 0.9](images/stammer/occupancy.svg) + +*Measured off the object's own playing flag, 100 grid points per run. Repeats is the hold.* + +At density 0.3, going from 1 repeat to 6 takes the machine from 41% busy to +76%. At density 0.9 it is already 90% busy with a single repeat, and 96% +with six — the ceiling, where the dial has run out of room. + +## `divisions`, `reverse`, `jump` — the character + +`divisions` is how finely the grid may be chopped: at 1 you get whole-step +slices, at 8 the machine may cut down to eighths of a step. Because the +divisor is drawn per slice, a high setting gives you a *mixture* of lengths, +not uniformly short ones — which is what keeps it sounding played rather +than gated. + +`reverse` is drawn per repeat rather than per slice, so a single train can +stagger forwards and back. `jump` is the reach: at 0 the machine only ever +replays the material immediately past (the classic stutter), and opening it +lets slices come from seconds ago, so the part starts quoting itself out of +order. That is the setting that turns "stuttering" into "disintegrating". + +`fade` is the anti-click — a raised-sine flank on each repeat, exactly zero +at the edges and exactly unity across the plateau. Repeats are sequential +rather than overlapped, so every junction dips to zero. That is deliberate: +the dip *is* the articulation of a stutter, and a crossfade there would +smear the thing you want to hear. + +## `seed` — the dial that is a contract + +Every draw — fire, division, repeat count, reach-back, and the per-repeat +coin for reverse — comes from a seeded generator in a fixed order. So the +same seed and the same moves give the same render, bit for bit. That is not +a nicety; it means a take you liked is recoverable, two instances on +different seeds decorrelate instead of moving in lockstep, and the tests can +assert bitwise equality. A different seed is a genuinely different +performance: 89% of samples change. + +And at `density` 0 the dice are never rolled *at all* — so the seed provably +cannot matter, and the object is a bitwise bypass at any mix. Switched off, +this is not "nearly transparent", it is your input. `clear` erases the +capture, drops the slice in flight, and rewinds the seeded stream, so the +same seed replays from there. + +## The material contract + +The header says this object wants transient material, and that on a +sustained pad a stutter is barely a tremolo. That reads like taste. It is +not — it is a property of the material, and it is measurable. + +![Slices of a sustained sine measure 1.000 alike; slices of a plucked phrase measure 0.286](images/stammer/material.svg) + +*How alike two arbitrary slices of the material are. Re-ordering interchangeable things does nothing.* + +Every slice of a steady sine looks like every other slice, so shuffling them +changes almost nothing you can hear. Slices of a played phrase are all +different, so shuffling them is the entire effect. Feed this object drums, +plucked or struck strings, consonants — anything whose interest is in *when* +things happen. It re-articulates rhythm that is already in the sound; it +cannot invent rhythm that is not. + +## Recipes + +- **A grid you can hear:** `@step 250 @density 0.55 @divisions 4 @repeats 4 + @reverse 0.2`. The mechanism, plainly, over a played part. +- **The disintegration:** start at `@density 0.2 @divisions 1 @repeats 1` + and walk over thirty seconds to `@density 0.9 @divisions 8 @repeats 10 + @reverse 0.6`, tightening `@step` from 250 to 120 as you go. Then open + `@jump 1500` and the machine starts quoting the wrong bar. +- **Vocal chop:** `@step 125 @density 0.4 @divisions 2 @repeats 3 @fade 6`. + Consonants are transients; the longer flank keeps it from sounding + digital. +- **Two of them:** the same settings on two instances with different seeds, + panned apart. They decorrelate by construction — that is what the seed + contract buys you. + +## When it is not the right tool + +- **Sustained material.** See above; it is measured. A tremolo or a gate + will do more for a pad. +- **Pitched mangling.** Slices play at ±1 rate only — there is no pitch + shift and no varispeed here. `tap.shift~` transposes; `tap.pitchaccum~` + spirals. +- **Exact, notated rhythms.** The grid is regular but the dice are dice. + `tap.808.seq~` sequences; this improvises. +- **Very long repeat trains.** A slice reads from the ring, not a private + copy, so a train longer than the captured history will start reading + fresher material as the write head laps it. Size the object argument to + the longest train you intend to fire. + +## Checkpoint + +Capture everything, then on a grid roll dice and re-fire what just went +past. `density` grabs, `repeats` holds — and holding is what fills the +timeline. `divisions`, `reverse` and `jump` are the character, and `jump` is +the one that turns a stutter into a disintegration. The seed is a real +contract: same seed, same performance, bit for bit; at density 0, a bitwise +bypass. And the material contract is measured rather than asserted, which is +the honest way to tell you what to feed it. Every number above lives twice: +as an executed cell in `stammer.ipynb` and as a pinned scenario in +`tests/stammer_test.cpp`. diff --git a/book/src/tapecho.md b/book/src/tapecho.md new file mode 100644 index 0000000..1ce4046 --- /dev/null +++ b/book/src/tapecho.md @@ -0,0 +1,151 @@ +# Four heads and a motor + +The last chapter's `tap.discreet~` is a machine you set up and walk away +from. `tap.tapecho~` is one you keep your hands on. Same spool of tape, same +worn return path, same family — but where the Eno objects are systems that +run without you, this one is an instrument, and every parameter on it is a +hand on the machine. That is the thread through this part of the book: these +are the objects you *ride*. + +What it recreates is the tape echo of the Copicat / Space Echo school: one +record head, a span of moving tape, several playback heads at fixed +positions along it, and a path from the heads back to the record head. Ed +O'Brien's Copicat is the reason it is here. It is a recreation of the +*topology*, not a circuit model of any one unit — the tape path itself is +the same published tape-echo modeling literature `tap.discreet~` already +stands on (Arnardóttir, Abel, and Smith's AES model of the Echoplex, and +Välimäki et al.'s tape-echo work), and no head spacing, filter curve, or +trim value in this object is claimed as measured from a real machine. + +Companion material: the executed notebook `tapecho.ipynb`, which measured +every number below, and the `radiohead_render` tool, whose `tapecho_heads`, +`tapecho_three_head`, `tapecho_selfosc`, and `tapecho_varispeed` scenarios +are the listening copies — all four *performed*, with the controls moving +while they render, because static settings tell you almost nothing about +this object. + +## `span` — the motor + +`span` is the delay of a head sitting at the far end of the tape path, and +every other head sits at `span` times its own ratio. So `span` is not "the +delay time" of one echo; it is the motor speed, and moving it moves the +whole layout together. + +![An impulse into a 400 ms span with four heads, returning once at each of 100, 200, 300 and 400 ms on the dotted head positions](images/tapecho/head-layout.svg) + +*One impulse, four heads. The returns land exactly on `span × ratio`.* + +Moving the motor while audio runs is a tape-speed change, which means it +bends pitch on the way — the same doppler contract as `tap.discreet~`, for +the same reason: the heads are physically moving relative to the tape. +`smooth` sets how long the motor takes to change speed, and therefore how +deep the bend is. There is no crossfading "digital" mode. If a pitch bend on +a delay-time change would ruin the patch, reach for `tap.delay~`. + +## `heads`, `ratios`, `levels`, `pans` — the layout + +Four heads by default, evenly spaced at 0.25, 0.5, 0.75 and 1.0 of the span. +That spacing is *nominal* — chosen because it is neutral and audibly a tape +echo — and every ratio is freely settable underneath, which is how you build +a three-head Copicat-style layout: + +``` +heads 3, ratios 0.333 0.667 1. +``` + +`levels` is per-head gain and `pans` places each head in the stereo field +(equal-power, with exact endpoints: a hard-panned head is bitwise absent +from the far bus). One thing to know: **a head's level is also its send into +the regeneration path**, as the head selector on the real machines is. Turn +a head down and you are turning down both what you hear from it and what it +feeds back. + +## `regen`, `drive`, `darken` — past unity, on purpose + +Here is where this object parts company with everything else in the house. +`tap.delay~` caps feedback at 0.99 so the loop is always contractive. +`tap.discreet~` reaches exactly 1.0 because the wear path is the stabilizer. +`tap.tapecho~` goes **past** 1.0 — up to 1.5 — into deliberate +sound-on-sound self-oscillation, the howl you reach for this machine to get. + +It stays bounded because the saturator does. `drive` is record-head +saturation, and its output can never exceed 1/drive no matter what the loop +accumulates, so the tape is bounded by the input plus regen/drive whatever +the loop gain. The measurement is the point: + +![Measured peak output against drive at regeneration 1.4, sitting below the analytic ceiling at every drive](images/tapecho/self-oscillation.svg) + +*Regeneration at 1.4 — well past unity — plateaus under the saturator's ceiling at every drive.* + +Because that bound *only* exists while the saturator is engaged, the +effective regeneration is capped back to 1.0 whenever `drive` is 0 — and the +cap is applied per sample, so dropping drive mid-howl lands the loop rather +than letting it run away. The attribute keeps its value and takes effect +again when drive returns. Twelve seconds of ring at regen 1.4 measures a +growth ratio of 1.007 between the two late windows: it plateaus, it does not +climb. + +`darken` is the per-pass corner. Every trip through the regeneration path +runs through a one-pole lowpass, so the repeats lose treble generation by +generation — measured at 0.2915 of a 6 kHz tone per pass against 0.2920 +predicted, and 0.8895 of a 300 Hz tone against 0.8898. Riding `darken` +*while the loop howls* is a performance control, not a set-up step; it is +what turns a howl into a swell and back. + +## `wow` and `flutter` — one motor, one path + +The transport is the family's deterministic pair of sines, and one motor +moves the whole tape path, so a speed error displaces every head together. +The pitch math is checkable in closed form: depth times 2π times rate is the +peak deviation, so 2 ms at 0.5 Hz predicts ±10.88 cents and the notebook's +pitch track measures 10.91. Two renders of the same settings are +bit-identical — periodic and deterministic by design, with stochastic +capstan drift a documented non-goal, because bit-exact renders are what let +the oracle test exist at all. Set both depths to 0 for a still machine. + +## The one that is not a knob + +With the tape path neutralized — no transport error, no regeneration — a +one-head echo is **bitwise** `tap.multitap~` with one tap. Same Hermite +read, same fractional position, same equal-power pan law. That is not a +curiosity; it is the whole design claim, measured: this object is +composition over the shared tape machinery rather than a second +implementation of it, and `tape_loop.h` needed no changes at all to serve a +topology it was not written for. The appendix has the derivation. + +## Recipes + +- **The Copicat:** `heads 3, ratios 0.333 0.667 1.` with `@span 390 @regen + 0.6 @drive 0.9 @darken 2600 @wow 0.9 0.9 @mix 50`. Heads down the middle, + a tired transport, repeats that thicken as they recirculate. +- **A wide slap:** four heads, `pans -0.7 0.5 -0.35 0.8`, `@span 480 @regen + 0.45 @drive 0.4 @mix 45`. The layout does the widening; no chorus needed. +- **Sound-on-sound:** `@drive 0.7 @regen 1.35`, then bring `@input` to 0 and + take your hands off. Ride `@darken` down to 1400 while it howls, then + `@regen 0.55` to bring it home. `clear` is the emergency stop. +- **The dive:** `@smooth 3000`, then `@span 200` → `@span 900`. Three + seconds of tape slowing down, with everything already on the tape bending + with it. + +## When it is not the right tool + +- **Tempo-locked delays.** Span changes bend pitch by design and there is no + sync. `tap.delay~` is the clean line. +- **A wash you set and leave.** That is `tap.discreet~`, one chapter back — + same machinery, opposite posture. +- **Independent free-running loops.** One motor moves every head here. For + loops that drift against each other, `tap.airport~`. +- **Clean repeats.** Wear is always in the regeneration path; `drive 0` + removes the saturation, not the darkening. + +## Checkpoint + +A motor and up to four heads along one tape path; the motor moves them +together and bends pitch doing it. Regeneration goes past unity into +self-oscillation, bounded by the saturator rather than a gain cap, and +capped back to 1.0 the moment drive leaves. The transport is two +deterministic sines measured in cents. And with the tape path neutral the +whole object collapses, bitwise, into a delay this library already had — +which is how you know it is composition and not a rewrite. Every number +above lives twice: as an executed cell in `tapecho.ipynb` and as a pinned +scenario in `tests/tapecho_test.cpp`, which CI runs on every push. From 4358a54e33cbce37a2a9e88e10baedd6a2b5ecfa Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 02:55:05 +0000 Subject: [PATCH 07/22] Record the Ondes Martenot source hunt The sources exist and are identified, with an honest column for how far each was actually read: the Acta Acustica intensity-key study, the Forum Acusticum diffuseur-loudspeaker paper (read in full), the IEEE circuit simulation and its ribbon-oscillator companion, plus the Leipp and Laurendeau primary references they cite. Two design assumptions were corrected by reading rather than by assuming. The touche d'intensite maps displacement, not force, across a 50 dB range per note -- so the control input is a position and only the taper is still open. And the diffuseurs are driven, not struck: the metallique is a motor-excited gong and the palme an electromagnet driving twelve strings, so the garden's strike-excited modal idiom applies for the resonator maths but not for the excitation. The early transducer is also inherently nonlinear, which a resonator-only model would miss entirely. Also records that hobbyist build pages give the palme 24 strings where the peer-reviewed source says 12, and that those pages are unciteable here. The gate is clearer but not open: three full texts are still needed and automated retrieval is blocked, which is a manual step rather than something to guess around. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 59 ++++++++++++++++++++++++++++++----- 1 file changed, 52 insertions(+), 7 deletions(-) diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index c0474fb..f5be690 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -32,7 +32,7 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. |--------|--------|-----------|-------------|--------| | `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | -| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom, `vco.h`/`vca.h` | planned — gated on source collection | +| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom (maths only — see the source hunt), `vco.h`/`vca.h` | planned — sources identified, full texts still needed | | `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | planned | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | @@ -170,12 +170,57 @@ instrument decomposes on exactly the family's seams, and the decomposition is th (comb/waveguide school, `grm_comb.h` experience). Principal is the dry path. **Gate: source collection before implementation.** The provenance rule is the whole -ballgame here. Candidate sources to verify and pin: the published organological studies of -the instrument (there is published work specifically measuring the touche d'intensité's -response — locate and verify it), Fletcher & Rossing for both diffuseurs, and period -technical descriptions of the waveform registers. If a needed number has no published -source, the honest fallback is a *recreation* voiced by ear against published recordings -and documented as such — decided per-number, in the header, when we get there. +ballgame here. If a needed number has no published source, the honest fallback is a +*recreation* voiced by ear against published recordings and documented as such — decided +per-number, in the header, when we get there. + +#### Source hunt, 2026-08-15 — findings + +The sources exist and are identified. Status per source, with an honest note on how far +each was actually read: + +| Source | For | Read to | +|--------|-----|---------| +| Quartier, Meurisse, Colmars, Frelat, Vaiedelich, "Intensity Key of the Ondes Martenot: An Early Mechanical Haptic Device", *Acta Acustica united with Acustica* **101**(2), 421–428, 2015 | the touche d'intensité | abstract / indexed summary only | +| Wijnand, Boutin, Jossic, Maniguet, "A physical model for the electromagnetic loudspeaker used in early Ondes Martenot diffuseurs", Forum Acusticum 2023 (EAA), CC-BY | the diffuseur transducer | **full text** | +| Najnudel, Hélie, Roze, Boutin, "Simulation of an Ondes Martenot Circuit", *IEEE/ACM TASLP* **28**, 2651–2660, 2020 | the oscillator/circuit | abstract only | +| Najnudel et al., "Simulation of the Ondes Martenot Ribbon-Controlled Oscillator…" (HAL hal-02425249) | the ribbon oscillator | abstract only | +| Leipp, "Les Ondes Martenot, un archétype", *Bulletin du GAM* n°60, 1972 | the palme (cited as the palme source by Wijnand et al.) | not obtained | +| Laurendeau, *Maurice Martenot, luthier de l'électronique* (1990; Beauchesne 2017) | the standard monograph | not obtained | + +**Three findings that change the design, not just the citation list.** + +1. **The touche maps *displacement*, not force.** The Acta Acustica work measured force on + the key, key depression, and the resulting sound, and reports that the change in sound + intensity depends on the key's displacement (the force applied follows from it), across a + **50 dB** dynamic range per note over the instrument's range. So the kernel's control + input is a position, the range is pinned at 50 dB, and what remains unknown is the + *taper* between them — which is exactly what the full text should settle. +2. **The diffuseurs are driven, not struck.** Wijnand et al. describe the *métallique* + (1944–45, patented 1947) as a gong excited by a **motor**, and the *palme* (1949–50) as an + **electromagnet driving 12 metal strings** attached to a soundboard; *résonance* (1970s) + is motor-excited metal springs. This invalidates amendment 2's assumption that the + diffuseurs inherit `garden.h`'s *strike-excited* modal idiom wholesale. The mode banks + still apply, but the excitation is continuous, so the right model is a driven resonator + bank — closer to `grm_comb.h`'s sustained ringing than to the chime's decay envelopes. + Amendment 2 stands for the resonator maths and falls for the excitation. +3. **The transducer itself is part of the sound.** The early diffuseurs used a moving-iron + loudspeaker whose operating principle is *inherently nonlinear* — the paper's point is + precisely that the linear Thiele–Small model does not apply, and it quantifies the + nonlinearity on a heritage instrument. A diffuseur model that is only a resonator is + missing a documented stage. + +**A discrepancy worth recording:** widely circulated DIY build pages describe the palme as +24 strings (two sets of 12); the peer-reviewed source says 12. Prefer the peer-reviewed +number, and treat hobbyist build documentation as unciteable for this family. + +**Where the gate stands.** Substantially clearer than when this plan was written: every +subsystem now has at least one peer-reviewed source, and two design assumptions have already +been corrected by reading them. It is **not yet clear** — full texts of the intensity-key +and circuit-simulation papers are still needed for the numbers that would go in the header, +and automated retrieval is blocked (HAL sits behind an anti-bot wall; the IEEE paper is +paywalled). The remaining step is manual access to those three PDFs, which is a +five-minute job for someone with institutional access and not something to fake around. ### 4. `tap.fuzz~` — the ShredMaster school *(small, parallel-friendly)* From c146589622fbed5f767c5efb069c8e7175b8d538 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 03:04:43 +0000 Subject: [PATCH 08/22] Add the two-stage fuzz: tap.fuzz~ The OK Computer-era dirt, and a sibling of overdrive.h rather than a replacement: that object is a feedback soft-clipper chasing the TS lineage, this is the harder, more scooped school -- two cascaded clipping stages and a bass/contrast/treble voicing section. The method is Yeh, Abel & Smith's DAFx-07 simplified cascade (conditioning filter -> memoryless nonlinearity -> equalization filter, twice), which supplies the architecture, the justification for approximating the diode limiter's moving-pole ODE with a static curve between fixed filters, the curve family, and the reason asymmetry exists. It is a recreation of a circuit class: no component value or corner is claimed as measured from any unit, and the voicing constants are the sound of the object. Two defects the measurements caught. The first cut had the second stage fully clipped at gain 0 -- the knob did nothing over most of its travel -- because the tanh family's small-signal slope compounds across a cascade; retuned, the harmonic ratio now sweeps 0.010 to 0.358. And the house 4th-order oversampling filter made aliasing *worse* at 4x and 8x than at 2x, so this kernel uses 8th order, which restores the monotone improvement the setting promises. Two test-design errors are recorded in the suite because both are easy to repeat: an alias test whose tone divided the sample rate, so every fold landed on a harmonic and was invisible; and probe frequencies near enough the fundamental to measure window leakage instead. The test now asserts only what is true -- two orders of magnitude against no oversampling, and deliberately no ordering among 2x/4x/8x, where the residual is -60 dB and noise dominates. Nine Catch2 scenarios plus the C ABI and ctypes surface. The notebook, a render scenario, the Max slice and the chapter are still to come. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 33 ++- include/taptools/fuzz.h | 506 ++++++++++++++++++++++++++++++++++ include/taptools/taptools.h | 1 + notebooks/taptools_py.py | 63 ++++- tests/CMakeLists.txt | 1 + tests/fuzz_test.cpp | 310 +++++++++++++++++++++ tools/capi/taptools_capi.cpp | 64 +++++ tools/capi/taptools_capi.h | 19 ++ 8 files changed, 994 insertions(+), 3 deletions(-) create mode 100644 include/taptools/fuzz.h create mode 100644 tests/fuzz_test.cpp diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index f5be690..9a13df0 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -33,7 +33,7 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. | `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom (maths only — see the source hunt), `vco.h`/`vca.h` | planned — sources identified, full texts still needed | -| `tap.fuzz~` (name open) | `fuzz.h` | ShredMaster-school two-stage fuzz | `overdrive.h` sibling, published schematic | planned | +| `tap.fuzz~` | `fuzz.h` | Two-stage tone-stacked fuzz (the OK Computer-era dirt) | `overdrive.h` sibling; the DAFx-07 cascade | ✅ kernel shipped 2026-08-15; Max slice, notebook, chapter pending | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | Parked (surveyed, deliberately not planned): a spectral freeze on the `stft.h` scaffold @@ -222,7 +222,36 @@ and automated retrieval is blocked (HAL sits behind an anti-bot wall; the IEEE p paywalled). The remaining step is manual access to those three PDFs, which is a five-minute job for someone with institutional access and not something to fake around. -### 4. `tap.fuzz~` — the ShredMaster school *(small, parallel-friendly)* +### 4. `tap.fuzz~` — the two-stage fuzz *(small, parallel-friendly)* — ✅ kernel shipped + +> **Shipped 2026-08-15**: `include/taptools/fuzz.h` (`stage` + `tone` under a thin `pedal`), +> `tests/fuzz_test.cpp` (9 scenarios), and the C ABI + ctypes surface (`Fuzz`). The name +> question closed: **`tap.fuzz~`**, generic, per the trademark posture below. +> +> The method is Yeh, Abel & Smith's DAFx-07 *simplified cascade* — conditioning filter → +> memoryless nonlinearity → equalization filter, twice — which is a stronger footing than +> the plan assumed: it supplies the architecture, the justification for a static curve +> (the diode limiter's exact ODE is a lowpass whose pole moves with voltage), the curve +> family (tanh), and the reason `asymmetry` exists (a real op-amp stage clips +> asymmetrically, producing the even harmonics an odd-only model cannot). +> +> **Two defects found by measurement, both worth carrying:** +> 1. *Gain staging.* The first cut had the second stage fully clipped at `gain` 0 — the +> knob did nothing above about 0.2 — because the tanh family's small-signal slope is +> `knee/tanh(knee)` (~3 at the original knee) and that multiplied into a fixed ×2.2. +> Retuned; the harmonic ratio now sweeps 0.010 → 0.358 across the knob. +> 2. *The house oversampler is not steep enough here.* With the 4th-order Butterworth that +> `tap.ladder~` / `overdrive.h` use, alias energy fell from 1× to 2× and then **rose** +> at 4× and 8×. Replaced with 8th order, which restores the monotone improvement. +> Whether `overdrive.h` is owed the same change is a live question — different +> nonlinearity, different gain structure, so it needs its own measurement rather than +> this one's conclusion. +> +> Two test-design errors were also caught and are recorded in the suite itself, since both +> are easy to repeat: an alias test whose tone divided the sample rate (every fold lands on +> a harmonic and is invisible), and probe frequencies close enough to the fundamental to +> measure window leakage rather than aliasing. Still to come: the notebook, a render +> scenario, the Max vertical slice, and the chapter. The OK Computer-era dirt (*Paranoid Android*, *My Iron Lung*). A circuit-informed recreation from the widely published schematic — cascaded clipping stages plus its diff --git a/include/taptools/fuzz.h b/include/taptools/fuzz.h new file mode 100644 index 0000000..7a145a3 --- /dev/null +++ b/include/taptools/fuzz.h @@ -0,0 +1,506 @@ +/// @file +/// @brief Portable two-stage fuzz/distortion kernel for tap.fuzz~ — no Max/Min dependency. +/// @details The third Radiohead-family kernel (book/PLAN-radiohead-family.md): the +/// two-stage, tone-stacked distortion of the early-90s British "shred" pedal class — +/// the OK Computer-era dirt behind *Paranoid Android* and *My Iron Lung*. A cascaded +/// clipper pair with a bass / contrast / treble voicing section, and a sibling of +/// overdrive.h rather than a replacement: that object is a *feedback* soft-clipper +/// chasing the TS lineage, this one is the harder, more scooped school. +/// +/// Method, and where it comes from: the architecture is the simplified cascade of +/// Yeh, Abel & Smith, "Simplified, Physically-Informed Models of Distortion and +/// Overdrive Guitar Effects Pedals" (Proc. DAFx-07, Bordeaux) — **conditioning +/// filter -> memoryless nonlinearity -> equalization filter**, twice. That paper's +/// own justification is the one this kernel relies on: the diode limiter is really a +/// lowpass whose pole moves with voltage (dVo/dt = (Vi - Vo)/RC - (2 Is/C) +/// sinh(Vo/Vt), from the Shockley model Id = Is(exp(V/Vt) - 1)), its exact ODE is +/// expensive, and approximating it as a static curve between fixed filters is +/// justified perceptually and measured there against real pedals. The paper compares +/// tanh, arctan and a tanh approximation against the tabulated DC curve; this kernel +/// uses the tanh family, with a sharpness parameter so one curve spans soft knee to +/// near-hard clip. The paper's note that a real op-amp stage clips *asymmetrically*, +/// producing even harmonics where an odd-only model predicts none, is why +/// `asymmetry` exists. +/// +/// **What is and is not claimed.** This is a recreation of a *class* of circuit — +/// two cascaded clipping stages and a three-control tone section — not a component +/// model of any one pedal. No resistor, capacitor, diode, or corner frequency here +/// is claimed as measured from a unit, and the control names follow the layout that +/// class of pedal conventionally carries rather than asserting what any particular +/// one does. The voicing constants (k_voice_*) are the "sound" of the object, chosen +/// by design and expected to be retouched in an in-Max voicing pass — the same +/// posture overdrive.h takes about its own, and the same posture tapecho.h takes +/// about head spacings. +/// +/// Two components and a thin composition, the family's habit: +/// - `stage` — one conditioning highpass, one gain, one memoryless curve (knee +/// sharpness + asymmetry), one equalization lowpass. The DAFx-07 triple, and the +/// only nonlinear thing in the file. Two of them cascade: the first is the +/// op-amp-ish gain stage (softer knee, most of the gain, the asymmetry), the +/// second the shunt-diode limiter (harder knee, unity gain). +/// - `tone` — the voicing: a low shelf, a high shelf, and a mid scoop whose depth is +/// `contrast`. Linear, entirely outside the nonlinearity, RBJ biquads. +/// - `pedal` — input gain, the two stages inside the oversampled region, the DC +/// blocker, the tone stack, output level. +/// +/// Aliasing: the clipper pair runs oversampled (1/2/4/8x, default 4x) — zero-stuff +/// plus an 8th-order Butterworth anti-image on the way up, a matching anti-alias +/// before decimation. The house pattern (tap.ladder~ / overdrive.h) uses 4th order +/// there; it was measured here and found to make oversampling *non-monotone* for +/// this kernel, so this file uses 8th (see butterworth8's comment for the numbers). DAFx-07 notes that +/// typical implementations use 8-10x and that residual aliases at 8x and above tend +/// to be masked by the dense spectrum of guitar distortion; 4x is the default here +/// because this kernel's curve is C-infinity rather than a hard corner, and 8 is one +/// setter away when it is not enough. +/// +/// Honest limits: +/// - The nonlinearity is static. The pole-moves-with-voltage behaviour of the real +/// limiter is approximated by fixed filters around a fixed curve — that is the +/// DAFx-07 simplification, adopted deliberately, and it is why this is a +/// *simplified physically-informed* model and not a circuit solver. +/// - No component values, no schematic netlist, no claim of matching a unit. If you +/// need a specific pedal, this is not it; it is that pedal's *class*. +/// - Hard settings alias. `edge` near 1 sharpens the knee toward a corner, which is +/// exactly where a static curve is worst; raise `oversample` before blaming the +/// tone controls. +/// - `contrast` is a mid scoop of this kernel's own design. The name is the class's; +/// the curve is not claimed to be anyone's. +/// - Mono, and gain staging is the caller's job past `level`. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include + +namespace tap::tools { + namespace fuzz { + + constexpr double k_pi = 3.14159265358979323846; + constexpr double k_default_smooth_ms = 20.0; + constexpr double k_dc_r = 0.9997; // the Jamoma TTDCBlock constant, via tap.dcblock~ + + // Gain mapping: `gain` 0..1 sweeps the first stage's drive linearly in dB. The floor is + // below unity on purpose: the second stage carries its own small-signal gain (the tanh + // family's slope is knee/tanh(knee), ~2 at the stock knee), so a floor at unity would + // arrive at the limiter already saturated and the knob would do nothing over most of its + // travel. Gain staging across a cascade is the whole game; these two numbers are it. + constexpr double k_gain_min_db = -12.0; + constexpr double k_gain_max_db = 36.0; + constexpr double k_level_range_db = 24.0; + + // Voicing: the sound of the object, chosen by design rather than measured (see the + // banner). Retouch these in the in-Max voicing pass, not analytically. + constexpr double k_voice_stage1_hp_hz = 90.0; // what reaches the first clipper + constexpr double k_voice_stage1_lp_hz = 7500.0; // the limiter's embedded lowpass, fixed + constexpr double k_voice_stage2_hp_hz = 150.0; // tighter into the second stage + constexpr double k_voice_stage2_lp_hz = 5200.0; + constexpr double k_voice_stage1_knee = 1.6; // softer: the op-amp-ish stage + constexpr double k_voice_stage2_knee = 2.0; // harder: the shunt limiter, at edge 0 + constexpr double k_voice_edge_knee = 12.0; // ...and at edge 1 + constexpr double k_voice_stage2_gain = 0.5; // fixed drive into the second stage + constexpr double k_voice_bass_hz = 180.0; + constexpr double k_voice_treble_hz = 2600.0; + constexpr double k_voice_mid_hz = 620.0; + constexpr double k_voice_mid_q = 0.85; + constexpr double k_voice_shelf_db = 12.0; // full-scale bass/treble travel + constexpr double k_voice_scoop_db = 14.0; // full-scale contrast scoop + + /// Per-sample linear parameter ramp — the anti-zipper unit, the delay.h shape. + class ramp { + public: + void snap(double v) { + m_current = m_target = v; + m_inc = 0.0; + m_remaining = 0; + } + void to(double tgt, long n) { + if (n < 1 || tgt == m_current) { + snap(tgt); + } + else { + m_target = tgt; + m_inc = (tgt - m_current) / static_cast(n); + m_remaining = n; + } + } + double tick() { + if (m_remaining > 0) { + m_current += m_inc; + if (--m_remaining == 0) { + m_current = m_target; + } + } + return m_current; + } + double current() const { return m_current; } + double target() const { return m_target; } + + private: + double m_current{0.0}, m_target{0.0}, m_inc{0.0}; + long m_remaining{0}; + }; + + /// RBJ biquad (transposed direct form II) — the cookbook designs, copied with citation + /// per the house reuse rule (same struct as overdrive.h; kernels stay self-contained). + struct biquad { + double b0{1.0}, b1{0.0}, b2{0.0}, a1{0.0}, a2{0.0}; + double z1{0.0}, z2{0.0}; + + void design_lowpass(double fc_norm, double q) { + const double w = 2.0 * k_pi * fc_norm; + const double alpha = std::sin(w) / (2.0 * q); + const double cw = std::cos(w); + const double a0 = 1.0 + alpha; + b0 = ((1.0 - cw) * 0.5) / a0; + b1 = (1.0 - cw) / a0; + b2 = b0; + a1 = (-2.0 * cw) / a0; + a2 = (1.0 - alpha) / a0; + } + void design_peaking(double fc_norm, double q, double gain_db) { + const double A = std::pow(10.0, gain_db / 40.0); + const double w = 2.0 * k_pi * fc_norm; + const double alpha = std::sin(w) / (2.0 * q); + const double cw = std::cos(w); + const double a0 = 1.0 + alpha / A; + b0 = (1.0 + alpha * A) / a0; + b1 = (-2.0 * cw) / a0; + b2 = (1.0 - alpha * A) / a0; + a1 = b1; + a2 = (1.0 - alpha / A) / a0; + } + void design_lowshelf(double fc_norm, double gain_db) { // shelf slope S = 1 + const double A = std::pow(10.0, gain_db / 40.0); + const double w = 2.0 * k_pi * fc_norm; + const double cw = std::cos(w); + const double sa = std::sin(w) * 0.5 * std::sqrt(2.0); + const double ap1 = A + 1.0; + const double am1 = A - 1.0; + const double sqA2 = 2.0 * std::sqrt(A) * sa; + const double a0 = ap1 + am1 * cw + sqA2; + b0 = A * (ap1 - am1 * cw + sqA2) / a0; + b1 = 2.0 * A * (am1 - ap1 * cw) / a0; + b2 = A * (ap1 - am1 * cw - sqA2) / a0; + a1 = -2.0 * (am1 + ap1 * cw) / a0; + a2 = (ap1 + am1 * cw - sqA2) / a0; + } + void design_highshelf(double fc_norm, double gain_db) { + const double A = std::pow(10.0, gain_db / 40.0); + const double w = 2.0 * k_pi * fc_norm; + const double cw = std::cos(w); + const double sa = std::sin(w) * 0.5 * std::sqrt(2.0); + const double ap1 = A + 1.0; + const double am1 = A - 1.0; + const double sqA2 = 2.0 * std::sqrt(A) * sa; + const double a0 = ap1 - am1 * cw + sqA2; + b0 = A * (ap1 + am1 * cw + sqA2) / a0; + b1 = -2.0 * A * (am1 + ap1 * cw) / a0; + b2 = A * (ap1 + am1 * cw - sqA2) / a0; + a1 = 2.0 * (am1 - ap1 * cw) / a0; + a2 = (ap1 - am1 * cw - sqA2) / a0; + } + double tick(double x) { + const double y = b0 * x + z1; + z1 = b1 * x - a1 * y + z2; + z2 = b2 * x - a2 * y; + return y; + } + void reset() { z1 = z2 = 0.0; } + }; + + /// 8th-order Butterworth lowpass as four cascaded biquads — the oversampling chain's + /// anti-image and anti-alias filter. + /// + /// The house pattern (tap.ladder~ / overdrive.h) uses a 4th-order pair here. It is not + /// steep enough for this kernel, and the difference is measurable rather than + /// theoretical: with the 4th-order filter, alias energy fell from 1x to 2x and then rose + /// again at 4x and 8x — more oversampling made it *worse*, because 24 dB/octave leaves + /// content just above the base Nyquist barely touched, and a higher factor pushes more + /// clipper-generated harmonics into that barely-touched band before decimation. Eighth + /// order restores the monotone improvement the setting promises. (Whether the same change + /// is owed to overdrive.h is a live question — it is a different nonlinearity at a + /// different gain structure, so it needs its own measurement, not this one's conclusion.) + /// + /// Pole Qs are the standard 8th-order Butterworth set, Q_k = 1/(2 cos((2k+1)pi/16)). + struct butterworth8 { + biquad s1, s2, s3, s4; + void design(double fc_norm) { + s1.design_lowpass(fc_norm, 0.50979558); + s2.design_lowpass(fc_norm, 0.60134489); + s3.design_lowpass(fc_norm, 0.89997622); + s4.design_lowpass(fc_norm, 2.56291545); + } + double tick(double x) { return s4.tick(s3.tick(s2.tick(s1.tick(x)))); } + void reset() { + s1.reset(); + s2.reset(); + s3.reset(); + s4.reset(); + } + }; + + /// The tanh family with an adjustable knee: `k` small is nearly linear, `k` large + /// approaches a hard corner. Normalized so shape(1, k) == 1 for every k, which keeps the + /// stage's gain structure independent of the knee setting. + inline double shape(double x, double k) { + if (k < 1e-6) { + return x; + } + return std::tanh(k * x) / std::tanh(k); + } + + /// One DAFx-07 stage: conditioning highpass -> gain -> memoryless curve -> equalization + /// lowpass. Allocation-free; coefficients are set by the owner each block. + class stage { + public: + void prepare(double sr, double hp_hz, double lp_hz) { + m_sr = (sr > 0.0) ? sr : 48000.0; + set_corners(hp_hz, lp_hz); + clear(); + } + + /// Recompute the fixed corners for a (possibly oversampled) rate. + void set_corners(double hp_hz, double lp_hz) { + m_a_hp = 1.0 - std::exp(-2.0 * k_pi * hp_hz / m_sr); + m_a_lp = 1.0 - std::exp(-2.0 * k_pi * lp_hz / m_sr); + } + + void clear() { m_hp = m_lp = 0.0; } + + /// `gain` is linear into the curve, `knee` the sharpness, `bias` the asymmetry that + /// buys even harmonics. The bias is corrected at the output so silence stays exactly + /// at zero (the overdrive.h contract). + double process(double x, double gain, double knee, double bias) { + m_hp += m_a_hp * (x - m_hp); + const double u = (x - m_hp) * gain; + const double y = shape(u + bias, knee) - shape(bias, knee); + m_lp += m_a_lp * (y - m_lp); + return m_lp; + } + + private: + double m_sr{48000.0}; + double m_a_hp{1.0}, m_a_lp{1.0}; + double m_hp{0.0}, m_lp{0.0}; + }; + + /// The voicing section: low shelf, mid scoop, high shelf. Linear, and entirely outside + /// the nonlinearity — the "equalization filter" of the cascade, at the audio rate. + class tone { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + design(0.0, 0.0, 0.0); + clear(); + } + + void clear() { + m_low.reset(); + m_mid.reset(); + m_high.reset(); + } + + /// bass/treble in -1..1 (full travel is k_voice_shelf_db either way), contrast in + /// 0..1 (0 flat, 1 the full mid scoop). + void design(double bass, double treble, double contrast) { + m_low.design_lowshelf(k_voice_bass_hz / m_sr, bass * k_voice_shelf_db); + m_high.design_highshelf(k_voice_treble_hz / m_sr, treble * k_voice_shelf_db); + m_mid.design_peaking(k_voice_mid_hz / m_sr, k_voice_mid_q, -contrast * k_voice_scoop_db); + } + + double process(double x) { return m_high.tick(m_mid.tick(m_low.tick(x))); } + + private: + double m_sr{48000.0}; + biquad m_low, m_mid, m_high; + }; + + /// The pedal: two stages inside the oversampled region, then DC block, tone, level. + class pedal { + public: + pedal() { + m_gain.snap(0.5); + m_edge.snap(0.5); + m_asymmetry.snap(0.0); + m_bass.snap(0.0); + m_treble.snap(0.0); + m_contrast.snap(0.35); + m_level_db.snap(0.0); + } + + // -- lifecycle ----------------------------------------------------------------------- + + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + configure(); + m_gain.snap(m_gain.target()); + m_edge.snap(m_edge.target()); + m_asymmetry.snap(m_asymmetry.target()); + m_bass.snap(m_bass.target()); + m_treble.snap(m_treble.target()); + m_contrast.snap(m_contrast.target()); + m_level_db.snap(m_level_db.target()); + m_tone.design(m_bass.current(), m_treble.current(), m_contrast.current()); + clear(); + } + + void clear() { + m_s1.clear(); + m_s2.clear(); + m_tone.clear(); + m_up.reset(); + m_down.reset(); + m_dc_x1 = m_dc_y1 = 0.0; + } + + bool prepared() const { return m_sr > 0.0 && m_configured; } + + // -- parameters (click-free; safe while audio runs) ---------------------------------- + + /// 0..1, sweeping the first stage's drive linearly in dB. + void set_gain(double g) { m_gain.to(std::clamp(g, 0.0, 1.0), smooth_samples()); } + + /// 0..1: how sharp the second stage's knee is — soft-ish limiter through to near-hard + /// clip. High settings alias; raise oversample. + void set_edge(double e) { m_edge.to(std::clamp(e, 0.0, 1.0), smooth_samples()); } + + /// 0..1 of clipping asymmetry — the even-harmonic control, and the thing an odd-only + /// static curve structurally cannot produce. + void set_asymmetry(double a) { m_asymmetry.to(std::clamp(a, 0.0, 1.0), smooth_samples()); } + + void set_bass(double b) { m_bass.to(std::clamp(b, -1.0, 1.0), smooth_samples()); } + void set_treble(double t) { m_treble.to(std::clamp(t, -1.0, 1.0), smooth_samples()); } + + /// 0..1 mid-scoop depth. This kernel's own curve — see the header. + void set_contrast(double c) { m_contrast.to(std::clamp(c, 0.0, 1.0), smooth_samples()); } + + /// Output level in dB, +-k_level_range_db. + void set_level_db(double db) { + m_level_db.to(std::clamp(db, -k_level_range_db, k_level_range_db), smooth_samples()); + } + + /// 1, 2, 4 or 8. Reconfigures the stage corners and the filters — not real-time-safe. + void set_oversample(int os) { + const int v = (os >= 8) ? 8 : (os >= 4) ? 4 : (os >= 2) ? 2 : 1; + if (v != m_os) { + m_os = v; + configure(); + clear(); + } + } + + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + double gain() const { return m_gain.target(); } + double edge() const { return m_edge.target(); } + double asymmetry() const { return m_asymmetry.target(); } + double bass() const { return m_bass.target(); } + double treble() const { return m_treble.target(); } + double contrast() const { return m_contrast.target(); } + double level_db() const { return m_level_db.target(); } + int oversample() const { return m_os; } + double smooth_ms() const { return m_smooth_ms; } + double samplerate() const { return m_sr; } + + // -- audio --------------------------------------------------------------------------- + + double process(double x) { + if (!prepared()) { + return x; + } + const double gain = m_gain.tick(); + const double edge = m_edge.tick(); + const double asym = m_asymmetry.tick(); + const double bass = m_bass.tick(); + const double treble = m_treble.tick(); + const double contrast = m_contrast.tick(); + const double level = m_level_db.tick(); + + if (bass != m_tone_bass || treble != m_tone_treble || contrast != m_tone_contrast) { + m_tone.design(bass, treble, contrast); + m_tone_bass = bass; + m_tone_treble = treble; + m_tone_contrast = contrast; + } + + const double drive = std::pow(10.0, (k_gain_min_db + gain * (k_gain_max_db - k_gain_min_db)) / 20.0); + const double knee2 = k_voice_stage2_knee + edge * (k_voice_edge_knee - k_voice_stage2_knee); + const double bias = asym * 0.7; // inside the curve; corrected at the stage output + + double y = 0.0; + if (m_os == 1) { + y = core(x, drive, knee2, bias); + } + else { + // zero-stuff + anti-image up, the clipper pair at the high rate, anti-alias + // + decimate down (the tap.ladder~ / overdrive.h chain). + for (int j = 0; j < m_os; ++j) { + const double up = m_up.tick(j == 0 ? x * m_os : 0.0); + y = m_down.tick(core(up, drive, knee2, bias)); + } + } + + // Asymmetry generates DC that the shelves would otherwise pass; always on. + const double d = y - m_dc_x1 + k_dc_r * m_dc_y1; + m_dc_x1 = y; + m_dc_y1 = anti_denormal(d); + + return m_tone.process(m_dc_y1) * std::pow(10.0, level / 20.0); + } + + void process(const double* in, double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(in[i]); + } + } + + private: + /// The two clipping stages, at whatever rate the caller is running. + double core(double x, double drive, double knee2, double bias) { + const double a = m_s1.process(x, drive, k_voice_stage1_knee, bias); + return m_s2.process(a, k_voice_stage2_gain, knee2, 0.0); + } + + void configure() { + const double osr = m_sr * m_os; + m_s1.prepare(osr, k_voice_stage1_hp_hz, k_voice_stage1_lp_hz); + m_s2.prepare(osr, k_voice_stage2_hp_hz, k_voice_stage2_lp_hz); + m_tone.prepare(m_sr); + if (m_os > 1) { + // Cut just below the original Nyquist, normalized to the oversampled rate. + const double fc_norm = 0.45 / static_cast(m_os); + m_up.design(fc_norm); + m_down.design(fc_norm); + } + m_tone_bass = m_tone_treble = m_tone_contrast = std::nan(""); + m_configured = true; + } + + static double anti_denormal(double x) { return (std::abs(x) < 1e-15) ? 0.0 : x; } + + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double m_sr{48000.0}; + double m_smooth_ms{k_default_smooth_ms}; + int m_os{4}; + bool m_configured{false}; + + stage m_s1, m_s2; + tone m_tone; + butterworth8 m_up, m_down; + double m_dc_x1{0.0}, m_dc_y1{0.0}; + + // Cached tone targets so the biquads are only redesigned when a control actually moves. + double m_tone_bass{0.0}, m_tone_treble{0.0}, m_tone_contrast{0.0}; + + ramp m_gain, m_edge, m_asymmetry, m_bass, m_treble, m_contrast, m_level_db; + }; + + } // namespace fuzz +} // namespace tap::tools diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index fbd71ec..8448b60 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -14,6 +14,7 @@ #include "delay.h" #include "diode_ladder.h" #include "discreet.h" +#include "fuzz.h" #include "garden.h" #include "grm_comb.h" #include "grm_pitchaccum.h" diff --git a/notebooks/taptools_py.py b/notebooks/taptools_py.py index 386af87..e6fc746 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -17,7 +17,7 @@ tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), the Discreet Music two-machine tape loop tap.discreet~ (`Discreet`), the multi-head tape echo tap.tapecho~ (`TapEcho`), the live buffer-stutter rig tap.stammer~ -(`Stammer`), the Music for Airports +(`Stammer`), the two-stage fuzz tap.fuzz~ (`Fuzz`), the Music for Airports incommensurate loop bank tap.airport~ (`Airport`), the generative event loop tap.garden~ (`Garden`), and tap.tune~'s pitch corrector (`Tune`, with the shared DspTap detector passed through as `Yin` for the notebooks' @@ -305,6 +305,21 @@ def load() -> ctypes.CDLL: "taptools_tapecho_clear": ([vp], ctypes.c_int), "taptools_tapecho_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_fuzz_create": ([], vp), + "taptools_fuzz_destroy": ([vp], None), + "taptools_fuzz_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_gain": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_edge": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_asymmetry": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_bass": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_treble": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_contrast": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_level_db": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_set_oversample": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_fuzz_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_fuzz_clear": ([vp], ctypes.c_int), + "taptools_fuzz_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_stammer_create": ([], vp), "taptools_stammer_destroy": ([vp], None), "taptools_stammer_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), @@ -1359,6 +1374,52 @@ def __del__(self): self._h = None +class Fuzz: + """tap.fuzz~'s kernel (tap::tools::fuzz::pedal): a two-stage, tone-stacked + distortion built on the Yeh/Abel/Smith DAFx-07 simplified cascade + (conditioning filter -> memoryless nonlinearity -> equalization filter, + twice), with a bass / contrast / treble voicing section outside the + nonlinearity. `gain` sweeps the first stage's drive, `edge` the second + stage's knee sharpness, `asymmetry` buys even harmonics. The clipper pair + runs oversampled (1/2/4/8x, default 4). A recreation of a circuit class, + not a component model of any one pedal.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_fuzz_create() + _check(_LIB.taptools_fuzz_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, gain=None, edge=None, asymmetry=None, bass=None, treble=None, + contrast=None, level_db=None, oversample=None, smooth_ms=None) -> "Fuzz": + # configuration first, so ramped targets in the same call honor the new slew + if oversample is not None: + _check(_LIB.taptools_fuzz_set_oversample(self._h, int(oversample)), "oversample") + if smooth_ms is not None: + _check(_LIB.taptools_fuzz_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + for name, value in (("gain", gain), ("edge", edge), ("asymmetry", asymmetry), + ("bass", bass), ("treble", treble), ("contrast", contrast), + ("level_db", level_db)): + if value is not None: + _check(getattr(_LIB, "taptools_fuzz_set_" + name)(self._h, float(value)), name) + return self + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_fuzz_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + """Flush the filters and the oversampling chain; parameters are kept.""" + _check(_LIB.taptools_fuzz_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_fuzz_destroy(h) + self._h = None + + class Stammer: """tap.stammer~'s kernel (tap::tools::stammer::machine): the live buffer-stutter rig. The input is captured continuously; on a `step_ms` diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 64d32a7..0e8887f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -19,6 +19,7 @@ add_executable(taptools_kernel_tests diode_ladder_test.cpp discreet_test.cpp garden_test.cpp + fuzz_test.cpp grm_comb_test.cpp harmonizer_test.cpp nr_test.cpp diff --git a/tests/fuzz_test.cpp b/tests/fuzz_test.cpp new file mode 100644 index 0000000..b242195 --- /dev/null +++ b/tests/fuzz_test.cpp @@ -0,0 +1,310 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.fuzz~ kernel (fuzz.h). +/// @details Oracle-based where the promise is audible: harmonic structure is measured out of +/// the output with a local Goertzel probe rather than by asserting internals, which +/// is how the even/odd asymmetry contract and the tone-stack claims are pinned. The +/// aliasing claim is measured the only honest way — by looking for energy at +/// frequencies that are *not* harmonics of the input and watching it fall as the +/// oversample factor rises. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + constexpr double k_pi = 3.14159265358979323846; + + using tap::tools::fuzz::pedal; + + /// A pedal with instant setters and a flat voicing: scenarios opt into tone and asymmetry. + pedal make() { + pedal p; + p.prepare(k_sr); + p.set_smooth_ms(0.0); + p.set_bass(0.0); + p.set_treble(0.0); + p.set_contrast(0.0); + p.set_asymmetry(0.0); + p.set_level_db(0.0); + return p; + } + + std::vector render(pedal& p, double hz, double amp, double seconds) { + const size_t n = static_cast(seconds * k_sr); + std::vector y(n, 0.0); + for (size_t i = 0; i < n; ++i) { + y[i] = p.process(amp * std::sin(2.0 * k_pi * hz * static_cast(i) / k_sr)); + } + return y; + } + + /// Single-bin magnitude, 2|X(f)|/N — the same probe as the tr808 and discreet suites. + double goertzel(const std::vector& x, double f, size_t begin, size_t end) { + const double w = 2.0 * k_pi * f / k_sr; + const double coef = 2.0 * std::cos(w); + double s1 = 0.0, s2 = 0.0; + for (size_t i = begin; i < end; ++i) { + const double s = x[i] + coef * s1 - s2; + s2 = s1; + s1 = s; + } + const double n = static_cast(end - begin); + const double re = s1 - s2 * std::cos(w); + const double im = s2 * std::sin(w); + return 2.0 * std::sqrt(re * re + im * im) / n; + } + + double rms(const std::vector& x, size_t begin, size_t end) { + double acc = 0.0; + for (size_t i = begin; i < end; ++i) { + acc += x[i] * x[i]; + } + return std::sqrt(acc / static_cast(end - begin)); + } + + size_t at(double seconds) { + return static_cast(seconds * k_sr); + } + +} // namespace + +SCENARIO("silence in is exactly silence out, at any asymmetry") { + // The bias lives inside the curve and is corrected at the stage output, so a asymmetric + // pedal must still be exactly quiet when nothing is playing — no DC pedestal, no hum. + for (double asym : {0.0, 0.5, 1.0}) { + pedal p = make(); + p.set_gain(1.0); + p.set_asymmetry(asym); + bool silent = true; + for (size_t i = 0; i < at(0.25); ++i) { + silent = silent && (p.process(0.0) == 0.0); + } + INFO("asymmetry " << asym); + REQUIRE(silent); + } +} + +SCENARIO("the clipping curve is monotonic, odd, and bounded at every knee") { + // The curve is the only nonlinear thing in the file, so it is tested directly. A DC sweep + // through the *stage* would measure nothing: the conditioning highpass settles a constant + // input to zero, which is what it is for. + using tap::tools::fuzz::shape; + for (double k : {0.0, 0.5, 1.6, 2.0, 12.0}) { + double last = -1e9; + bool mono = true, bounded = true, odd = true; + for (int i = 0; i <= 4000; ++i) { + const double x = -8.0 + 16.0 * static_cast(i) / 4000.0; + const double y = shape(x, k); + mono = mono && (y >= last); + bounded = bounded && std::isfinite(y) && (k < 1e-6 || std::abs(y) <= 1.0 / std::tanh(k) + 1e-12); + odd = odd && (std::abs(y + shape(-x, k)) < 1e-12); + last = y; + } + INFO("knee " << k); + CHECK(mono); // never folds back + CHECK(bounded); // asymptote is 1/tanh(k) + CHECK(odd); // symmetric curve, so odd harmonics only (see the asymmetry scenario) + } + // And the normalization the cascade depends on: full scale in is full scale out, any knee. + for (double k : {0.5, 1.6, 2.0, 12.0}) { + INFO("knee " << k); + CHECK(std::abs(shape(1.0, k) - 1.0) < 1e-12); + } +} + +SCENARIO("the pedal stays bounded on absurd input") { + pedal p = make(); + p.set_gain(1.0); + p.set_edge(1.0); + p.set_asymmetry(1.0); + + bool bounded = true; + for (size_t i = 0; i < at(0.2); ++i) { + const double x = 50.0 * std::sin(2.0 * k_pi * 110.0 * static_cast(i) / k_sr); + const double y = p.process(x); + bounded = bounded && std::isfinite(y) && std::abs(y) < 4.0; + } + REQUIRE(bounded); +} + +SCENARIO("more gain is more harmonic content") { + const double f0 = 220.0; + auto harmonic_ratio = [&](double gain) { + pedal p = make(); + p.set_gain(gain); + const std::vector y = render(p, f0, 0.3, 0.4); + const size_t b = at(0.2), e = at(0.4); + const double fund = goertzel(y, f0, b, e); + double harm = 0.0; + for (int k = 2; k <= 8; ++k) { + const double m = goertzel(y, f0 * k, b, e); + harm += m * m; + } + return std::sqrt(harm) / fund; + }; + + const double quiet = harmonic_ratio(0.0); + const double loud = harmonic_ratio(1.0); + INFO("harmonic/fundamental: gain 0 = " << quiet << ", gain 1 = " << loud); + REQUIRE(loud > quiet * 1.5); +} + +// The DAFx-07 note this kernel's asymmetry exists for: a symmetric static curve produces odd +// harmonics only, and a real op-amp stage clips asymmetrically, which is where the even +// harmonics come from. Measured out of the output, not asserted about the code. +SCENARIO("asymmetry is what puts even harmonics in the spectrum") { + const double f0 = 220.0; + auto even_odd = [&](double asym) { + pedal p = make(); + p.set_gain(0.8); + p.set_asymmetry(asym); + const std::vector y = render(p, f0, 0.3, 0.4); + const size_t b = at(0.2), e = at(0.4); + double even = 0.0, odd = 0.0; + for (int k = 2; k <= 8; ++k) { + const double m = goertzel(y, f0 * k, b, e); + (k % 2 == 0 ? even : odd) += m * m; + } + return std::sqrt(even) / std::sqrt(odd); + }; + + const double symmetric = even_odd(0.0); + const double asymmetric = even_odd(1.0); + INFO("even/odd ratio: symmetric = " << symmetric << ", asymmetric = " << asymmetric); + REQUIRE(symmetric < 0.05); // a symmetric curve is odd-only, to the noise floor + REQUIRE(asymmetric > symmetric * 10.0); // and asymmetry is what changes that +} + +// Aliasing is the honest weakness of a static curve, so it gets a real measurement. Two things +// this test had to get right, both of which caught a bug the first time round: +// +// * The tone must NOT divide the sample rate. At 3 kHz into 48 kHz every alias folds back +// exactly onto a harmonic of the input and is invisible; 3733 Hz puts the folds at +// frequencies nothing else occupies. +// * The probe frequencies must be far from the fundamental. Probes a few hundred Hz away +// measure spectral leakage from it (~1e-3 here) rather than aliasing, which swamps the +// thing being measured. +// +// What is asserted is what is true: oversampling drops aliasing by two orders of magnitude +// against no oversampling. It is deliberately NOT asserted that 8x beats 2x — measured, the +// residual above 2x sits around -60 dB where filter numerics and window leakage dominate, and a +// test that pinned an ordering there would be pinning noise. +SCENARIO("oversampling drops the aliased energy by orders of magnitude") { + const double f0 = 3733.0; // deliberately not a submultiple of the sample rate + auto alias_floor = [&](int os) { + pedal p = make(); + p.set_gain(1.0); + p.set_edge(1.0); + p.set_oversample(os); + const std::vector y = render(p, f0, 0.5, 0.4); + const size_t b = at(0.2), e = at(0.4); + // Where harmonics 8..13 of f0 fold back, skipping any fold that lands near the + // fundamental (those probes read leakage, not aliasing). + double acc = 0.0; + for (int k = 8; k <= 13; ++k) { + double f = k * f0; + while (f > k_sr * 0.5) { + f = (f > k_sr) ? f - k_sr : k_sr - f; + } + if (std::abs(f - f0) < 1000.0) { + continue; + } + const double m = goertzel(y, f, b, e); + acc += m * m; + } + return std::sqrt(acc); + }; + + const double none = alias_floor(1); + const double two = alias_floor(2); + const double four = alias_floor(4); + const double eight = alias_floor(8); + INFO("alias energy: 1x = " << none << ", 2x = " << two << ", 4x = " << four << ", 8x = " << eight); + REQUIRE(none > 0.05); // the test material really does alias when nothing is done + REQUIRE(two < none * 0.05); // and oversampling really does fix it + REQUIRE(four < none * 0.05); + REQUIRE(eight < none * 0.05); +} + +SCENARIO("the tone stack moves the band it says it moves") { + auto band = [](const std::vector& y, double f) { return goertzel(y, f, at(0.2), at(0.4)); }; + + // Drive the pedal with a low and a high tone at once and watch each shelf move its own end. + auto render_pair = [&](double bass, double treble, double contrast) { + pedal p = make(); + p.set_gain(0.3); + p.set_bass(bass); + p.set_treble(treble); + p.set_contrast(contrast); + std::vector y(at(0.4), 0.0); + for (size_t i = 0; i < y.size(); ++i) { + const double t = static_cast(i) / k_sr; + y[i] = p.process(0.15 * std::sin(2.0 * k_pi * 80.0 * t) + 0.15 * std::sin(2.0 * k_pi * 620.0 * t) + + 0.15 * std::sin(2.0 * k_pi * 6000.0 * t)); + } + return y; + }; + + const std::vector flat = render_pair(0.0, 0.0, 0.0); + const std::vector bassy = render_pair(1.0, 0.0, 0.0); + const std::vector bright = render_pair(0.0, 1.0, 0.0); + const std::vector scooped = render_pair(0.0, 0.0, 1.0); + + INFO("80 Hz: flat " << band(flat, 80.0) << " -> bassy " << band(bassy, 80.0)); + CHECK(band(bassy, 80.0) > band(flat, 80.0) * 1.5); + CHECK(band(bassy, 6000.0) < band(flat, 6000.0) * 1.1); // and leaves the top alone + + INFO("6 kHz: flat " << band(flat, 6000.0) << " -> bright " << band(bright, 6000.0)); + CHECK(band(bright, 6000.0) > band(flat, 6000.0) * 1.5); + CHECK(band(bright, 80.0) < band(flat, 80.0) * 1.1); + + INFO("620 Hz: flat " << band(flat, 620.0) << " -> scooped " << band(scooped, 620.0)); + CHECK(band(scooped, 620.0) < band(flat, 620.0) * 0.6); // contrast is a mid scoop + CHECK(band(scooped, 80.0) > band(flat, 80.0) * 0.8); // and it is a scoop, not a fader +} + +SCENARIO("the output carries no DC, even wide open and asymmetric") { + pedal p = make(); + p.set_gain(1.0); + p.set_asymmetry(1.0); + p.set_edge(1.0); + + const std::vector y = render(p, 220.0, 0.4, 1.0); + double mean = 0.0; + for (size_t i = at(0.5); i < y.size(); ++i) { + mean += y[i]; + } + mean /= static_cast(y.size() - at(0.5)); + INFO("tail mean " << mean << ", rms " << rms(y, at(0.5), y.size())); + REQUIRE(std::abs(mean) < 1e-3); +} + +SCENARIO("level is a clean output trim") { + auto level_rms = [](double db) { + pedal p = make(); + p.set_gain(0.5); + p.set_level_db(db); + const std::vector y = render(p, 220.0, 0.3, 0.4); + return rms(y, at(0.2), at(0.4)); + }; + + const double unity = level_rms(0.0); + const double up = level_rms(6.0); + INFO("rms at 0 dB " << unity << ", at +6 dB " << up); + REQUIRE(std::abs(up / unity - std::pow(10.0, 6.0 / 20.0)) < 0.02); +} + +SCENARIO("unprepared, the pedal passes input through") { + pedal p; + REQUIRE(p.process(0.7) == 0.7); + REQUIRE(p.process(-0.3) == -0.3); +} diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index c60fd4b..7b3f855 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -1228,6 +1229,69 @@ int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, return with(h, [&](tapecho_machine& m) { m.process(in, outL, outR, static_cast(n)); }); } +// ---- tap.fuzz~ ----------------------------------------------------------------------------------- + +using fuzz_pedal = tap::tools::fuzz::pedal; + +taptools_fuzz taptools_fuzz_create(void) { + return static_cast(new fuzz_pedal()); +} + +void taptools_fuzz_destroy(taptools_fuzz h) { + delete static_cast(h); +} + +int taptools_fuzz_prepare(taptools_fuzz h, double sr) { + return with(h, [&](fuzz_pedal& p) { p.prepare(sr); }); +} + +int taptools_fuzz_set_gain(taptools_fuzz h, double g) { + return with(h, [&](fuzz_pedal& p) { p.set_gain(g); }); +} + +int taptools_fuzz_set_edge(taptools_fuzz h, double e) { + return with(h, [&](fuzz_pedal& p) { p.set_edge(e); }); +} + +int taptools_fuzz_set_asymmetry(taptools_fuzz h, double a) { + return with(h, [&](fuzz_pedal& p) { p.set_asymmetry(a); }); +} + +int taptools_fuzz_set_bass(taptools_fuzz h, double b) { + return with(h, [&](fuzz_pedal& p) { p.set_bass(b); }); +} + +int taptools_fuzz_set_treble(taptools_fuzz h, double t) { + return with(h, [&](fuzz_pedal& p) { p.set_treble(t); }); +} + +int taptools_fuzz_set_contrast(taptools_fuzz h, double c) { + return with(h, [&](fuzz_pedal& p) { p.set_contrast(c); }); +} + +int taptools_fuzz_set_level_db(taptools_fuzz h, double db) { + return with(h, [&](fuzz_pedal& p) { p.set_level_db(db); }); +} + +int taptools_fuzz_set_oversample(taptools_fuzz h, int os) { + return with(h, [&](fuzz_pedal& p) { p.set_oversample(os); }); +} + +int taptools_fuzz_set_smooth_ms(taptools_fuzz h, double ms) { + return with(h, [&](fuzz_pedal& p) { p.set_smooth_ms(ms); }); +} + +int taptools_fuzz_clear(taptools_fuzz h) { + return with(h, [&](fuzz_pedal& p) { p.clear(); }); +} + +int taptools_fuzz_process(taptools_fuzz h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](fuzz_pedal& p) { p.process(in, out, static_cast(n)); }); +} + // ---- tap.stammer~ -------------------------------------------------------------------------------- using stammer_machine = tap::tools::stammer::machine; diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index adbfc41..213be34 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -393,6 +393,25 @@ TAPTOOLS_API int taptools_tapecho_clear(taptools_tapecho h); /// Process n samples mono-in / stereo-out (the dry path is mixed to both busses). TAPTOOLS_API int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, double* outR, int n); +// ---- tap.fuzz~ (tap::tools::fuzz::pedal) --------------------------------------------------------- + +typedef void* taptools_fuzz; + +TAPTOOLS_API taptools_fuzz taptools_fuzz_create(void); +TAPTOOLS_API void taptools_fuzz_destroy(taptools_fuzz h); +TAPTOOLS_API int taptools_fuzz_prepare(taptools_fuzz h, double sr); +TAPTOOLS_API int taptools_fuzz_set_gain(taptools_fuzz h, double g); // 0..1, first-stage drive +TAPTOOLS_API int taptools_fuzz_set_edge(taptools_fuzz h, double e); // 0..1, second-stage knee +TAPTOOLS_API int taptools_fuzz_set_asymmetry(taptools_fuzz h, double a); // 0..1, the even harmonics +TAPTOOLS_API int taptools_fuzz_set_bass(taptools_fuzz h, double b); // -1..1 low shelf +TAPTOOLS_API int taptools_fuzz_set_treble(taptools_fuzz h, double t); // -1..1 high shelf +TAPTOOLS_API int taptools_fuzz_set_contrast(taptools_fuzz h, double c); // 0..1 mid scoop +TAPTOOLS_API int taptools_fuzz_set_level_db(taptools_fuzz h, double db); +TAPTOOLS_API int taptools_fuzz_set_oversample(taptools_fuzz h, int os); // 1, 2, 4 or 8 +TAPTOOLS_API int taptools_fuzz_set_smooth_ms(taptools_fuzz h, double ms); +TAPTOOLS_API int taptools_fuzz_clear(taptools_fuzz h); +TAPTOOLS_API int taptools_fuzz_process(taptools_fuzz h, const double* in, double* out, int n); + // ---- tap.stammer~ (tap::tools::stammer::machine) ------------------------------------------------- typedef void* taptools_stammer; From d05a654bb4f3888eef30dc53a2fbbdec0bfb1e9d Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 15:48:37 +0000 Subject: [PATCH 09/22] Finish the fuzz verification layer, and correct the oversampling claim Adds the executed fuzz.ipynb and three radiohead_render scenarios (the gain sweep, the voicing section, and the knee sharpening into the even harmonics). Building the notebook caught an overclaim in the kernel header, the plan and the previous commit message: 8th-order anti-aliasing was described as restoring the monotone improvement that oversampling promises. It does not. Measured against a 3733 Hz tone, fold energy runs 1.2e-1 / 2.7e-5 / 7.4e-4 / 1.8e-3 at 1x / 2x / 4x / 8x -- every factor is worth having over none, and 2x is the best of them, so 2x is now the default rather than 4x. Eighth order is still the right filter (it improves 4x about sixfold over the house 4th-order pattern); it just does not do what was claimed. The cause of the non-monotonicity is recorded as open, with one hypothesis tested and ruled out -- biquads going ill-conditioned at the low normalized cutoffs a high factor needs, disproved by an impulse-response check showing clean decay to denormal at every factor -- and the untested one (imaging from zero-stuff upsampling intermodulating in the clipper) named along with the fix it would imply, cascaded 2x resampling. The kernel test already asserted only what was true here, so it needed no change: all factors beat 1x by orders of magnitude, and no ordering among them is pinned. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 17 +- include/taptools/fuzz.h | 54 ++-- notebooks/fuzz.ipynb | 497 ++++++++++++++++++++++++++++++ tools/render/radiohead_render.cpp | 87 +++++- 4 files changed, 628 insertions(+), 27 deletions(-) create mode 100644 notebooks/fuzz.ipynb diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 9a13df0..6af00ce 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -240,12 +240,17 @@ five-minute job for someone with institutional access and not something to fake > knob did nothing above about 0.2 — because the tanh family's small-signal slope is > `knee/tanh(knee)` (~3 at the original knee) and that multiplied into a fixed ×2.2. > Retuned; the harmonic ratio now sweeps 0.010 → 0.358 across the knob. -> 2. *The house oversampler is not steep enough here.* With the 4th-order Butterworth that -> `tap.ladder~` / `overdrive.h` use, alias energy fell from 1× to 2× and then **rose** -> at 4× and 8×. Replaced with 8th order, which restores the monotone improvement. -> Whether `overdrive.h` is owed the same change is a live question — different -> nonlinearity, different gain structure, so it needs its own measurement rather than -> this one's conclusion. +> 2. *The house oversampler is not steep enough here — and steepening it was not the whole +> story.* With the 4th-order Butterworth that `tap.ladder~` / `overdrive.h` use, alias +> energy at 4× came out worse than at 2× (1.7e-2 vs 2.8e-3). Eighth order improves 4× by +> ~6× but does **not** make the sequence monotone: measured, 1×/2×/4×/8× run +> 1.2e-1 / 2.7e-5 / 7.4e-4 / 1.8e-3, so 2× is best and is now the default. An earlier +> draft of this record claimed 8th order "restored monotonicity" — it does not, and the +> notebook plot is the correction. The cause is open: the obvious suspect (ill-conditioned +> biquads at low normalized cutoffs) was tested and **ruled out** by an impulse-response +> check; the untested hypothesis is imaging, which would point at cascaded 2× resampling +> as the real fix. Whether `overdrive.h` is owed the 8th-order change is a separate live +> question needing its own measurement. > > Two test-design errors were also caught and are recorded in the suite itself, since both > are easy to repeat: an alias test whose tone divided the sample rate (every fold lands on diff --git a/include/taptools/fuzz.h b/include/taptools/fuzz.h index 7a145a3..cdd0eca 100644 --- a/include/taptools/fuzz.h +++ b/include/taptools/fuzz.h @@ -43,15 +43,17 @@ /// - `pedal` — input gain, the two stages inside the oversampled region, the DC /// blocker, the tone stack, output level. /// -/// Aliasing: the clipper pair runs oversampled (1/2/4/8x, default 4x) — zero-stuff -/// plus an 8th-order Butterworth anti-image on the way up, a matching anti-alias -/// before decimation. The house pattern (tap.ladder~ / overdrive.h) uses 4th order -/// there; it was measured here and found to make oversampling *non-monotone* for -/// this kernel, so this file uses 8th (see butterworth8's comment for the numbers). DAFx-07 notes that -/// typical implementations use 8-10x and that residual aliases at 8x and above tend -/// to be masked by the dense spectrum of guitar distortion; 4x is the default here -/// because this kernel's curve is C-infinity rather than a hard corner, and 8 is one -/// setter away when it is not enough. +/// Aliasing: the clipper pair runs oversampled (1/2/4/8x, **default 2x**) — +/// zero-stuff plus an 8th-order Butterworth anti-image on the way up, a matching +/// anti-alias before decimation. Two things here differ from the house pattern and +/// both are measurements rather than preferences. The pattern's 4th-order filter is +/// not steep enough (it made 4x worse than 2x); and even at 8th order the sequence +/// is *not* monotone — 2x measures best, so 2x is the default, not the largest +/// factor. DAFx-07 notes that typical implementations use 8-10x and that residual +/// aliases there tend to be masked by the dense spectrum of guitar distortion; this +/// kernel's curve is C-infinity rather than a hard corner, which is why a modest +/// factor already buys four orders of magnitude. See butterworth8's comment for the +/// numbers and for what is and is not known about the cause. /// /// Honest limits: /// - The nonlinearity is static. The pole-moves-with-voltage behaviour of the real @@ -216,14 +218,27 @@ namespace tap::tools { /// anti-image and anti-alias filter. /// /// The house pattern (tap.ladder~ / overdrive.h) uses a 4th-order pair here. It is not - /// steep enough for this kernel, and the difference is measurable rather than - /// theoretical: with the 4th-order filter, alias energy fell from 1x to 2x and then rose - /// again at 4x and 8x — more oversampling made it *worse*, because 24 dB/octave leaves - /// content just above the base Nyquist barely touched, and a higher factor pushes more - /// clipper-generated harmonics into that barely-touched band before decimation. Eighth - /// order restores the monotone improvement the setting promises. (Whether the same change - /// is owed to overdrive.h is a live question — it is a different nonlinearity at a - /// different gain structure, so it needs its own measurement, not this one's conclusion.) + /// steep enough for this kernel: with it, alias energy at the fold frequencies measured + /// 1.7e-2 at 4x against 2.8e-3 at 2x — more oversampling was *worse*. Eighth order cuts + /// that to 2.7e-3, a ~6x improvement at 4x. + /// + /// It does NOT make the sequence monotone, and this file does not claim it does. Measured + /// against a 3733 Hz tone (fuzz.ipynb §5), fold-frequency energy runs 1.2e-1 / 2.7e-5 / + /// 7.4e-4 / 1.8e-3 at 1x / 2x / 4x / 8x: every factor is worth having over none, and 2x + /// is the best of them, which is why it is the default. + /// + /// The cause is not established. The obvious suspect — biquads going ill-conditioned at + /// the low normalized cutoffs a high factor needs (0.056 at 8x) — was tested and ruled + /// out: the cascade's impulse response decays cleanly to denormal at every factor. The + /// next hypothesis, untested, is imaging: zero-stuffing by N leaves N-1 images for one + /// filter to suppress, and residuals intermodulate in the clipper into products that are + /// not harmonics of the input, which is exactly what the probe measures. If that is + /// right, the fix is cascaded 2x (halfband/polyphase) resampling rather than a single + /// stage at 1/N — each step then suppresses one image at a comfortable normalized + /// frequency. That is the known next move on this file. + /// + /// (Whether overdrive.h is owed the 8th-order change is a live question — different + /// nonlinearity, different gain structure, so it needs its own measurement.) /// /// Pole Qs are the standard 8th-order Butterworth set, Q_k = 1/(2 cos((2k+1)pi/16)). struct butterworth8 { @@ -383,7 +398,8 @@ namespace tap::tools { m_level_db.to(std::clamp(db, -k_level_range_db, k_level_range_db), smooth_samples()); } - /// 1, 2, 4 or 8. Reconfigures the stage corners and the filters — not real-time-safe. + /// 1, 2, 4 or 8; 2 is the default and measures best (see the banner — bigger is not + /// better here). Reconfigures the stage corners and the filters — not real-time-safe. void set_oversample(int os) { const int v = (os >= 8) ? 8 : (os >= 4) ? 4 : (os >= 2) ? 2 : 1; if (v != m_os) { @@ -488,7 +504,7 @@ namespace tap::tools { double m_sr{48000.0}; double m_smooth_ms{k_default_smooth_ms}; - int m_os{4}; + int m_os{2}; bool m_configured{false}; stage m_s1, m_s2; diff --git a/notebooks/fuzz.ipynb b/notebooks/fuzz.ipynb new file mode 100644 index 0000000..c3bcada --- /dev/null +++ b/notebooks/fuzz.ipynb @@ -0,0 +1,497 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "259470e2", + "metadata": {}, + "source": [ + "# tap.fuzz~ — the dirt, measured\n", + "\n", + "A two-stage, tone-stacked distortion (`taptools/fuzz.h`): the harder, more scooped school that\n", + "sits beside `tap.overdrive~`'s feedback soft-clipper rather than replacing it.\n", + "\n", + "The method is not invented here. It is the **simplified cascade** of Yeh, Abel & Smith,\n", + "*\"Simplified, Physically-Informed Models of Distortion and Overdrive Guitar Effects Pedals\"*\n", + "(Proc. DAFx-07): conditioning filter → memoryless nonlinearity → equalization filter, twice.\n", + "That paper is also where the justification comes from — the diode limiter is really a lowpass\n", + "whose pole moves with voltage, its exact ODE is expensive, and approximating it as a static\n", + "curve between fixed filters is defended there and measured against real pedals. It is a\n", + "recreation of a *class* of circuit; no component value here is claimed as measured from any\n", + "unit.\n", + "\n", + "Two of the sections below exist because the first implementation was wrong and measurement\n", + "caught it: the gain staging (§2) and the oversampling filter order (§5).\n", + "\n", + "Every trace drives the **shipping C++** through `tools/capi` via ctypes.\n", + "\n", + "Sections: **1** the curve · **2** gain staging · **3** the even harmonics · **4** the tone stack\n", + "· **5** aliasing, and a house pattern that did not survive" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ab2f98c2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T15:48:08.196502Z", + "iopub.status.busy": "2026-08-16T15:48:08.196324Z", + "iopub.status.idle": "2026-08-16T15:48:08.614437Z", + "shell.execute_reply": "2026-08-16T15:48:08.612509Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.2),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def pedal(**params):\n", + " base = dict(smooth_ms=0, bass=0.0, treble=0.0, contrast=0.0, asymmetry=0.0, level_db=0.0)\n", + " base.update(params)\n", + " return tap.Fuzz(sr, **base)\n", + "\n", + "def tone_in(hz, amp=0.3, seconds=0.4):\n", + " t = np.arange(int(seconds * sr)) / sr\n", + " return amp * np.sin(2 * np.pi * hz * t)\n", + "\n", + "def spectrum(y, skip=0.5):\n", + " seg = y[int(skip * y.size):]\n", + " w = np.hanning(seg.size)\n", + " mag = np.abs(np.fft.rfft(seg * w)) * 2.0 / w.sum()\n", + " f = np.fft.rfftfreq(seg.size, 1 / sr)\n", + " return f, mag\n", + "\n", + "def at(f, freqs, mags):\n", + " return float(mags[np.argmin(np.abs(freqs - f))])" + ] + }, + { + "cell_type": "markdown", + "id": "89deb27a", + "metadata": {}, + "source": [ + "## 1 · The curve\n", + "\n", + "One clipping curve serves both stages: a tanh family with an adjustable knee,\n", + "`shape(x, k) = tanh(kx)/tanh(k)`, normalized so full scale in is full scale out at *every*\n", + "knee. That normalization is what lets the knee be a character control rather than a hidden\n", + "volume control.\n", + "\n", + "The curve is monotonic (it never folds back, which would add harmonics of its own), odd\n", + "(so a symmetric setting is odd-harmonics-only — see §3), and bounded." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "55661e28", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T15:48:08.617335Z", + "iopub.status.busy": "2026-08-16T15:48:08.617016Z", + "iopub.status.idle": "2026-08-16T15:48:08.785331Z", + "shell.execute_reply": "2026-08-16T15:48:08.784211Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "knee 0.5: shape(1) = 1.000000 small-signal slope = 1.082 asymptote = 2.1640\n", + "knee 1.6: shape(1) = 1.000000 small-signal slope = 1.736 asymptote = 1.0850\n", + "knee 2.0: shape(1) = 1.000000 small-signal slope = 2.075 asymptote = 1.0373\n", + "knee 12.0: shape(1) = 1.000000 small-signal slope = 12.000 asymptote = 1.0000\n" + ] + } + ], + "source": [ + "x = np.linspace(-3, 3, 1201)\n", + "fig, ax = plt.subplots()\n", + "for i, k in enumerate([0.5, 1.6, 2.0, 12.0]):\n", + " y = np.tanh(k * x) / np.tanh(k)\n", + " ax.plot(x, y, color=C[i], lw=1.4, label=f\"knee {k}\")\n", + "ax.plot(x, x, color=\"0.7\", lw=0.8, ls=\"--\", label=\"linear\")\n", + "ax.set_xlim(-3, 3); ax.set_ylim(-1.5, 1.5)\n", + "ax.set_xlabel(\"input\"); ax.set_ylabel(\"output\")\n", + "ax.set_title(\"shape(x, k) = tanh(kx)/tanh(k) — one family, soft knee to near-hard corner\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "for k in [0.5, 1.6, 2.0, 12.0]:\n", + " y = np.tanh(k * x) / np.tanh(k)\n", + " print(f\"knee {k:5.1f}: shape(1) = {np.tanh(k)/np.tanh(k):.6f} \"\n", + " f\"small-signal slope = {k/np.tanh(k):6.3f} asymptote = {1/np.tanh(k):.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "14ae489a", + "metadata": {}, + "source": [ + "## 2 · Gain staging — where the first implementation was wrong\n", + "\n", + "Look at the slope column above. The tanh family's small-signal gain is `k/tanh(k)`, which is\n", + "**greater than one and grows with the knee** — about 2 at the stock second-stage knee, and 3\n", + "at the knee the first draft used.\n", + "\n", + "That is easy to miss in a single stage and fatal in a cascade. The first cut of this kernel put\n", + "a ×2.2 fixed gain in front of a knee-3 curve, so the second stage saw an effective ×6.6 and was\n", + "*already fully clipped with the gain knob at zero* — the knob did nothing over most of its\n", + "travel. It sounded like a distortion the whole way, which is exactly why listening did not\n", + "catch it and a measurement did.\n", + "\n", + "Below: the harmonic-to-fundamental ratio across the knob, after retuning." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "69e2f549", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T15:48:08.787360Z", + "iopub.status.busy": "2026-08-16T15:48:08.787162Z", + "iopub.status.idle": "2026-08-16T15:48:09.152316Z", + "shell.execute_reply": "2026-08-16T15:48:09.151169Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "gain 0.0 -> 0.010 (edge of breakup)\n", + "gain 0.5 -> 0.284\n", + "gain 1.0 -> 0.358 (37x the harmonic content of gain 0)\n" + ] + } + ], + "source": [ + "def harmonic_ratio(gain, f0=220.0):\n", + " y = pedal(gain=gain).process(tone_in(f0))\n", + " f, m = spectrum(y)\n", + " fund = at(f0, f, m)\n", + " harm = np.sqrt(sum(at(f0 * k, f, m) ** 2 for k in range(2, 9)))\n", + " return harm / fund\n", + "\n", + "gains = np.linspace(0, 1, 11)\n", + "ratios = [harmonic_ratio(g) for g in gains]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(gains, ratios, color=C[0], marker=\"o\", ms=4)\n", + "ax.set_xlabel(\"gain\"); ax.set_ylabel(\"harmonics / fundamental\")\n", + "ax.set_title(\"the gain knob, after retuning: a real sweep from clean to saturated\")\n", + "plt.show()\n", + "\n", + "print(f\"gain 0.0 -> {ratios[0]:.3f} (edge of breakup)\")\n", + "print(f\"gain 0.5 -> {ratios[5]:.3f}\")\n", + "print(f\"gain 1.0 -> {ratios[-1]:.3f} ({ratios[-1] / ratios[0]:.0f}x the harmonic content of gain 0)\")" + ] + }, + { + "cell_type": "markdown", + "id": "ee9dc70b", + "metadata": {}, + "source": [ + "## 3 · The even harmonics\n", + "\n", + "A symmetric static curve is an odd function, so it can only produce odd harmonics. DAFx-07\n", + "points out that a real op-amp stage clips *asymmetrically*, which is where a pedal's even\n", + "harmonics come from — and that is the whole reason `asymmetry` exists here.\n", + "\n", + "The bias is applied inside the curve and corrected at the stage output, so an asymmetric pedal\n", + "is still *exactly* silent on silence: no DC pedestal." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f8eb603c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T15:48:09.154321Z", + "iopub.status.busy": "2026-08-16T15:48:09.154136Z", + "iopub.status.idle": "2026-08-16T15:48:09.520788Z", + "shell.execute_reply": "2026-08-16T15:48:09.519882Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "symmetric (0.0): even/odd = 0.00000 <- odd-only, to the noise floor\n", + "asymmetric (1.0): even/odd = 0.54841\n", + "and silence is still exactly silent: True\n" + ] + } + ], + "source": [ + "def even_odd(asym, f0=220.0):\n", + " y = pedal(gain=0.8, asymmetry=asym).process(tone_in(f0))\n", + " f, m = spectrum(y)\n", + " even = np.sqrt(sum(at(f0 * k, f, m) ** 2 for k in (2, 4, 6, 8)))\n", + " odd = np.sqrt(sum(at(f0 * k, f, m) ** 2 for k in (3, 5, 7)))\n", + " return even / odd\n", + "\n", + "asyms = np.linspace(0, 1, 11)\n", + "ratios = [even_odd(a) for a in asyms]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(asyms, ratios, color=C[2], marker=\"o\", ms=4)\n", + "ax.set_xlabel(\"asymmetry\"); ax.set_ylabel(\"even / odd harmonic energy\")\n", + "ax.set_title(\"asymmetry is what puts even harmonics in the spectrum\")\n", + "plt.show()\n", + "\n", + "print(f\"symmetric (0.0): even/odd = {ratios[0]:.5f} <- odd-only, to the noise floor\")\n", + "print(f\"asymmetric (1.0): even/odd = {ratios[-1]:.5f}\")\n", + "q = tap.Fuzz(sr, smooth_ms=0, gain=1.0, asymmetry=1.0)\n", + "print(f\"and silence is still exactly silent: {bool(np.all(q.process(np.zeros(4096)) == 0.0))}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5a43f58d", + "metadata": {}, + "source": [ + "## 4 · The tone stack\n", + "\n", + "Three linear filters entirely outside the nonlinearity — a low shelf, a high shelf, and a mid\n", + "scoop whose depth is `contrast`. On this class of pedal the voicing section is most of the\n", + "identity, which is why it is a first-class part of the object rather than an afterthought." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8d265bab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T15:48:09.523527Z", + "iopub.status.busy": "2026-08-16T15:48:09.523342Z", + "iopub.status.idle": "2026-08-16T15:48:10.351214Z", + "shell.execute_reply": "2026-08-16T15:48:10.350062Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def response(**tone):\n", + " # Measure the voicing at a gain low enough that the curve is near-linear, so what the plot\n", + " # shows is the tone stack rather than the distortion's own spectrum.\n", + " rng = np.random.default_rng(3)\n", + " x = 0.02 * rng.standard_normal(int(2.0 * sr))\n", + " y = pedal(gain=0.0, **tone).process(x)\n", + " f, m = spectrum(y, skip=0.25)\n", + " fr, mr = spectrum(x, skip=0.25)\n", + " keep = (f > 30) & (f < 16000)\n", + " # smooth in log-frequency for a readable curve\n", + " db = 20 * np.log10(np.maximum(m[keep], 1e-12) / np.maximum(mr[keep], 1e-12))\n", + " n = 257\n", + " return f[keep], np.convolve(db, np.ones(n) / n, mode=\"same\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "for i, (label, kw) in enumerate([(\"flat\", {}),\n", + " (\"contrast 1\", dict(contrast=1.0)),\n", + " (\"bass +1\", dict(bass=1.0)),\n", + " (\"treble +1\", dict(treble=1.0))]):\n", + " f, db = response(**kw)\n", + " ax.semilogx(f, db, color=C[i], lw=1.4, label=label)\n", + "ax.set_xlim(40, 15000); ax.set_ylim(-20, 20)\n", + "ax.set_xlabel(\"frequency (Hz)\"); ax.set_ylabel(\"gain (dB)\")\n", + "ax.set_title(\"the voicing section, measured through the object\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8a682340", + "metadata": {}, + "source": [ + "## 5 · Aliasing — and a house pattern that did not survive contact\n", + "\n", + "A static curve generates harmonics without limit, so anything above Nyquist folds back. The\n", + "clipper pair therefore runs oversampled, with an anti-image filter on the way up and a matching\n", + "anti-alias filter before decimation.\n", + "\n", + "The house pattern (`tap.ladder~`, `overdrive.h`) uses a **4th-order** Butterworth there. Measured\n", + "in this kernel it is not steep enough — fold energy at 4× came out *worse* than at 2× (1.7e-2\n", + "against 2.8e-3). Eighth order improves 4× by about 6×, and this file uses it.\n", + "\n", + "It does **not** make the sequence monotone, and the plot below is the honest picture: every\n", + "factor beats no oversampling by orders of magnitude, and **2× measures best**, which is why 2×\n", + "is the default rather than the largest factor. The cause is not established. The obvious\n", + "suspect — biquads going ill-conditioned at the low normalized cutoffs a high factor needs\n", + "(0.056 at 8×) — was tested and ruled out: the cascade's impulse response decays cleanly to\n", + "denormal at every factor. The untested next hypothesis is imaging (zero-stuffing by N leaves\n", + "N−1 images for one filter to suppress, and residuals intermodulate in the clipper into exactly\n", + "the non-harmonic products this probe measures), which would point at cascaded 2× resampling as\n", + "the fix.\n", + "\n", + "Measuring this correctly took two tries, and both mistakes are easy to repeat:\n", + "\n", + "* **The test tone must not divide the sample rate.** At 3 kHz into 48 kHz, every alias folds\n", + " back exactly onto a harmonic of the input and is invisible.\n", + "* **Probes must sit far from the fundamental**, or they measure window leakage from it rather\n", + " than aliasing." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5d6dcfdf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T15:48:10.353688Z", + "iopub.status.busy": "2026-08-16T15:48:10.353380Z", + "iopub.status.idle": "2026-08-16T15:48:10.664303Z", + "shell.execute_reply": "2026-08-16T15:48:10.663130Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1x: 1.228e-01\n", + "2x: 2.659e-05 ( 4618x better than 1x)\n", + "4x: 7.399e-04 ( 166x better than 1x)\n", + "8x: 1.774e-03 ( 69x better than 1x)\n" + ] + } + ], + "source": [ + "f0 = 3733.0 # deliberately not a submultiple of the sample rate\n", + "\n", + "def alias_energy(os):\n", + " y = pedal(gain=1.0, edge=1.0, oversample=os).process(tone_in(f0, amp=0.5))\n", + " f, m = spectrum(y)\n", + " total = 0.0\n", + " for k in range(8, 14):\n", + " fold = k * f0\n", + " while fold > sr / 2:\n", + " fold = fold - sr if fold > sr else sr - fold\n", + " if abs(fold - f0) < 1000: # skip probes that would read leakage, not aliasing\n", + " continue\n", + " total += at(fold, f, m) ** 2\n", + " return np.sqrt(total)\n", + "\n", + "factors = [1, 2, 4, 8]\n", + "energies = [alias_energy(o) for o in factors]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.semilogy(factors, energies, color=C[0], marker=\"o\", ms=6)\n", + "ax.set_xticks(factors)\n", + "ax.set_xlabel(\"oversample factor\"); ax.set_ylabel(\"energy at fold frequencies\")\n", + "ax.set_title(\"aliasing against oversampling — every factor helps; 2x measures best\")\n", + "plt.show()\n", + "\n", + "for o, e in zip(factors, energies):\n", + " print(f\"{o}x: {e:.3e}\" + (\"\" if o == 1 else f\" ({energies[0] / e:>5.0f}x better than 1x)\"))" + ] + }, + { + "cell_type": "markdown", + "id": "6c8447d8", + "metadata": {}, + "source": [ + "## Checkpoint\n", + "\n", + "- One tanh family with an adjustable knee, normalized so full scale in is full scale out at\n", + " every knee — monotonic, odd, bounded.\n", + "- The gain knob sweeps clean to saturated for real, after a first cut where the cascade's\n", + " compounded small-signal slope had the second stage clipped at zero.\n", + "- `asymmetry` is the even-harmonic control, and it costs no DC: silence stays exactly silent.\n", + "- The voicing section is three linear filters outside the nonlinearity.\n", + "- Oversampling buys orders of magnitude against none, with an 8th-order filter because the\n", + " house 4th-order one measured worse at higher factors — but bigger is not better here, 2×\n", + " measures best, and why that is remains open.\n", + "\n", + "Every number above lives twice: as a cell in this notebook and as a pinned scenario in\n", + "`tests/fuzz_test.cpp`." + ] + } + ], + "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/tools/render/radiohead_render.cpp b/tools/render/radiohead_render.cpp index 5d2bee4..647e1a0 100644 --- a/tools/render/radiohead_render.cpp +++ b/tools/render/radiohead_render.cpp @@ -1,6 +1,6 @@ /// @file /// @brief Offline renderer for the Radiohead family — writes demo WAVs for listening checks. -/// @details Exercises tapecho.h and stammer.h with no Max involved (the kernels' portability, demonstrated). +/// @details Exercises tapecho.h, stammer.h and fuzz.h with no Max involved (the kernels' portability, demonstrated). /// The tape echo is a *performed* effect, so these scenarios move the controls while /// they render rather than auditioning static settings — that is the only way to hear /// what the kernel is actually for. @@ -17,7 +17,10 @@ /// object exists for — density, chop, hold and reversal all ridden up until the part /// comes apart, then the reach-back opened so it quotes material from seconds ago), /// and `stammer_two_seeds` (the same settings on two seeds back to back: a seed is a -/// performance). +/// performance); and `fuzz_gain_sweep` (five gain settings back to back, so the +/// sweep from edge-of-breakup to saturated is audible rather than described), +/// `fuzz_tone` (the voicing section, which is most of that pedal class's identity), +/// and `fuzz_edge_and_bite` (the knee sharpening, then the even harmonics coming in). /// /// Usage: radiohead_render [output-directory] (default: current directory) /// @author Timothy Place @@ -31,6 +34,7 @@ #include #include +#include #include #include @@ -341,6 +345,82 @@ namespace { write_scenario(dir + "/stammer_two_seeds.wav", mono, 0.8, 1); } + // ---- tap.fuzz~ ------------------------------------------------------------------------------- + + /// The gain knob doing what a gain knob should: the same phrase at five settings, so the + /// sweep from edge-of-breakup to saturated is audible in one file rather than described. + void fuzz_gain_sweep(const std::string& dir) { + const double step = 4.0; + const size_t frames = static_cast(step * k_r_sr); + std::vector mono; + mono.reserve(5 * frames); + + for (double g : {0.0, 0.25, 0.5, 0.75, 1.0}) { + tap::tools::fuzz::pedal p; + p.prepare(k_r_sr); + p.set_gain(g); + p.set_edge(0.4); + p.set_asymmetry(0.15); + p.set_bass(0.2); + p.set_treble(0.1); + p.set_contrast(0.35); + for (size_t i = 0; i < frames; ++i) { + mono.push_back(p.process(looping_phrase(static_cast(i) / k_r_sr))); + } + } + write_scenario(dir + "/fuzz_gain_sweep.wav", mono, 0.7, 1); + } + + /// The tone section, which on this class of pedal is most of the identity: flat, scooped, + /// and the two shelves at their travel, twelve seconds apiece. + void fuzz_tone(const std::string& dir) { + struct setting { + double bass, treble, contrast; + }; + const setting settings[4] = {{0.0, 0.0, 0.0}, {0.0, 0.0, 1.0}, {0.6, -0.6, 0.5}, {-0.6, 0.8, 0.5}}; + + const size_t frames = static_cast(8.0 * k_r_sr); + std::vector mono; + mono.reserve(4 * frames); + for (const setting& v : settings) { + tap::tools::fuzz::pedal p; + p.prepare(k_r_sr); + p.set_gain(0.7); + p.set_edge(0.5); + p.set_bass(v.bass); + p.set_treble(v.treble); + p.set_contrast(v.contrast); + for (size_t i = 0; i < frames; ++i) { + mono.push_back(p.process(looping_phrase(static_cast(i) / k_r_sr))); + } + } + write_scenario(dir + "/fuzz_tone.wav", mono, 0.4, 1); // the bass-shelf setting is the peak here + } + + /// The two controls a static-curve model has to be honest about, ridden rather than set: + /// `edge` sharpening the knee toward a corner, and `asymmetry` bringing in the even + /// harmonics an odd-only curve cannot make. + void fuzz_edge_and_bite(const std::string& dir) { + tap::tools::fuzz::pedal p; + p.prepare(k_r_sr); + p.set_gain(0.8); + p.set_contrast(0.4); + p.set_smooth_ms(300.0); + p.set_oversample(8); // the honest setting for a hard knee + + const double seconds = 24.0; + const size_t frames = static_cast(seconds * k_r_sr); + std::vector mono(frames); + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + const double u = t / seconds; + p.set_edge(u < 0.5 ? 2.0 * u : 1.0); // first half: the knee sharpens + p.set_asymmetry(u < 0.5 ? 0.0 : 2.0 * (u - 0.5)); // second half: the bite comes in + mono[i] = p.process(looping_phrase(t)); + } + write_scenario(dir + "/fuzz_edge_and_bite.wav", mono, 0.7, 1); + } + } // namespace int main(int argc, char** argv) { @@ -352,5 +432,8 @@ int main(int argc, char** argv) { stammer_grid(dir); stammer_disintegrate(dir); stammer_two_seeds(dir); + fuzz_gain_sweep(dir); + fuzz_tone(dir); + fuzz_edge_and_bite(dir); return 0; } From a202550ceb4b12dcd397f4ad3be77de1deb683e2 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 15:51:32 +0000 Subject: [PATCH 10/22] Open the Ondes gate: all three papers read The full texts arrived, so the source hunt closes. The touche d'intensite is now fully specified and its table is reproduced in the plan, because the table is the specification: 4.5 mm of travel carries the whole 50 dB, the map is memoryless (the paper shows it does not depend on gesture velocity), the taper is distinctly not linear-in-dB against displacement, it is linear in dB against log force over the playable region, and it separates cleanly from pitch. The bigger news is an amendment. The plan assumed a waveform-register VCO built on vco.h. The circuit paper models five coupled stages and finds the oscillators are essentially pure -- about 0.03% second-harmonic distortion -- which is the simplification the authors themselves use to reach real time. The timbre comes from the two triode stages after the demodulator and then from the diffuseur. So the kernel is a clean heterodyne source into a triode-flavoured nonlinearity into the touche curve into the diffuseurs, which is nearer overdrive.h and fuzz.h than vco.h, and a different object than the one sketched. Their full solve runs at 768 kHz and their plugin eats 85% of a laptop core, so the documented simplifications are the route, not a faithful circuit solve. The gate is open in the sense that matters: what remains is design, not sourcing. tap.ondes~ needs a design pass against these findings first. Also records that the papers are open access but sit behind an anti-automation wall with no mirror, and that the wall was not circumvented. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 137 ++++++++++++++++++++++------------ 1 file changed, 88 insertions(+), 49 deletions(-) diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 6af00ce..df384b5 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -32,7 +32,7 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. |--------|--------|-----------|-------------|--------| | `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | -| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | `garden.h` modal idiom (maths only — see the source hunt), `vco.h`/`vca.h` | planned — sources identified, full texts still needed | +| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | Heterodyne source + triode nonlinearity + `garden.h` modal idiom; **not** `vco.h` — see the source hunt | planned — sources read, gate open, needs a design pass | | `tap.fuzz~` | `fuzz.h` | Two-stage tone-stacked fuzz (the OK Computer-era dirt) | `overdrive.h` sibling; the DAFx-07 cascade | ✅ kernel shipped 2026-08-15; Max slice, notebook, chapter pending | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | @@ -53,7 +53,10 @@ The survey predated the Eno components wave by hours. Five amendments, now assum 2. **The Ondes diffuseurs inherit the garden's modal pattern.** Mode banks with published ratio tables (Fletcher & Rossing), doublet splitting, per-index deterministic scatter, per-mode decay — the scary half of `tap.ondes~` now has a shipped house idiom and a - standalone component (`tap.chime~`) to model the shape on. + standalone component (`tap.chime~`) to model the shape on. *(Amended twice by the source + hunt below: the resonator maths stands, but the diffuseurs are driven rather than struck, + so the garden's strike envelopes do not carry over — and the voice is not a `vco.h` + descendant at all.)* 3. **Components from day one.** The Eno components chapter's lesson — "the monoliths were monoliths by accident" — is prospective here: every kernel below is planned as parts with a thin composition, and the parts get C ABI + wrapper reachability from the start. @@ -174,53 +177,89 @@ ballgame here. If a needed number has no published source, the honest fallback i *recreation* voiced by ear against published recordings and documented as such — decided per-number, in the header, when we get there. -#### Source hunt, 2026-08-15 — findings - -The sources exist and are identified. Status per source, with an honest note on how far -each was actually read: - -| Source | For | Read to | -|--------|-----|---------| -| Quartier, Meurisse, Colmars, Frelat, Vaiedelich, "Intensity Key of the Ondes Martenot: An Early Mechanical Haptic Device", *Acta Acustica united with Acustica* **101**(2), 421–428, 2015 | the touche d'intensité | abstract / indexed summary only | -| Wijnand, Boutin, Jossic, Maniguet, "A physical model for the electromagnetic loudspeaker used in early Ondes Martenot diffuseurs", Forum Acusticum 2023 (EAA), CC-BY | the diffuseur transducer | **full text** | -| Najnudel, Hélie, Roze, Boutin, "Simulation of an Ondes Martenot Circuit", *IEEE/ACM TASLP* **28**, 2651–2660, 2020 | the oscillator/circuit | abstract only | -| Najnudel et al., "Simulation of the Ondes Martenot Ribbon-Controlled Oscillator…" (HAL hal-02425249) | the ribbon oscillator | abstract only | -| Leipp, "Les Ondes Martenot, un archétype", *Bulletin du GAM* n°60, 1972 | the palme (cited as the palme source by Wijnand et al.) | not obtained | -| Laurendeau, *Maurice Martenot, luthier de l'électronique* (1990; Beauchesne 2017) | the standard monograph | not obtained | - -**Three findings that change the design, not just the citation list.** - -1. **The touche maps *displacement*, not force.** The Acta Acustica work measured force on - the key, key depression, and the resulting sound, and reports that the change in sound - intensity depends on the key's displacement (the force applied follows from it), across a - **50 dB** dynamic range per note over the instrument's range. So the kernel's control - input is a position, the range is pinned at 50 dB, and what remains unknown is the - *taper* between them — which is exactly what the full text should settle. -2. **The diffuseurs are driven, not struck.** Wijnand et al. describe the *métallique* - (1944–45, patented 1947) as a gong excited by a **motor**, and the *palme* (1949–50) as an - **electromagnet driving 12 metal strings** attached to a soundboard; *résonance* (1970s) - is motor-excited metal springs. This invalidates amendment 2's assumption that the - diffuseurs inherit `garden.h`'s *strike-excited* modal idiom wholesale. The mode banks - still apply, but the excitation is continuous, so the right model is a driven resonator - bank — closer to `grm_comb.h`'s sustained ringing than to the chime's decay envelopes. - Amendment 2 stands for the resonator maths and falls for the excitation. -3. **The transducer itself is part of the sound.** The early diffuseurs used a moving-iron - loudspeaker whose operating principle is *inherently nonlinear* — the paper's point is - precisely that the linear Thiele–Small model does not apply, and it quantifies the - nonlinearity on a heritage instrument. A diffuseur model that is only a resonator is - missing a documented stage. - -**A discrepancy worth recording:** widely circulated DIY build pages describe the palme as -24 strings (two sets of 12); the peer-reviewed source says 12. Prefer the peer-reviewed -number, and treat hobbyist build documentation as unciteable for this family. - -**Where the gate stands.** Substantially clearer than when this plan was written: every -subsystem now has at least one peer-reviewed source, and two design assumptions have already -been corrected by reading them. It is **not yet clear** — full texts of the intensity-key -and circuit-simulation papers are still needed for the numbers that would go in the header, -and automated retrieval is blocked (HAL sits behind an anti-bot wall; the IEEE paper is -paywalled). The remaining step is manual access to those three PDFs, which is a -five-minute job for someone with institutional access and not something to fake around. +#### Source hunt, 2026-08-15 — findings, and the gate + +**All three full texts are now in hand** (supplied manually — HAL's Anubis wall blocks +automated retrieval, and Unpaywall confirms HAL is the only OA host for all three, so there is +no mirror; the papers are open access, the wall is anti-automation, and it was not circumvented). + +| Source | For | Status | +|--------|-----|--------| +| Quartier, Meurisse, Colmars, Frelat, Vaiedelich, "Intensity Key of the Ondes Martenot: An Early Mechanical Haptic Device", *Acta Acustica united with Acustica* **101**(2), 421–428, 2015, doi:10.3813/AAA.918837 | the touche d'intensité | **read in full** | +| Najnudel, Hélie, Roze, Boutin, "Simulation of an ondes Martenot circuit", *IEEE/ACM TASLP* **28**, 2651–2660, 2020 (HAL hal-02920526) | the circuit | **read in full** | +| Najnudel, Hélie, Roze, "Simulation of the Ondes Martenot Ribbon-Controlled Oscillator…", *JAES* **67**(12), 961–971, 2019, doi:10.17743/jaes.2019.0040 (HAL hal-02425249) | the variable oscillator | **read in full** | +| Wijnand, Boutin, Jossic, Maniguet, Forum Acusticum 2023 | the diffuseur transducer | read in full | + +**The touche d'intensité is fully specified — this subsystem's gate is open.** The key is a +rheostat: a graphite/mica powder bag compressed by the key, resistance dropping as the number +of conducting bead paths rises (the carbon-microphone principle). Quartier et al. measured +force, displacement and sound simultaneously on instrument No. 320 and give the taper as a +table, reproduced here because it *is* the specification: + +| dB_SPL | mean displacement (mm) | mean finger force (N) | +|--------|------------------------|------------------------| +| 45.0 | 4.3 (s.d. 0.15) | 0.39 (s.d. 0.06) | +| 53.3 | 5.3 (s.d. 0.19) | 0.47 (s.d. 0.07) | +| 61.6 | 5.9 (s.d. 0.15) | 0.52 (s.d. 0.07) | +| 70.0 | 6.4 (s.d. 0.15) | 0.62 (s.d. 0.08) | +| 78.3 | 6.8 (s.d. 0.12) | 0.82 (s.d. 0.11) | +| 86.6 | 7.3 (s.d. 0.08) | 1.34 (s.d. 0.11) | +| 95.0 | 8.8 (s.d. 0.05) | 9.60 (s.d. 0.30) | + +Five things follow directly, and together they are the `touche` component's contract: + +1. **4.5 mm of travel carries the whole 50 dB** (4.3 → 8.8 mm, background to maximum); + playable gestures span roughly 3–9.5 mm. +2. **The map is memoryless.** The paper states explicitly that the change in sound intensity + depends only on displacement and the force it implies, and *not on the velocity of the + gesture* — so a static displacement→gain curve is not a simplification, it is the finding. +3. **The taper is not linear-in-dB against displacement.** The table's dB steps are equal by + construction (six nuances over 50 dB) and the displacement steps are not: 1.0, 0.6, 0.5, + 0.4, 0.5, 1.5 mm. Interpolate the table; do not fit a straight line. +4. **Linear in dB against log(force)** over the quasi-linear region (below ~85 dB_SPL and + 1.3 N) — Weber–Fechner, and the paper's argument for why the key feels the way it does. + Useful if a force-sensing controller is ever the input; displacement is the primary map. +5. **Pitch-independent.** Resistance curves for different notes have the same shape, so the + key's law separates cleanly from the oscillator — one gain curve serves the whole range. + (Amplitude does fall ~8 dB as frequency rises, but that is the oscillator and speaker, not + the key.) + +**The voice is a heterodyne pair, not a waveform-register VCO — amendment needed.** The plan +assumed an oscillator with timbre switches built on `vco.h`. Najnudel et al. model instrument +No. 169 as **five coupled stages**: fixed-frequency oscillator (80 kHz), variable-frequency +oscillator, demodulator, preamplifier, power amplifier, coupled through transformers. Two +findings matter more than the topology: + +- **The oscillators are essentially pure.** Even coupled to the rest of the circuit, oscillator + output measures about **0.03 % second-harmonic distortion** — which is precisely the + simplification the authors use to reach real time. So the tone does *not* come from an + interesting oscillator waveform. +- **The timbre comes from downstream.** Harmonics are generated by the **two successive triode + stages** after the demodulator, and then the **diffuseur** "converts the electrical waveform + into sound and in turn modifies its spectral content". Their plugin even exposes demodulator + input gain as a harmonics control — a knob the real instrument does not have. + +So the kernel's shape should be: a clean sinusoidal source (heterodyne difference tone, and the +ribbon paper is the reference for the variable oscillator's tuning behaviour), into a +**triode-flavoured nonlinearity**, into the **touche** gain curve, into the diffuseurs. That is +much closer to `overdrive.h`/`fuzz.h` territory than to `vco.h`, and it is a different object +than the one this plan sketched. Note also that their full PHS simulation runs at 768 kHz and +their plugin consumes 85 % of a laptop CPU core — a faithful circuit solve is *not* the route +for a TapTools kernel; the documented simplifications are. + +**Diffuseurs, unchanged from the earlier note:** driven, not struck — *métallique* a +motor-excited gong (1944–45, patented 1947), *palme* an electromagnet driving **12** strings on +a soundboard (1949–50), *résonance* motor-excited springs (1970s). The early transducer is a +moving-iron loudspeaker and inherently nonlinear (Thiele–Small does not apply). Widely +circulated DIY pages say the palme has 24 strings; the peer-reviewed source says 12 — prefer +the peer-reviewed number and treat hobbyist build documentation as unciteable here. + +**Where the gate stands: open enough to build.** The touche is fully specified. The voice has a +published decomposition and, more usefully, a published *justification for simplifying it*. The +diffuseurs have their excitation and their transducer characterized, though the resonator mode +data still has to come from Fletcher & Rossing rather than from an ondes-specific source. The +remaining work is design, not sourcing — and the object it points at is not the one originally +sketched, so `tap.ondes~` needs a design pass against these findings before implementation. ### 4. `tap.fuzz~` — the two-stage fuzz *(small, parallel-friendly)* — ✅ kernel shipped From b72b80c2721cc95fb99bd319f10d1264e47bc77b Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 17:43:04 +0000 Subject: [PATCH 11/22] Write the fuzz chapters "The dirt with two stages" places tap.fuzz~ against tap.overdrive~ -- two dirt objects, not competitors -- and spends its length on the three things a patcher can act on: the knee as a character control, why the gain floor sits below unity, and why oversample 2 beats 8. The machine appendix is deliberately about two mistakes, because the DSP is a published recipe followed closely and the failures are the reusable part. Small-signal gain compounds across a cascade, which left the second stage saturated at gain 0 and was inaudible precisely because the object sounded like a distortion at every setting. And the house oversampling filter measured wrong here -- but so did my first explanation for it, so the appendix records the ruled-out hypothesis (biquad conditioning, disproved by an impulse-response check) next to the surviving one rather than leaving a vague note. The two aliasing test-design errors are written up too, since both passed review the first time. Two measured figures via book/figures/radiohead.py, SUMMARY and the introduction's part list updated, and the chapters' drafting record extended. mdbook builds clean. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-chapters.md | 33 +- book/PLAN-radiohead-family.md | 9 +- book/figures/radiohead.py | 68 ++- book/src/SUMMARY.md | 2 + book/src/fuzz.md | 139 +++++ book/src/images/fuzz/curve.svg | 510 +++++++++++++++++++ book/src/images/fuzz/gain-and-bite.svg | 481 +++++++++++++++++ book/src/images/stammer/material.svg | 40 +- book/src/images/stammer/occupancy.svg | 408 +++++++-------- book/src/images/tapecho/head-layout.svg | 58 +-- book/src/images/tapecho/self-oscillation.svg | 80 +-- book/src/introduction.md | 3 +- book/src/machine/fuzz.md | 115 +++++ 13 files changed, 1643 insertions(+), 303 deletions(-) create mode 100644 book/src/fuzz.md create mode 100644 book/src/images/fuzz/curve.svg create mode 100644 book/src/images/fuzz/gain-and-bite.svg create mode 100644 book/src/machine/fuzz.md diff --git a/book/PLAN-radiohead-chapters.md b/book/PLAN-radiohead-chapters.md index 299956e..23de039 100644 --- a/book/PLAN-radiohead-chapters.md +++ b/book/PLAN-radiohead-chapters.md @@ -1,7 +1,7 @@ # Plan — the Radiohead-family chapters -> **Status: drafted.** All four chapters are written and live in `src/` per the placement -> below (2026-08-15). This file remains as the drafting record, the plans-directory way. The +> **Status: drafted.** Six chapters now — the original four plus `tap.fuzz~`'s pair, added +> the same day (2026-08-15). This file remains as the drafting record, the plans-directory way. The > object-level plan is `PLAN-radiohead-family.md`; this one covers only the book. Planning document for the *Tools on Tap* chapters covering the first two Radiohead-family @@ -28,12 +28,14 @@ entries append to the file-by-file part, keeping its chronological order. - [Four heads and a motor](tapecho.md) - [The part that comes apart](stammer.md) +- [The dirt with two stages](fuzz.md) # Part X — The machine, file by file ...existing entries... - [Events, not audio: garden.h](machine/garden.md) - [Composition, not construction: tapecho.h](machine/tapecho.md) - [Dice you can replay: stammer.h](machine/stammer.md) +- [Two stages and a knee: fuzz.h](machine/fuzz.md) ``` **Found while renumbering:** `introduction.md`'s part list had been stale since the Eno wave @@ -53,6 +55,9 @@ contract, driving the shipping kernels through the C ABI rather than illustratin the analytic ceiling at every point. - `images/stammer/occupancy.svg` — when a slice is in flight, four density/repeat pairs. - `images/stammer/material.svg` — slice similarity for a sustained sine vs a played phrase. +- `images/fuzz/curve.svg` — the clipping family at four knees, all through the same full-scale + point. +- `images/fuzz/gain-and-bite.svg` — the gain knob's sweep and asymmetry's even/odd ratio. No hand-authored block diagrams this round. The Eno chapters needed them because their signal flow is a rig with named machines; these two are a tape line with extra read points @@ -141,6 +146,30 @@ contract, the early return at density 0, ring reads vs a burst memcpy (with the stated), the deliberate envelope dip, and the corollary to the components chapter — not every class boundary is a seam. +### `src/fuzz.md` — *The dirt with two stages* and `src/machine/fuzz.md` — *Two stages and a knee* + +Added with the object. The user-facing chapter opens by placing it against `tap.overdrive~` +(two dirt objects, not competing) and spends its length on the three things a patcher can act +on: the knee as a character control, why the gain floor sits below unity, and why +`oversample` 2 beats 8. The appendix is deliberately **about two mistakes**, because the DSP +is a published recipe followed closely and the failures are the reusable part: + +- *Small-signal gain compounds across a cascade.* The tanh family's slope is `k/tanh(k)`, so a + fixed ×2.2 into a knee-3 curve gave the second stage an effective ×6.6 and left it saturated + at gain 0. Harmonic ratio measured 0.401 → 0.408 across the whole knob. The point worth + keeping is that it was **inaudible** — it sounded like a distortion at every setting because + it was one — so only a swept measurement found it. +- *The house oversampler measured wrong here, and so did the first explanation.* 4th order made + 4× worse than 2×; 8th order improves 4× ~6× but does not restore an ordering. An earlier + draft of both the appendix and the plan claimed it did; that is corrected, the measured table + is in the chapter, and the ruled-out hypothesis (biquad conditioning, disproved by an + impulse-response check) is recorded alongside the surviving one (imaging) rather than left + as a vague "needs investigation". + +Two aliasing test-design errors are also written up in the appendix — a tone dividing the +sample rate, and probes near enough the fundamental to read window leakage — since both passed +review the first time. + ## Deliberately not covered - **The Max-side surface.** The reference pages and help patchers carry it; the book's diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index df384b5..46a96a6 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,7 +1,8 @@ # Plan — the Radiohead family -> **Status: in progress — `tap.tapecho~` and `tap.stammer~` have both shipped end-to-end, -> chapters included (2026-08-15); the rest is plan.** This is the drafting record of the +> **Status: in progress — `tap.tapecho~`, `tap.stammer~` and `tap.fuzz~` have all shipped +> end-to-end, chapters included (2026-08-15). `tap.ondes~`'s sources are read and its gate is +> open; `tap.scrub~` is still plan.** This is the drafting record of the > 2026-08-15 survey ("are there Radiohead-inspired objects we should consider?"), amended the > same day against the Eno components wave (`d4cf28a`) before any code was written. It stays > after the objects ship, the plans-directory way; the chapters have their own drafting @@ -33,7 +34,7 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. | `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | Heterodyne source + triode nonlinearity + `garden.h` modal idiom; **not** `vco.h` — see the source hunt | planned — sources read, gate open, needs a design pass | -| `tap.fuzz~` | `fuzz.h` | Two-stage tone-stacked fuzz (the OK Computer-era dirt) | `overdrive.h` sibling; the DAFx-07 cascade | ✅ kernel shipped 2026-08-15; Max slice, notebook, chapter pending | +| `tap.fuzz~` | `fuzz.h` | Two-stage tone-stacked fuzz (the OK Computer-era dirt) | `overdrive.h` sibling; the DAFx-07 cascade | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | Parked (surveyed, deliberately not planned): a spectral freeze on the `stft.h` scaffold @@ -261,7 +262,7 @@ data still has to come from Fletcher & Rossing rather than from an ondes-specifi remaining work is design, not sourcing — and the object it points at is not the one originally sketched, so `tap.ondes~` needs a design pass against these findings before implementation. -### 4. `tap.fuzz~` — the two-stage fuzz *(small, parallel-friendly)* — ✅ kernel shipped +### 4. `tap.fuzz~` — the two-stage fuzz *(small, parallel-friendly)* — ✅ shipped > **Shipped 2026-08-15**: `include/taptools/fuzz.h` (`stage` + `tone` under a thin `pedal`), > `tests/fuzz_test.cpp` (9 scenarios), and the C ABI + ctypes surface (`Fuzz`). The name diff --git a/book/figures/radiohead.py b/book/figures/radiohead.py index cca20be..5a2d360 100644 --- a/book/figures/radiohead.py +++ b/book/figures/radiohead.py @@ -1,16 +1,16 @@ #!/usr/bin/env python3 """Generate the measured figures for the Radiohead-family book chapters. -Drives the *shipping* kernels (tapecho.h, stammer.h) through the C ABI via the +Drives the *shipping* kernels (tapecho.h, stammer.h, fuzz.h) through the C ABI via the notebooks' ctypes bridge — the same rule as eno.py and the verification notebooks: figures are measurements of the real DSP, never illustrations of what it should do. The companion notebooks (notebooks/tapecho.ipynb, -stammer.ipynb) carry the same measurements with commentary; this script renders +stammer.ipynb, fuzz.ipynb) carry the same measurements with commentary; this script renders the book-styled SVGs. Regenerate after a kernel behavior change: - python3 book/figures/radiohead.py # writes book/src/images/{tapecho,stammer}/*.svg + python3 book/figures/radiohead.py # writes book/src/images/{tapecho,stammer,fuzz}/*.svg Colors and rcParams are eno.py's, verbatim in intent: the house categorical hues with the amber snapped darker so pairs pass the print/CVD lightness-band @@ -198,9 +198,71 @@ def similarity(x, win_ms=60.0, n=96, seed=0): plt.close(fig) +def fuzz_curve(): + """fuzz: the one clipping family, and its knee as a character control.""" + x = np.linspace(-3, 3, 1201) + fig, ax = plt.subplots(figsize=(7.2, 2.8)) + for k, color, label in [(0.5, INK, "0.5"), (1.6, BLUE, "1.6 — first stage"), + (2.0, AMBER, "2.0 — second stage, edge 0"), (12.0, RED, "12 — edge 1")]: + ax.plot(x, np.tanh(k * x) / np.tanh(k), color=color, lw=1.4) + ax.text(3.05, np.tanh(k * 3.0) / np.tanh(k), label, color=color, fontsize=8.5, va="center") + ax.plot(x, x, color="0.75", lw=0.8, ls="--") + ax.set_xlim(-3, 4.4); ax.set_ylim(-1.6, 1.6) + ax.set_xlabel("input"); ax.set_ylabel("output") + ax.set_title("one curve, tanh(kx)/tanh(k): full scale in is full scale out at every knee") + fig.savefig(out_dir("fuzz") / "curve.svg", bbox_inches="tight") + plt.close(fig) + + +def fuzz_gain_and_bite(): + """fuzz: the gain knob's real sweep, and asymmetry as the even-harmonic control.""" + f0 = 220.0 + t = np.arange(int(0.4 * fs)) / fs + x = 0.3 * np.sin(2 * np.pi * f0 * t) + + def spec(y): + seg = y[int(0.5 * y.size):] + w = np.hanning(seg.size) + return (np.fft.rfftfreq(seg.size, 1 / fs), np.abs(np.fft.rfft(seg * w)) * 2.0 / w.sum()) + + def at(f, fr, m): + return float(m[np.argmin(np.abs(fr - f))]) + + def make(**kw): + base = dict(smooth_ms=0, bass=0.0, treble=0.0, contrast=0.0, asymmetry=0.0, level_db=0.0) + base.update(kw) + return tap.Fuzz(fs, **base) + + knob = np.linspace(0, 1, 11) + harm = [] + for g in knob: + fr, m = spec(make(gain=g).process(x)) + harm.append(np.sqrt(sum(at(f0 * k, fr, m) ** 2 for k in range(2, 9))) / at(f0, fr, m)) + + even = [] + for a in knob: + fr, m = spec(make(gain=0.8, asymmetry=a).process(x)) + e = np.sqrt(sum(at(f0 * k, fr, m) ** 2 for k in (2, 4, 6, 8))) + o = np.sqrt(sum(at(f0 * k, fr, m) ** 2 for k in (3, 5, 7))) + even.append(e / o) + + fig, (a1, a2) = plt.subplots(1, 2, figsize=(7.2, 2.7)) + a1.plot(knob, harm, color=BLUE, marker="o", ms=4) + a1.set_xlabel("gain"); a1.set_ylabel("harmonics / fundamental") + a1.set_title("the gain knob", fontsize=9.5) + a2.plot(knob, even, color=RED, marker="o", ms=4) + a2.set_xlabel("asymmetry"); a2.set_ylabel("even / odd energy") + a2.set_title("asymmetry buys the even harmonics", fontsize=9.5) + plt.tight_layout() + fig.savefig(out_dir("fuzz") / "gain-and-bite.svg", bbox_inches="tight") + plt.close(fig) + + if __name__ == "__main__": head_layout() self_oscillation() occupancy() material() + fuzz_curve() + fuzz_gain_and_bite() print("wrote the Radiohead-family figures") diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index 82c08e5..174de3a 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -29,6 +29,7 @@ - [Four heads and a motor](tapecho.md) - [The part that comes apart](stammer.md) +- [The dirt with two stages](fuzz.md) # Part VI — The spectral set @@ -72,6 +73,7 @@ - [Events, not audio: garden.h](machine/garden.md) - [Composition, not construction: tapecho.h](machine/tapecho.md) - [Dice you can replay: stammer.h](machine/stammer.md) +- [Two stages and a knee: fuzz.h](machine/fuzz.md) # Part XI — Recipes diff --git a/book/src/fuzz.md b/book/src/fuzz.md new file mode 100644 index 0000000..0da88c5 --- /dev/null +++ b/book/src/fuzz.md @@ -0,0 +1,139 @@ +# The dirt with two stages + +Two objects in this library make things dirty and they are not competing. +`tap.overdrive~` is a *feedback* soft-clipper chasing the Tube Screamer +lineage — the nonlinearity sits inside a loop with a lowpass, so the bass +stays clean and the mids break up first. `tap.fuzz~` is the other school: +two clipping stages one after the other, and a tone section that scoops the +middle out. It is the OK Computer-era sound — the dirt on *Paranoid Android* +and *My Iron Lung* — and it belongs in this part of the book because, like +the tape echo and the stutter, the interesting settings are the ones you +arrive at by moving something. + +The method is not invented here. It is the **simplified cascade** of Yeh, +Abel and Smith's DAFx-07 paper on distortion and overdrive pedals: +conditioning filter → memoryless nonlinearity → equalization filter, twice. +That paper also supplies the licence for the central shortcut. A real diode +limiter is not a static curve at all — it is a lowpass whose pole moves with +the voltage across it, and solving that honestly is expensive. Approximating +it as a fixed curve between fixed filters is defended there, and measured +against real pedals. + +What this object is *not* is a model of a specific pedal. No resistor, +capacitor or corner frequency in it is claimed as measured from a unit, and +the control names follow the layout that class of pedal conventionally +carries rather than asserting what any particular one does. + +Companion material: the executed notebook `fuzz.ipynb`, and the +`radiohead_render` scenarios `fuzz_gain_sweep`, `fuzz_tone` and +`fuzz_edge_and_bite`. + +## One curve, two knees + +Both stages share a single clipping family — `tanh(kx)/tanh(k)` — normalized +so that full scale in is full scale out at *every* knee. That normalization +is what lets the knee be a character control instead of a hidden volume +control. + +![Four clipping curves at knees 0.5, 1.6, 2.0 and 12, all passing through the same full-scale point, the sharpest approaching a hard corner](images/fuzz/curve.svg) + +*The knee sharpens the corner without moving the ceiling.* + +The first stage takes a soft knee and most of the gain (the op-amp-ish +stage); the second takes a harder one at unity (the shunt limiter). `edge` +sweeps the second stage's knee from a gentle limiter toward something close +to a hard corner. + +## `gain` — and why the floor is below unity + +The knob sweeps the first stage's drive. Its floor sits *below* unity +deliberately, and the reason is the most useful thing in this chapter if you +ever build a cascade of your own. + +The tanh family's small-signal gain is `k/tanh(k)` — greater than one, and +growing with the knee. Put a fixed ×2.2 in front of a knee-3 curve and the +second stage sees an effective ×6.6, which means it is fully clipped before +the gain knob leaves zero. That is exactly what the first version of this +kernel did. It sounded like a distortion at every setting, which is precisely +why listening did not catch it and a measurement did. + +![Two panels: harmonic content rising steeply with the gain knob, and even-to-odd harmonic ratio rising with asymmetry](images/fuzz/gain-and-bite.svg) + +*Left: the gain knob after retuning — harmonic content sweeps 0.010 to 0.358. Right: `asymmetry` is what makes even harmonics.* + +## `asymmetry` — the even harmonics + +A symmetric curve is an odd function, so it can only make odd harmonics. +DAFx-07 points out that a real op-amp stage clips lopsided, and that this is +where a pedal's even-order content comes from — which is the whole reason +this control exists. Turn it up and the even/odd ratio climbs from +essentially zero to about 0.55. + +It costs no DC. The bias is applied inside the curve and corrected at the +stage output, so however lopsided the setting, silence in is *exactly* +silence out — no pedestal, no thump when you stop playing. + +## `bass`, `treble`, `contrast` — the voicing + +Three linear filters entirely outside the nonlinearity: a low shelf, a high +shelf, and a mid scoop whose depth is `contrast`. On this class of pedal the +voicing section is most of the identity — the scoop is the sound people mean +when they describe it — so it is a first-class part of the object rather +than an afterthought bolted on at the end. + +## `oversample` — where 2 beats 8 + +A static curve makes harmonics without limit, so anything above Nyquist folds +back. The clipper pair therefore runs oversampled. Two things about the +setting are worth knowing, and both are measurements rather than opinions. + +First, the anti-alias filter here is **8th order**, where the rest of the +house uses 4th. Measured in this kernel the 4th-order pair is not steep +enough — alias energy at 4× came out worse than at 2×. + +Second, and more surprising: **bigger is not better**. Fold energy measures +1.2e-1 / 2.7e-5 / 7.4e-4 / 1.8e-3 at 1× / 2× / 4× / 8×. Every factor is worth +having over none — 2× alone is four orders of magnitude — but the sequence is +not monotone, and 2× wins. That is why the default is 2 rather than the +largest available number. The cause is genuinely open: the obvious suspect +(filters going ill-conditioned at the very low normalized cutoffs a high +factor needs) was tested and ruled out, and the untested candidate is +imaging from the zero-stuff upsampler intermodulating in the clipper. The +appendix says more. + +Use a higher factor if a specific patch measures better there. Do not assume +it will. + +## Recipes + +- **Edge of breakup:** `@gain 0.3 @edge 0.2 @contrast 0. @bass 0.`. Barely + dirty; a boost with attitude. +- **The scoop:** `@gain 0.8 @edge 0.6 @contrast 1. @bass 0.4 @treble 0.2`. + The sound the control is named for. +- **Lopsided and mean:** `@gain 0.9 @edge 1. @asymmetry 0.7 @oversample 8`. + Hard knee plus even harmonics; the one setting where a bigger oversample + factor is worth auditioning. +- **Into the echo:** `tap.fuzz~` → `tap.tapecho~` with the echo's `@drive` + low. Two saturators in series get muddy fast; let the pedal be the dirt and + the tape be the space. + +## When it is not the right tool + +- **Amp-like breakup.** `tap.overdrive~` keeps the bass clean by design; this + object does not, and hard settings will get woolly on a bass-heavy source. +- **Subtle warmth.** Two stages is a lot of stages. At low gain this is a + clean boost with a tone stack, which is fine, but `tap.overdrive~` is the + better instrument for gentle. +- **A specific pedal.** This is that pedal's *class*. If you need a named + unit, this is not it and does not pretend to be. + +## Checkpoint + +One clipping family with a knee control, cascaded twice, into a voicing +section that scoops the middle. The gain knob's floor is below unity because +small-signal gain compounds through a cascade — a lesson that cost this +kernel one wrong first draft. `asymmetry` is the even-harmonic control and +costs no DC. And the oversample setting is a measurement, not a +bigger-is-better dial: 2× is the default because 2× wins. Every number here +lives twice, as a cell in `fuzz.ipynb` and as a pinned scenario in +`tests/fuzz_test.cpp`. diff --git a/book/src/images/fuzz/curve.svg b/book/src/images/fuzz/curve.svg new file mode 100644 index 0000000..cc3cbe0 --- /dev/null +++ b/book/src/images/fuzz/curve.svg @@ -0,0 +1,510 @@ + + + + + + + + 2026-08-16T17:41:10.700376 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + −3 + + + + + + + + + + + + + −2 + + + + + + + + + + + + + −1 + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 1 + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 3 + + + + + + + + + + + + + 4 + + + + input + + + + + + + + + + + + + + + + + −1.5 + + + + + + + + + + + + + −1.0 + + + + + + + + + + + + + −0.5 + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.5 + + + + + + + + + + + + + 1.0 + + + + + + + + + + + + + 1.5 + + + + output + + + + + + + + + + + + + + + + + + + + + + + + + 0.5 + + + 1.6 — first stage + + + 2.0 — second stage, edge 0 + + + 12 — edge 1 + + + one curve, tanh(kx)/tanh(k): full scale in is full scale out at every knee + + + + + + + + + diff --git a/book/src/images/fuzz/gain-and-bite.svg b/book/src/images/fuzz/gain-and-bite.svg new file mode 100644 index 0000000..0acaf3c --- /dev/null +++ b/book/src/images/fuzz/gain-and-bite.svg @@ -0,0 +1,481 @@ + + + + + + + + 2026-08-16T17:41:11.477172 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.4 + + + + + + + + + + + + + 0.6 + + + + + + + + + + + + + 0.8 + + + + + + + + + + + + + 1.0 + + + + gain + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.1 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.3 + + + + harmonics / fundamental + + + + + + + + + + + + + + + + + + + + + + + + + + + + + the gain knob + + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.4 + + + + + + + + + + + + + 0.6 + + + + + + + + + + + + + 0.8 + + + + + + + + + + + + + 1.0 + + + + asymmetry + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.4 + + + + even / odd energy + + + + + + + + + + + + + + + + + + + + + + + + + + + + + asymmetry buys the even harmonics + + + + + + + + + + + + diff --git a/book/src/images/stammer/material.svg b/book/src/images/stammer/material.svg index 3eb5c74..6299db1 100644 --- a/book/src/images/stammer/material.svg +++ b/book/src/images/stammer/material.svg @@ -6,7 +6,7 @@ - 2026-08-16T02:37:59.767584 + 2026-08-16T17:41:10.603648 image/svg+xml @@ -43,7 +43,7 @@ L 445.460139 137.222437 L 445.460139 100.262437 L 86.745859 100.262437 z -" clip-path="url(#p6e9eb2fc8d)" style="fill: #b8890f"/> +" clip-path="url(#p83c7c86ba6)" style="fill: #b8890f"/> +" clip-path="url(#p83c7c86ba6)" style="fill: #4269d0"/> +" clip-path="url(#p83c7c86ba6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - - + @@ -78,11 +78,11 @@ L 0 3.5 +" clip-path="url(#p83c7c86ba6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -93,11 +93,11 @@ L 158.488717 20.798437 +" clip-path="url(#p83c7c86ba6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -108,11 +108,11 @@ L 230.231574 20.798437 +" clip-path="url(#p83c7c86ba6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -123,11 +123,11 @@ L 301.974431 20.798437 +" clip-path="url(#p83c7c86ba6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -138,11 +138,11 @@ L 373.717288 20.798437 +" clip-path="url(#p83c7c86ba6)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -157,12 +157,12 @@ L 445.460145 20.798437 - - + @@ -172,7 +172,7 @@ L -3.5 0 - + @@ -202,7 +202,7 @@ L 488.505859 142.766437 - + diff --git a/book/src/images/stammer/occupancy.svg b/book/src/images/stammer/occupancy.svg index 28906e9..23cbf66 100644 --- a/book/src/images/stammer/occupancy.svg +++ b/book/src/images/stammer/occupancy.svg @@ -6,7 +6,7 @@ - 2026-08-16T02:37:59.682231 + 2026-08-16T17:41:10.368997 image/svg+xml @@ -43,247 +43,247 @@ L 114.117158 131.350437 L 117.559619 131.350437 L 117.559619 158.390437 z -" clip-path="url(#pd02b5baabf)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #4269d0"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #b8890f"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #ff725c"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: #1a1a1a"/> +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - - + @@ -1126,11 +1126,11 @@ L 0 3.5 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1141,11 +1141,11 @@ L 164.624129 20.798437 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1156,11 +1156,11 @@ L 222.018415 20.798437 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1171,11 +1171,11 @@ L 279.412701 20.798437 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1186,11 +1186,11 @@ L 336.806987 20.798437 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1201,11 +1201,11 @@ L 394.201272 20.798437 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1216,11 +1216,11 @@ L 451.595558 20.798437 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1236,16 +1236,16 @@ L 508.989844 20.798437 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - - + @@ -1256,11 +1256,11 @@ L -3.5 0 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1271,11 +1271,11 @@ L 508.989844 110.203771 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1286,11 +1286,11 @@ L 508.989844 75.537104 +" clip-path="url(#pba88e94576)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -1326,7 +1326,7 @@ L 508.989844 164.942437 - + diff --git a/book/src/images/tapecho/head-layout.svg b/book/src/images/tapecho/head-layout.svg index 9933a32..29bbed0 100644 --- a/book/src/images/tapecho/head-layout.svg +++ b/book/src/images/tapecho/head-layout.svg @@ -6,7 +6,7 @@ - 2026-08-16T02:37:50.240937 + 2026-08-16T17:40:56.877875 image/svg+xml @@ -42,16 +42,16 @@ z +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - - + @@ -62,11 +62,11 @@ L 0 3.5 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -77,11 +77,11 @@ L 127.478914 20.798438 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -92,11 +92,11 @@ L 193.888041 20.798438 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -107,11 +107,11 @@ L 260.297168 20.798438 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -122,11 +122,11 @@ L 326.706295 20.798438 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -142,16 +142,16 @@ L 393.115422 20.798438 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - - + @@ -162,11 +162,11 @@ L -3.5 0 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -177,11 +177,11 @@ L 444.567969 117.460256 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -192,11 +192,11 @@ L 444.567969 81.822074 +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -223,27 +223,27 @@ L 326.706295 27.098438 L 326.803142 153.098438 L 426.306151 153.098438 L 426.306151 153.098438 -" clip-path="url(#pe1bf552d8d)" style="fill: none; stroke: #4269d0; stroke-linecap: square"/> +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke: #4269d0; stroke-linecap: square"/> +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #666666; stroke-width: 0.8"/> +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #666666; stroke-width: 0.8"/> +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #666666; stroke-width: 0.8"/> +" clip-path="url(#p3c30aa07dd)" style="fill: none; stroke-dasharray: 0.8,1.32; stroke-dashoffset: 0; stroke: #666666; stroke-width: 0.8"/> + diff --git a/book/src/images/tapecho/self-oscillation.svg b/book/src/images/tapecho/self-oscillation.svg index 4d760f8..1fb32be 100644 --- a/book/src/images/tapecho/self-oscillation.svg +++ b/book/src/images/tapecho/self-oscillation.svg @@ -6,7 +6,7 @@ - 2026-08-16T02:37:51.028607 + 2026-08-16T17:40:58.592303 image/svg+xml @@ -42,16 +42,16 @@ z +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - - + @@ -62,11 +62,11 @@ L 0 3.5 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -77,11 +77,11 @@ L 104.081076 20.798437 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -92,11 +92,11 @@ L 157.792306 20.798437 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -107,11 +107,11 @@ L 211.503535 20.798437 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -122,11 +122,11 @@ L 265.214765 20.798437 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -137,11 +137,11 @@ L 318.925995 20.798437 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -152,11 +152,11 @@ L 372.637225 20.798437 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -172,16 +172,16 @@ L 426.348455 20.798437 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - - + @@ -192,11 +192,11 @@ L -3.5 0 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -207,11 +207,11 @@ L 444.610273 142.634336 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -222,11 +222,11 @@ L 444.610273 116.158834 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -237,11 +237,11 @@ L 444.610273 89.683333 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -252,11 +252,11 @@ L 444.610273 63.207831 +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b0b0b0; stroke-opacity: 0.22; stroke-width: 0.5; stroke-linecap: square"/> - + @@ -273,11 +273,11 @@ L 104.081076 98.502196 L 168.534552 137.816311 L 254.472519 159.657485 L 426.348455 177.130425 -" clip-path="url(#p8561675372)" style="fill: none; stroke: #b8890f; stroke-opacity: 0.8; stroke-width: 1.2; stroke-linecap: square"/> +" clip-path="url(#pa5837767c3)" style="fill: none; stroke: #b8890f; stroke-opacity: 0.8; stroke-width: 1.2; stroke-linecap: square"/> - - - - - - - + + + + + + @@ -319,7 +319,7 @@ L 444.610273 192.662437 - + diff --git a/book/src/introduction.md b/book/src/introduction.md index f9f4e40..4789c6d 100644 --- a/book/src/introduction.md +++ b/book/src/introduction.md @@ -35,7 +35,8 @@ The book is organized the way a patch is: (`tap.garden~`), and the components they decompose into. - **Part V — The machines you ride**: the Radiohead family — objects whose point is the performance surface rather than a setting. The multi-head tape - echo (`tap.tapecho~`) and the live buffer-stutter rig (`tap.stammer~`). + echo (`tap.tapecho~`), the live buffer-stutter rig (`tap.stammer~`), and the + two-stage fuzz (`tap.fuzz~`). - **Part VI — The spectral set**: the 24-band vocoder (`tap.vocoder~`), the per-bin spectral gate (`tap.nr~`), and the bin remapper (`tap.spectra~`). - **Part VII — The rhythm section**: the Roland recreations — the TB-303 voice, diff --git a/book/src/machine/fuzz.md b/book/src/machine/fuzz.md new file mode 100644 index 0000000..35429d5 --- /dev/null +++ b/book/src/machine/fuzz.md @@ -0,0 +1,115 @@ +# Two stages and a knee: `fuzz.h` + +This appendix is mostly about two mistakes, because the DSP itself is a +published recipe followed closely and there is little to explain about it +that Yeh, Abel and Smith's DAFx-07 paper does not explain better. What is +worth recording is what went wrong on the way, since both failures are the +kind that recur. + +## The recipe, briefly + +Two `stage` objects, each a conditioning highpass, a gain, a memoryless +curve, and an equalization lowpass — the paper's cascade, twice. A `tone` +section of three RBJ biquads outside the nonlinearity. A `pedal` that runs +the pair inside an oversampled region, DC-blocks, voices, and trims. + +The curve is `shape(x, k) = tanh(kx)/tanh(k)`, chosen from the family the +paper itself compares against a tabulated diode DC curve (tanh, arctan, a +tanh approximation). The normalization matters more than the choice: dividing +by `tanh(k)` fixes the output at full scale for unit input at every knee, so +`edge` changes the shape of the corner without moving the ceiling. + +## Mistake one: small-signal gain compounds + +The tanh family's slope at the origin is `k/tanh(k)`. It is greater than one +and it grows with the knee — 1.7 at knee 1.6, 2.1 at knee 2, 12 at knee 12. + +In one stage that is a curiosity you can absorb into the gain mapping. In a +cascade it multiplies. The first implementation put a fixed ×2.2 in front of +a knee-3 curve, so the second stage's effective small-signal gain was about +6.6, and with the drive floor at +6 dB the limiter was *already saturated +with the gain knob at zero*. The measured harmonic-to-fundamental ratio was +0.401 at gain 0 and 0.408 at gain 1: the knob did essentially nothing. + +The reason this is worth a paragraph is that it is inaudible as a bug. The +object sounded like a distortion pedal at every setting, because it *was* one +at every setting. Only a swept measurement showed the knob was inert. The fix +was to lower the drive floor below unity (−12 dB) and the second stage's +fixed gain to 0.5; the ratio now runs 0.010 → 0.358. + +The general lesson, stated for the next cascade someone builds here: **a +waveshaper's small-signal slope is part of the gain structure**, and if the +curve family's slope depends on a user-facing parameter, that dependence +propagates to every stage downstream of it. + +## Mistake two: the house oversampler, and a hypothesis that died + +The oversampling chain in `tap.ladder~`, `tap.svf~` and `overdrive.h` is +zero-stuff plus a 4th-order Butterworth, cut at 0.45 of the base rate +normalized to the oversampled rate. This file started as a copy of it. + +Measured, that was wrong here: alias energy at the fold frequencies came out +**worse at 4× than at 2×** (1.7e-2 against 2.8e-3). Twenty-four dB per octave +leaves content just above the base Nyquist barely attenuated, and a higher +factor pushes more clipper-generated content into exactly that band before +decimation. Moving to 8th order improved 4× about sixfold. + +It did not fix the ordering, and this is where the appendix has to be careful, +because an earlier draft of this file claimed it did. Measured against a +3733 Hz tone: + +| factor | fold energy | vs. 1× | +|--------|-------------|--------| +| 1× | 1.2e-1 | — | +| 2× | 2.7e-5 | 4618× better | +| 4× | 7.4e-4 | 166× better | +| 8× | 1.8e-3 | 69× better | + +Every factor is worth having. 2× is the best of them, so 2× is the default. + +**The cause is not established, and one hypothesis is dead.** The obvious +suspect was numerical: at 8× the filters are cut at 0.056 normalized, where +biquad poles crowd the unit circle and direct-form sections are known to +misbehave. That was tested — the cascade's impulse response was run out to +400,000 samples at each factor — and it decays cleanly to denormal every +time. Not conditioning. + +The surviving hypothesis, untested, is imaging. Zero-stuffing by N leaves +N−1 images for a single filter to suppress; residual images entering a +*nonlinearity* intermodulate with the signal into products that are not +harmonics of the input, which is precisely what the probe measures, and there +are more of them at higher N. If that is right, the fix is the standard one: +cascaded 2× (halfband/polyphase) resampling rather than one stage at 1/N, so +each step suppresses a single image at a comfortable normalized frequency. +That is the known next move on this file. + +Whether `overdrive.h` is owed the 8th-order change is a separate question. +Different nonlinearity, different gain structure, different spectrum — it +needs its own measurement, not this one's conclusion. + +## Two ways to measure aliasing wrong + +Both were committed before being caught, and both are recorded in +`fuzz_test.cpp` because they are easy to repeat. + +**Choosing a tone that divides the sample rate.** The first alias test used +3 kHz at 48 kHz. Every harmonic of 3 kHz folds back onto another harmonic of +3 kHz, so every alias hides exactly underneath legitimate content and the +probes read nothing at all. The test passed happily while measuring noise. +3733 Hz puts the folds where nothing else lives. + +**Probing too close to the fundamental.** Two of the original probe +frequencies sat a few hundred Hz from a full-scale tone. What they measured +was the window's spectral leakage — around 1e-3, which swamped the aliasing +underneath it. Probes have to be far enough out that leakage from the loudest +component is below the thing being measured. + +## Checkpoint + +A published cascade, followed closely. One curve whose normalization keeps +the knee from becoming a volume control. A gain floor set below unity because +small-signal slope compounds across stages — the bug that sounded fine. An +8th-order oversampling filter because the house 4th-order one measured worse, +and a default of 2× because bigger measured worse still, with the cause +recorded as open and one hypothesis explicitly ruled out rather than left +hanging. From 71d25923e80c8cf966baac9418e24336d67d753d Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 17:44:19 +0000 Subject: [PATCH 12/22] Design tap.ondes~ against the sources The papers describe a different object than the family plan sketched, so this is the design pass they forced, written before any code. The instrument is heterodyne and its oscillators are measured as essentially pure, so the kernel is a clean source into a triode nonlinearity into the intensity-key gain law into a driven resonator -- nearer fuzz.h and garden.h than vco.h. Synthesizing the difference tone directly is a documented simplification of a published model rather than a shortcut, and the header should carry the number that justifies it: the full port-Hamiltonian solve runs at 768 kHz and its plugin eats 85% of a laptop core. The component split differs from the family's recent objects in a way worth planning for: three of the four parts are independently useful. The touche is a measured, published expressive gain curve that would improve almost any object, and the diffuseurs run anything you feed them, so both should be standalone externals from the start rather than seams discovered later. Work is ordered to front-load those: touche first (fully specified, small, shippable alone), then the diffuseurs, then the triode -- which needs a listening comparison to settle whether to use a published grid-conduction curve or the house tanh family -- and the source last. Records what is still unsourced: diffuseur-specific modal data, and the waveform-register filter shapes. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-ondes.md | 143 ++++++++++++++++++++++++++++++++ book/PLAN-radiohead-chapters.md | 12 +-- 2 files changed, 150 insertions(+), 5 deletions(-) create mode 100644 book/PLAN-ondes.md diff --git a/book/PLAN-ondes.md b/book/PLAN-ondes.md new file mode 100644 index 0000000..4c727ed --- /dev/null +++ b/book/PLAN-ondes.md @@ -0,0 +1,143 @@ +# Plan — `tap.ondes~`, after reading the sources + +> **Status: design, not yet implemented.** The source gate is closed — +> `PLAN-radiohead-family.md` §3 records what was found and how far each paper was read. This +> file is the design pass those findings forced, written before any code, because what the +> papers describe is **not the object the family plan sketched**. + +## What changed, in one paragraph + +The family plan assumed an Ondes Martenot voice built on `vco.h`: an oscillator with waveform +registers, switched timbres, the usual synthesis shape. The circuit paper says otherwise. The +instrument is a **heterodyne** design whose oscillators are, measured, essentially pure — about +0.03 % second-harmonic distortion even coupled to the rest of the circuit, which is precisely +the simplification Najnudel et al. use to reach real time. The character comes from what +happens *after* the difference tone: two triode stages, the intensity key, and the diffuseur. +So the kernel is a clean source into a nonlinearity into a gain law into a resonator — much +closer to `fuzz.h` and `garden.h` than to `vco.h`. + +## The shape + +``` +ribbon/keyboard ─▶ heterodyne source ─▶ triode stages ─▶ touche ─▶ diffuseur ─▶ out + (near-sinusoidal) (the timbre) (the gain) (the voice) +``` + +Four components under a thin composition, the family's habit — and unlike the tape echo's +`head` or the stammer's `slicer`, **three of these are independently useful** and should be +standalone externals from the start: + +| Component | What it is | Standalone? | +|-----------|------------|-------------| +| `source` | the heterodyne difference tone, near-sinusoidal | no — it is an oscillator, `tap.vco~` territory if anyone wants one | +| `triode` | the two post-demodulator gain stages, the timbre | maybe — a triode-flavoured saturator has uses beyond this instrument | +| `touche` | the intensity-key gain law | **yes** — a measured, published expressive gain curve is useful on *anything* | +| `palme` / `metallique` | the diffuseurs as driven resonators | **yes** — run a guitar through the Palme; that is the killer feature | + +`touche` and the diffuseurs are the reason to build this object even for someone who never +wants an ondes. That is worth designing for rather than discovering later, per the components +chapter's lesson. + +## `touche` — fully specified, build it first + +The measurement is in `PLAN-radiohead-family.md`; the design consequences: + +- **Input is a position**, normalized 0..1 over the playable travel, not a force and not a + velocity. The paper is explicit that the result does not depend on gesture speed, so a + static curve is the finding, not a shortcut. +- **The curve is the published table, interpolated** — 45.0 / 53.3 / 61.6 / 70.0 / 78.3 / 86.6 + / 95.0 dB_SPL at 4.3 / 5.3 / 5.9 / 6.4 / 6.8 / 7.3 / 8.8 mm. Monotone cubic (PCHIP-style) + through seven points, precomputed at `prepare()` into a table; no fitting, no analytic + approximation, because the shape is the whole point and a straight line in dB-vs-mm is + visibly wrong (the displacement steps are 1.0, 0.6, 0.5, 0.4, 0.5, 1.5 mm for equal dB + steps). +- **50 dB of range** over ~4.5 mm of travel, with the bottom of the table at the noise floor. + Below the first point the object should go to true silence rather than extrapolating. +- Expose the raw millimetre domain too, not just 0..1 — the numbers are published and someone + will want to drive it from a real sensor. +- An optional **force** input as a second mode: dB is linear in log(force) below ~85 dB_SPL / + 1.3 N. Document it as the secondary map; displacement is primary. +- The curve is **pitch-independent** (all notes share the shape), which the tests should pin: + the same `touche` position gives the same gain at any source frequency. + +Honest limit to state in the header: the table is one instrument (No. 320) and the paper notes +variation between units can exceed 10 %. + +## `triode` — where the timbre actually is + +The circuit paper attributes the harmonics to two successive triode stages after the +demodulator, and their plugin exposes demodulator input gain as a harmonics control — a knob +the real instrument does not have, and a good precedent for exposing one here. + +This is `fuzz.h` territory and should reuse its thinking rather than its code: a +conditioning filter, an asymmetric static curve (triodes are strongly asymmetric — even +harmonics are the point), an equalization filter, and oversampling. Two stages, cascaded, with +the gain-staging lesson from `fuzz.h` applied from the start: **the small-signal slope of the +curve family compounds**, so the drive floor must sit low enough that stage two is not +saturated at zero. + +Open question: whether to model the triode with a published grid-conduction curve or to reuse +the tanh family with an asymmetry bias. The former is more honest to the instrument; the +latter is already in the house and measured. Decide with a listening comparison, and document +whichever loses. + +## `source` — cheap, and deliberately so + +A heterodyne pair whose difference tone is the note. Given the measured 0.03 % distortion, the +kernel should synthesize the difference tone **directly** as a sinusoid rather than simulating +two RF oscillators and a demodulator: same output, a fraction of the cost, and the paper is +the citation for why that is legitimate. The ribbon paper is the reference for how the +variable oscillator's frequency responds to the ribbon, which matters for glide feel. + +State plainly in the header that this is a *documented simplification of a published model*, +not a circuit solve — and note the number that justifies it. Najnudel et al.'s full +port-Hamiltonian simulation runs at 768 kHz and their plugin consumes 85 % of a laptop core; +that is the road not taken, and the header should say so, so nobody assumes the simple path +was chosen out of ignorance. + +## The diffuseurs — driven, not struck + +The correction that matters most for reusing `garden.h`'s idiom. Wijnand et al.: + +- **Métallique** (1944–45, patented 1947) — a gong excited by a **motor**. +- **Palme** (1949–50) — an electromagnet driving **12** metal strings on a soundboard. +- **Résonance** (1970s) — motor-excited metal springs. + +So the mode banks carry over from `garden.h` but the excitation does not: these are +continuously driven resonators, not struck ones. No `decay_env` per mode; instead the input +signal drives the bank and the modes ring at their own decay rates — closer to `grm_comb.h`'s +sustained resonance than to the chime's strike envelopes. Mode ratios still come from Fletcher +& Rossing (plates/gongs for the métallique, strings for the palme), because there is no +ondes-specific modal measurement in any of the four sources. + +The transducer is its own stage: early diffuseurs used a **moving-iron loudspeaker** whose +operating principle is *inherently nonlinear* — the Forum Acusticum paper's whole point is that +Thiele–Small does not apply, and it quantifies the nonlinearity on a heritage instrument. A +diffuseur that is only a resonator is missing a documented stage. Whether to model it is a +scope decision; **not** modelling it should be a stated limit rather than an omission. + +Note for the header: hobbyist build pages give the palme 24 strings (two sets of 12). The +peer-reviewed source says 12. Prefer 12 and say why. + +## Order of work + +1. **`touche`** — fully specified, small, independently useful, and it can ship as + `tap.touche~` before the rest of the instrument exists. Do this first. +2. **The diffuseurs** — also independently useful, and the modal machinery is familiar. + `tap.palme~` and `tap.metallique~`. +3. **`triode`** — needs a listening comparison to settle the curve question. +4. **`source`** and the composition — last, because it is the cheapest piece and the one most + constrained by the others. + +That order deliberately front-loads the parts that are useful on their own, so the object +delivers value before the flagship is finished. + +## What is still unsourced + +- Modal data for either diffuseur specific to the instrument — falling back to Fletcher & + Rossing for the general plate/string physics, which is a recreation rather than a model, and + must be labelled as such. +- The waveform-register filter shapes. The circuit paper covers five stages but not the timbre + registers in detail; Leipp (*Bulletin du GAM* n°60, 1972) and Laurendeau's monograph are the + next places to look, neither yet obtained. If they do not settle it, the registers are a + recreation voiced by ear and the header says so. diff --git a/book/PLAN-radiohead-chapters.md b/book/PLAN-radiohead-chapters.md index 23de039..c19ef04 100644 --- a/book/PLAN-radiohead-chapters.md +++ b/book/PLAN-radiohead-chapters.md @@ -4,9 +4,10 @@ > the same day (2026-08-15). This file remains as the drafting record, the plans-directory way. The > object-level plan is `PLAN-radiohead-family.md`; this one covers only the book. -Planning document for the *Tools on Tap* chapters covering the first two Radiohead-family -objects (`tap.tapecho~`, `tap.stammer~`; `taptools/tapecho.h`, `stammer.h`). Four chapters: -two user-facing, two machine appendices. It is not part of the built book. +Planning document for the *Tools on Tap* chapters covering the shipped Radiohead-family +objects (`tap.tapecho~`, `tap.stammer~`, `tap.fuzz~`; `taptools/tapecho.h`, `stammer.h`, +`fuzz.h`). Six chapters: three user-facing, three machine appendices. It is not part of the +built book. Every measured claim below already exists as an executed notebook cell or a pinned test — each section lists its evidence, so the chapters keep the book's "measured, not remembered" @@ -61,8 +62,9 @@ contract, driving the shipping kernels through the C ABI rather than illustratin No hand-authored block diagrams this round. The Eno chapters needed them because their signal flow is a rig with named machines; these two are a tape line with extra read points -and a buffer with dice, and the measured figures carry more than a box diagram would. If a -diagram is ever added, the obvious one is the stammer's grid/slice/repeat timeline. +and a buffer with dice, and the fuzz is a two-box chain; the measured figures carry more than +a block diagram would. If a diagram is ever added, the obvious one is the stammer's +grid/slice/repeat timeline. One thing the generator learned the hard way, recorded so it is not re-learned: the occupancy figure's first draft used `fill_between` over a per-sample boolean at 48 kHz and From c4e2622e4191b9d4d66c2dbbdba0a84f9f7809c4 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 16 Aug 2026 20:24:04 +0000 Subject: [PATCH 13/22] Add the Ondes intensity key: tap.touche~ The first piece of the Ondes Martenot, and the one that is useful on its own: the touche d'intensite as a gain law. The curve is not modelled or fitted -- it is Quartier et al.'s published measurement (Acta Acustica 101(2), 2015, Table II), interpolated with monotone cubic segments through all seven points. 50 dB over 4.5 mm, referenced to 0 dB at full press, and the seven points come back to within 6e-5 dB. Monotone cubic rather than a spline because an overshoot here is a non-monotone gain -- audible as a dip while pressing harder. And interpolation rather than a fit because the shape is the whole point: equal dB steps correspond to displacement steps of 1.0, 0.6, 0.5, 0.4, 0.5, 1.5 mm, so a straight line in dB-against-mm departs by 8.3 dB and throws away the property that makes the key expressive. Two things the tests caught. The normalized domain has to be the physical travel, not the measured band: mapping 0..1 onto 4.3-8.8 mm put position 0 exactly on the first published point while returning silence there. The paper puts gestures at roughly 3-9.5 mm with the measured band inside, so position spans 9.5 mm and the bottom 45% is genuinely silent -- the key bending before it reaches the powder bag. And the dead zone belongs in the lookup rather than the table, because zeroing entries below the floor put a cliff next to it and a query landing on the floor read 4.2 dB low. Eleven Catch2 scenarios, the C ABI plus ctypes surface, the executed notebook, and a render putting the curve against a linear fade and a fade linear in dB -- it is audibly neither. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-ondes.md | 25 +- include/taptools/taptools.h | 1 + include/taptools/touche.h | 377 ++++++++++++++++++++++++++++++ notebooks/taptools_py.py | 77 +++++- notebooks/touche.ipynb | 376 +++++++++++++++++++++++++++++ tests/CMakeLists.txt | 1 + tests/touche_test.cpp | 223 ++++++++++++++++++ tools/capi/taptools_capi.cpp | 64 +++++ tools/capi/taptools_capi.h | 20 ++ tools/render/radiohead_render.cpp | 54 ++++- 10 files changed, 1213 insertions(+), 5 deletions(-) create mode 100644 include/taptools/touche.h create mode 100644 notebooks/touche.ipynb create mode 100644 tests/touche_test.cpp diff --git a/book/PLAN-ondes.md b/book/PLAN-ondes.md index 4c727ed..a244084 100644 --- a/book/PLAN-ondes.md +++ b/book/PLAN-ondes.md @@ -1,6 +1,7 @@ # Plan — `tap.ondes~`, after reading the sources -> **Status: design, not yet implemented.** The source gate is closed — +> **Status: in progress — `touche` shipped 2026-08-15 as `tap.touche~` (kernel side); the rest +> is design.** The source gate is closed — > `PLAN-radiohead-family.md` §3 records what was found and how far each paper was read. This > file is the design pass those findings forced, written before any code, because what the > papers describe is **not the object the family plan sketched**. @@ -38,7 +39,27 @@ standalone externals from the start: wants an ondes. That is worth designing for rather than discovering later, per the components chapter's lesson. -## `touche` — fully specified, build it first +## `touche` — ✅ shipped + +> **Shipped 2026-08-15**: `include/taptools/touche.h`, `tests/touche_test.cpp` (11 scenarios), +> the C ABI + ctypes surface (`Touche`), the executed `notebooks/touche.ipynb`, and a +> `radiohead_render` scenario putting the curve against the two laws you would otherwise reach +> for. The seven published points come back to within 6e-5 dB. +> +> Two implementation notes worth carrying. **The normalized domain is the physical travel, not +> the measured band** — an early cut mapped 0..1 onto 4.3–8.8 mm, which put position 0 exactly +> on the first published point *and* returned silence there, contradicting the measurement. The +> paper puts playable gestures at roughly 3–9.5 mm with the measured band inside, so position +> now spans 9.5 mm and the bottom 45 % is genuinely silent (the key's first phase is bending +> before it reaches the powder bag). **And the dead zone belongs in the lookup, not the table**: +> zeroing dense-table entries below the floor put a cliff next to it, so a query landing on the +> floor lerped toward zero and read 4.2 dB low. Both were caught by the reproduce-the-table +> test, which is exactly what that test is for. +> +> Still to come for this piece: the Max vertical slice and a chapter (probably folded into an +> Ondes-family chapter once more of the instrument exists, rather than one chapter per part). + +## The design (as written before implementation) The measurement is in `PLAN-radiohead-family.md`; the design consequences: diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index 8448b60..d6545e1 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -37,6 +37,7 @@ #include "tr808_kick.h" #include "tr808_rim.h" #include "tr808_snare.h" +#include "touche.h" #include "tr808_tom.h" #include "vca.h" #include "vco.h" diff --git a/include/taptools/touche.h b/include/taptools/touche.h new file mode 100644 index 0000000..354c989 --- /dev/null +++ b/include/taptools/touche.h @@ -0,0 +1,377 @@ +/// @file +/// @brief Portable Ondes Martenot intensity-key gain law for tap.touche~ — no Max/Min +/// dependency. +/// @details The first piece of the Ondes Martenot to land (book/PLAN-ondes.md), and the one +/// that is useful on its own: the *touche d'intensité*, the pressure key Maurice +/// Martenot's left hand rides, reduced to what it actually is — a measured, +/// published, expressive gain curve. Olivier Messiaen called it the instrument's +/// greatest invention. It is a graphite/mica powder bag working as a rheostat (the +/// carbon-microphone principle: compress it and the number of conducting bead paths +/// rises, so resistance falls), and what the player feels is a well-chosen nonlinear +/// spring. +/// +/// **The curve is not modelled or fitted — it is the published measurement.** +/// Quartier, Meurisse, Colmars, Frelat & Vaiedelich, "Intensity Key of the Ondes +/// Martenot: An Early Mechanical Haptic Device", *Acta Acustica united with +/// Acustica* 101(2), 421–428, 2015 (doi:10.3813/AAA.918837) measured finger force, +/// key displacement and the resulting sound simultaneously on instrument No. 320, +/// and reports the boundaries of the six musical nuances over the key's travel. +/// Those seven points are `k_table_*` below, and this kernel interpolates them. +/// +/// Three findings from that paper drive the design, and each is a decision this file +/// did not get to make: +/// +/// - **The input is a position, not a force and not a velocity.** The paper states +/// that the change in sound intensity depends on the key's displacement (and on +/// the force that displacement implies), and explicitly that it does *not* depend +/// on the speed of the gesture. A static, memoryless map is therefore the finding +/// rather than a simplification. Force is offered as a secondary input because the +/// same table has a force column, not because it is the primary story. +/// - **50 dB over about 4.5 mm.** From 4.3 mm (the instrument's noise floor, 45 +/// dB_SPL) to 8.8 mm (95 dB_SPL). For comparison the paper cites most traditional +/// instruments as rarely exceeding 25 dB of per-note dynamic range. +/// - **The shape is not a line.** Equal 8.3 dB steps correspond to displacement +/// steps of 1.0, 0.6, 0.5, 0.4, 0.5 and 1.5 mm — the curve steepens through the +/// middle and flattens hard at the top. Fitting a straight line in dB-against-mm +/// would throw away the entire reason the key is expressive, so the kernel +/// interpolates the table with monotone cubic (Fritsch–Carlson PCHIP) segments, +/// which pass through every measured point and cannot overshoot between them. +/// +/// Interpolation is precomputed into a dense table at construction, so `process()` +/// is a lookup and a lerp. Nothing here depends on the sample rate except the +/// anti-zipper ramp. +/// +/// Honest limits: +/// - **One instrument.** The measurements are of ondes No. 320, and the paper notes +/// that weight and thickness of the key vary by more than 10 % between instruments. +/// This is that instrument's curve, not a universal constant. +/// - **Pressing only.** The paper says the released-key case was not investigated, +/// so the same curve is used in both directions here. That is an assumption, and +/// it is this file's, not the paper's. +/// - **The dB values are relative, not absolute.** The published numbers are dB_SPL +/// at one metre through that instrument's own amplifier and speaker; the constant +/// 92 dB offset the paper reports between its electrical and acoustic scales is +/// rig-specific. What is used here is the *shape*, normalized so full press is +/// 0 dB. No absolute level is claimed. +/// - **Below the first point is silence, not extrapolation.** 4.3 mm is where the +/// instrument sits at its own noise floor, so the kernel outputs exact zero below +/// it rather than inventing curve outside the measured domain. Above 8.8 mm it +/// clamps at unity for the same reason. Note the consequence for a 0..1 control: +/// normalized position spans the *physical* 9.5 mm travel the paper describes, so +/// roughly the first 45 % of the throw is silent. That dead zone is the key's own +/// first phase — pure bending of the elastic strip before it reaches the powder +/// bag — not a modelling choice, and it is why the instrument can be played with +/// such sharp attacks: the useful 50 dB lives in 4.5 mm right after it. +/// - The force map covers the same seven points; the paper's observation that dB +/// rises linearly with log(force) holds below about 85 dB_SPL and 1.3 N, and above +/// that the force required climbs steeply (9.6 N at full press — past where a +/// player would stay for long). +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include + +namespace tap::tools { + namespace touche { + + constexpr double k_default_smooth_ms = 20.0; + constexpr int k_points = 7; // the published nuance boundaries + constexpr int k_table_size = 1025; // dense lookup resolution (~4.4 um per step) + + /// The measurement, verbatim: Quartier et al. 2015, Table II — mean displacement and + /// mean finger force at the boundaries of six musical nuances equally distributed over + /// the instrument's 50 dB dynamic range (means over notes C3a..C3h). + constexpr std::array k_table_db = {45.0, 53.3, 61.6, 70.0, 78.3, 86.6, 95.0}; + constexpr std::array k_table_mm = {4.3, 5.3, 5.9, 6.4, 6.8, 7.3, 8.8}; + constexpr std::array k_table_n = {0.39, 0.47, 0.52, 0.62, 0.82, 1.34, 9.60}; + + constexpr double k_min_mm = 4.3; // the noise floor: below this the instrument is silent + constexpr double k_max_mm = 8.8; // full press + constexpr double k_min_n = 0.39; + constexpr double k_max_n = 9.60; + + // The *physical* travel the player moves through, which is wider than the measured band. + // Quartier et al.: "all instrumental gestures take place in a displacement of only a few + // millimetres (about between 3mm and 9.5mm)", and the key's first phase is pure bending + // of the elastic strip before it even contacts the powder bag. So the bottom of the + // travel is genuinely silent — normalized position spans the travel, not the measured + // sub-range, and the dead zone below k_min_mm is the instrument's, not an invention. + constexpr double k_travel_mm = 9.5; + constexpr double k_travel_n = 9.60; // the force axis bottoms at zero for the same reason + constexpr double k_range_db = 50.0; // k_table_db.back() - k_table_db.front() + + /// Which measured column drives the gain. + enum input_mode : int { + mode_displacement = 0, // millimetres of key travel — the primary map + mode_force = 1 // newtons of finger force — the same table's other column + }; + + /// Monotone cubic (Fritsch–Carlson PCHIP) through the published points. Chosen over a + /// natural spline because it passes through every measurement *and* cannot overshoot + /// between them — an overshoot here would be a non-monotone gain curve, which is + /// audible as a dip while pressing harder. + class pchip { + public: + void build(const std::array& x, const std::array& y) { + m_x = x; + m_y = y; + + std::array h{}, delta{}; + for (int i = 0; i < k_points - 1; ++i) { + h[static_cast(i)] = x[static_cast(i + 1)] - x[static_cast(i)]; + delta[static_cast(i)] = + (y[static_cast(i + 1)] - y[static_cast(i)]) / h[static_cast(i)]; + } + + // Interior slopes: weighted harmonic mean, zeroed at any sign change so the + // interpolant stays monotone (Fritsch & Carlson, SIAM J. Numer. Anal. 17, 1980). + for (int i = 1; i < k_points - 1; ++i) { + const double d0 = delta[static_cast(i - 1)]; + const double d1 = delta[static_cast(i)]; + if (d0 * d1 <= 0.0) { + m_m[static_cast(i)] = 0.0; + } + else { + const double w1 = 2.0 * h[static_cast(i)] + h[static_cast(i - 1)]; + const double w2 = h[static_cast(i)] + 2.0 * h[static_cast(i - 1)]; + m_m[static_cast(i)] = (w1 + w2) / (w1 / d0 + w2 / d1); + } + } + m_m[0] = end_slope(h[0], h[1], delta[0], delta[1]); + m_m[k_points - 1] = + end_slope(h[k_points - 2], h[k_points - 3], delta[k_points - 2], delta[k_points - 3]); + } + + /// Evaluate at t, clamped to the measured domain (callers handle out-of-range policy). + double at(double t) const { + const double lo = m_x[0]; + const double hi = m_x[k_points - 1]; + if (t <= lo) { + return m_y[0]; + } + if (t >= hi) { + return m_y[k_points - 1]; + } + int i = 0; + while (i < k_points - 2 && t >= m_x[static_cast(i + 1)]) { + ++i; + } + const double h = m_x[static_cast(i + 1)] - m_x[static_cast(i)]; + const double s = (t - m_x[static_cast(i)]) / h; + const double s2 = s * s; + const double s3 = s2 * s; + // Cubic Hermite basis. + const double h00 = 2.0 * s3 - 3.0 * s2 + 1.0; + const double h10 = s3 - 2.0 * s2 + s; + const double h01 = -2.0 * s3 + 3.0 * s2; + const double h11 = s3 - s2; + return h00 * m_y[static_cast(i)] + h10 * h * m_m[static_cast(i)] + + h01 * m_y[static_cast(i + 1)] + h11 * h * m_m[static_cast(i + 1)]; + } + + private: + /// One-sided three-point end slope, limited so the end segment stays monotone. + static double end_slope(double h0, double h1, double d0, double d1) { + double m = ((2.0 * h0 + h1) * d0 - h0 * d1) / (h0 + h1); + if (m * d0 <= 0.0) { + m = 0.0; + } + else if (d0 * d1 <= 0.0 && std::abs(m) > std::abs(3.0 * d0)) { + m = 3.0 * d0; + } + return m; + } + + std::array m_x{}, m_y{}, m_m{}; + }; + + /// Per-sample linear parameter ramp — the anti-zipper unit, the delay.h shape. + class ramp { + public: + void snap(double v) { + m_current = m_target = v; + m_inc = 0.0; + m_remaining = 0; + } + void to(double tgt, long n) { + if (n < 1 || tgt == m_current) { + snap(tgt); + } + else { + m_target = tgt; + m_inc = (tgt - m_current) / static_cast(n); + m_remaining = n; + } + } + double tick() { + if (m_remaining > 0) { + m_current += m_inc; + if (--m_remaining == 0) { + m_current = m_target; + } + } + return m_current; + } + double current() const { return m_current; } + double target() const { return m_target; } + + private: + double m_current{0.0}, m_target{0.0}, m_inc{0.0}; + long m_remaining{0}; + }; + + /// The intensity key: a position in, a gain out, and an input scaled by it. + class key { + public: + key() { + m_disp.build(k_table_mm, k_table_db); + m_force.build(k_table_n, k_table_db); + rebuild(); + m_position.snap(0.0); + } + + // -- lifecycle ----------------------------------------------------------------------- + + /// Only the anti-zipper ramp depends on the sample rate; the curve does not. + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_position.snap(m_position.target()); + } + + /// Return the key to rest (silent). + void clear() { m_position.snap(0.0); } + + // -- parameters ---------------------------------------------------------------------- + + /// Key travel as 0..1 over the *physical* range (0 to 9.5 mm), slewed. The measured + /// band sits inside it: everything below 4.3 mm is silent, because that is where the + /// key is still bending before it compresses the powder bag. Expect roughly the + /// first 45 % of the throw to do nothing — that dead zone is the instrument's. + void set_position(double p) { m_position.to(std::clamp(p, 0.0, 1.0), smooth_samples()); } + + /// The same control in the published unit, millimetres of key travel. + void set_position_mm(double mm) { set_position(mm / k_travel_mm); } + + /// Finger force in newtons, for `mode_force`. Below k_min_n is silence. + void set_force_n(double n) { set_position(n / k_travel_n); } + + /// Which measured column the position drives. Changing it rebuilds the dense table; + /// not real-time-safe. + void set_mode(int mode) { + const int v = (mode == mode_force) ? mode_force : mode_displacement; + if (v != m_mode) { + m_mode = v; + rebuild(); + } + } + + /// Anti-zipper ramp time in ms (0 = instant). + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + double position() const { return m_position.target(); } + double position_mm() const { return m_position.target() * k_travel_mm; } + int mode() const { return m_mode; } + double smooth_ms() const { return m_smooth_ms; } + double samplerate() const { return m_sr; } + + /// The linear gain the key is currently applying (after the ramp). + double gain() const { return lookup(m_position.current()); } + + /// The curve itself, for plotting and for callers who want the law without the VCA: + /// linear gain at a normalized position, 0 dB at full press. + double gain_at(double p) const { return lookup(std::clamp(p, 0.0, 1.0)); } + + /// The curve in dB relative to full press (-inf at rest). + double db_at(double p) const { + const double g = gain_at(p); + return (g > 0.0) ? 20.0 * std::log10(g) : -std::numeric_limits::infinity(); + } + + // -- audio --------------------------------------------------------------------------- + + /// Message-rate position: the slewed target drives the gain. + double process(double in) { return in * lookup(m_position.tick()); } + + /// Signal-rate position override (a pedal, a sensor, a control signal). Snaps the + /// ramp so a later message-rate move continues from here without a jump. + double process(double in, double position) { + m_position.snap(std::clamp(position, 0.0, 1.0)); + return in * lookup(m_position.current()); + } + + void process(const double* in, double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(in[i]); + } + } + + private: + /// Fill the dense linear-gain table from whichever measured column is selected. The + /// published dB values are referenced to full press, so the top of the curve is + /// exactly unity and the bottom is exactly -50 dB. + /// The dense table spans the *measured band only* — 4.3..8.8 mm, or 0.39..9.60 N — + /// so entry 0 is exactly the first published point. The silent dead zone below the + /// band is handled in lookup() rather than by zeroing entries here: a hard zero + /// adjacent to the floor puts a cliff in the table, and a query landing on the floor + /// then lerps toward it and reads several dB low. (Measured: -54.2 dB instead of the + /// published -50.0 at the first force point. Caught by the reproduce-the-table test, + /// which is exactly what that test is for.) + void rebuild() { + const bool force = (m_mode == mode_force); + const pchip& curve = force ? m_force : m_disp; + const double lo = force ? k_min_n : k_min_mm; + const double hi = force ? k_max_n : k_max_mm; + // Band edges cached in the *normalized* domain, so a caller who converts + // millimetres the same way this does lands exactly on the edge rather than a + // rounding error below it. + m_floor_p = lo / (force ? k_travel_n : k_travel_mm); + m_top_p = hi / (force ? k_travel_n : k_travel_mm); + for (int i = 0; i < k_table_size; ++i) { + const double q = static_cast(i) / (k_table_size - 1); + const double db = curve.at(lo + q * (hi - lo)) - k_table_db[k_points - 1]; + m_gain[static_cast(i)] = std::pow(10.0, db / 20.0); + } + } + + /// Position (0..1 of the physical travel) to linear gain. Below the measured floor + /// the answer is exact zero — that region is real travel the instrument spends + /// silent, and extrapolating curve into it would be inventing data. Inside the band + /// it is a dense-table lookup with a linear step between entries. + double lookup(double p) const { + const double q = std::clamp(p, 0.0, 1.0); + // Strictly below the floor is silence; *at* the floor is the first published + // point (-50 dB), not zero — 4.3 mm is a measurement, not the edge of nothing. + if (q < m_floor_p) { + return 0.0; + } + if (q >= m_top_p) { + return m_gain[k_table_size - 1]; + } + const double t = (q - m_floor_p) / (m_top_p - m_floor_p) * (k_table_size - 1); + const double f = std::floor(t); + const int i = static_cast(f); + const double a = t - f; + return m_gain[static_cast(i)] * (1.0 - a) + m_gain[static_cast(i + 1)] * a; + } + + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double m_sr{48000.0}; + double m_smooth_ms{k_default_smooth_ms}; + int m_mode{mode_displacement}; + pchip m_disp, m_force; + std::array m_gain{}; + double m_floor_p{0.0}, m_top_p{1.0}; + ramp m_position; + }; + + } // namespace touche +} // namespace tap::tools diff --git a/notebooks/taptools_py.py b/notebooks/taptools_py.py index e6fc746..d046b63 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -17,7 +17,8 @@ tap.delay~ (`Delay`), tap.multitap~ (`Multitap`), the Discreet Music two-machine tape loop tap.discreet~ (`Discreet`), the multi-head tape echo tap.tapecho~ (`TapEcho`), the live buffer-stutter rig tap.stammer~ -(`Stammer`), the two-stage fuzz tap.fuzz~ (`Fuzz`), the Music for Airports +(`Stammer`), the two-stage fuzz tap.fuzz~ (`Fuzz`), the Ondes Martenot intensity +key tap.touche~ (`Touche`), the Music for Airports incommensurate loop bank tap.airport~ (`Airport`), the generative event loop tap.garden~ (`Garden`), and tap.tune~'s pitch corrector (`Tune`, with the shared DspTap detector passed through as `Yin` for the notebooks' @@ -305,6 +306,19 @@ def load() -> ctypes.CDLL: "taptools_tapecho_clear": ([vp], ctypes.c_int), "taptools_tapecho_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_touche_create": ([], vp), + "taptools_touche_destroy": ([vp], None), + "taptools_touche_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_touche_set_position": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_touche_set_position_mm": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_touche_set_force_n": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_touche_set_mode": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_touche_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_touche_clear": ([vp], ctypes.c_int), + "taptools_touche_gain_at": ([vp, ctypes.c_double], ctypes.c_double), + "taptools_touche_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_touche_process_mod": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_fuzz_create": ([], vp), "taptools_fuzz_destroy": ([vp], None), "taptools_fuzz_prepare": ([vp, ctypes.c_double], ctypes.c_int), @@ -1374,6 +1388,67 @@ def __del__(self): self._h = None +class Touche: + """tap.touche~'s kernel (tap::tools::touche::key): the Ondes Martenot + intensity key as a gain law. The curve is not modelled — it is Quartier + et al.'s published measurement (Acta Acustica 101(2), 2015, Table II), + interpolated with monotone cubic segments through all seven points: 50 dB + over 4.5 mm of the key's travel, referenced to 0 dB at full press. + `position` spans the physical 9.5 mm throw, so the bottom ~45% is silent + — that dead zone is the key bending before it reaches the powder bag. + `mode` 0 drives from displacement (primary), 1 from finger force.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_touche_create() + _check(_LIB.taptools_touche_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, position=None, position_mm=None, force_n=None, mode=None, + smooth_ms=None) -> "Touche": + # configuration first, so ramped targets in the same call honor the new slew + if mode is not None: + _check(_LIB.taptools_touche_set_mode(self._h, int(mode)), "mode") + if smooth_ms is not None: + _check(_LIB.taptools_touche_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + if position is not None: + _check(_LIB.taptools_touche_set_position(self._h, float(position)), "position") + if position_mm is not None: + _check(_LIB.taptools_touche_set_position_mm(self._h, float(position_mm)), "position_mm") + if force_n is not None: + _check(_LIB.taptools_touche_set_force_n(self._h, float(force_n)), "force_n") + return self + + def gain_at(self, p) -> float: + """The curve itself: linear gain at a normalized position. No state touched.""" + return float(_LIB.taptools_touche_gain_at(self._h, float(p))) + + def curve(self, n: int = 512): + """The whole law as (position, linear gain) arrays — for plotting.""" + p = np.linspace(0.0, 1.0, int(n)) + return p, np.array([self.gain_at(v) for v in p]) + + def process(self, x, position=None) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + if position is None: + _check(_LIB.taptools_touche_process(self._h, _p64(x), _p64(out), x.size), "process") + else: + pos = _f64(position) + _check(_LIB.taptools_touche_process_mod(self._h, _p64(x), _p64(pos), _p64(out), x.size), + "process_mod") + return out + + def clear(self) -> None: + """Return the key to rest (silent).""" + _check(_LIB.taptools_touche_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_touche_destroy(h) + self._h = None + + class Fuzz: """tap.fuzz~'s kernel (tap::tools::fuzz::pedal): a two-stage, tone-stacked distortion built on the Yeh/Abel/Smith DAFx-07 simplified cascade diff --git a/notebooks/touche.ipynb b/notebooks/touche.ipynb new file mode 100644 index 0000000..ae736e2 --- /dev/null +++ b/notebooks/touche.ipynb @@ -0,0 +1,376 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6def32be", + "metadata": {}, + "source": [ + "# tap.touche~ — the key, reproduced\n", + "\n", + "The *touche d'intensité* is the pressure key the Ondes Martenot player's left hand rides, and\n", + "Messiaen called it the instrument's greatest invention. Physically it is a graphite/mica powder\n", + "bag working as a rheostat — the carbon-microphone principle, compress it and resistance falls —\n", + "and what the player feels is a carefully chosen nonlinear spring.\n", + "\n", + "This kernel's contract is unusual for the library. Every other object here makes design choices\n", + "and then measures them. **This one is obliged to reproduce someone else's measurement.**\n", + "Quartier, Meurisse, Colmars, Frelat & Vaiedelich, *\"Intensity Key of the Ondes Martenot: An\n", + "Early Mechanical Haptic Device\"* (Acta Acustica united with Acustica 101(2), 421–428, 2015)\n", + "measured finger force, key displacement and the resulting sound simultaneously on instrument\n", + "No. 320, and published the boundaries of the six musical nuances across the key's travel. Those\n", + "seven points are the specification; `touche.h` interpolates them and must not wander.\n", + "\n", + "So section 1 is the only test that really matters, and the rest are about whether the\n", + "interpolation between the points can be trusted.\n", + "\n", + "Sections: **1** the published points come back · **2** the shape, and why not a line · **3** the\n", + "dead zone · **4** against the two obvious alternatives" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6d55db42", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T20:23:13.326652Z", + "iopub.status.busy": "2026-08-16T20:23:13.326428Z", + "iopub.status.idle": "2026-08-16T20:23:13.812503Z", + "shell.execute_reply": "2026-08-16T20:23:13.811168Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.4),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "# Quartier et al. 2015, Table II — the measurement this object exists to reproduce.\n", + "TABLE_DB = np.array([45.0, 53.3, 61.6, 70.0, 78.3, 86.6, 95.0])\n", + "TABLE_MM = np.array([4.3, 5.3, 5.9, 6.4, 6.8, 7.3, 8.8])\n", + "TABLE_N = np.array([0.39, 0.47, 0.52, 0.62, 0.82, 1.34, 9.60])\n", + "TRAVEL_MM = 9.5 # the physical throw the paper describes (~3 to 9.5 mm of gesture)\n", + "\n", + "key = tap.Touche(sr, smooth_ms=0)\n", + "\n", + "def db(g):\n", + " g = np.asarray(g, dtype=float)\n", + " return 20 * np.log10(np.where(g > 0, g, 1e-300))" + ] + }, + { + "cell_type": "markdown", + "id": "bd909ecc", + "metadata": {}, + "source": [ + "## 1 · The published points come back\n", + "\n", + "Referenced to full press, the seven measured nuance boundaries are −50.0, −41.7, −33.4, −25.0,\n", + "−16.7, −8.4 and 0.0 dB. Read straight out of the object at the corresponding displacements:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2fd20aab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T20:23:13.815471Z", + "iopub.status.busy": "2026-08-16T20:23:13.815141Z", + "iopub.status.idle": "2026-08-16T20:23:13.821538Z", + "shell.execute_reply": "2026-08-16T20:23:13.820187Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mm published kernel error\n", + " 4.3 -50.0 dB -50.000 dB 0.0000\n", + " 5.3 -41.7 dB -41.700 dB 0.0001\n", + " 5.9 -33.4 dB -33.400 dB 0.0000\n", + " 6.4 -25.0 dB -25.000 dB 0.0001\n", + " 6.8 -16.7 dB -16.700 dB 0.0000\n", + " 7.3 -8.4 dB -8.400 dB -0.0001\n", + " 8.8 0.0 dB 0.000 dB 0.0000\n", + "\n", + "largest error: 5.74e-05 dB\n" + ] + } + ], + "source": [ + "want = TABLE_DB - TABLE_DB[-1]\n", + "got = np.array([db(key.gain_at(mm / TRAVEL_MM)) for mm in TABLE_MM])\n", + "\n", + "print(f\"{'mm':>6} {'published':>11} {'kernel':>10} {'error':>9}\")\n", + "for mm, w, g in zip(TABLE_MM, want, got):\n", + " print(f\"{mm:6.1f} {w:10.1f} dB {g:9.3f} dB {g - w:8.4f}\")\n", + "print(f\"\\nlargest error: {np.max(np.abs(got - want)):.2e} dB\")" + ] + }, + { + "cell_type": "markdown", + "id": "4ce1dc3c", + "metadata": {}, + "source": [ + "## 2 · The shape, and why it is not fitted\n", + "\n", + "The reason the kernel interpolates the table rather than fitting a curve through it: the\n", + "published dB steps are equal by construction (six nuances over 50 dB) and the *displacement*\n", + "steps are not — 1.0, 0.6, 0.5, 0.4, 0.5, 1.5 mm. The law steepens through the middle of the\n", + "travel and flattens hard at the top. A straight line in dB-against-mm would throw away exactly\n", + "the property that makes the key expressive.\n", + "\n", + "Interpolation is monotone cubic (Fritsch–Carlson), which passes through every measured point\n", + "and cannot overshoot between them. Overshoot here would be a non-monotone gain — audible as a\n", + "dip while you press *harder*." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e01f8be5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T20:23:13.823702Z", + "iopub.status.busy": "2026-08-16T20:23:13.823481Z", + "iopub.status.idle": "2026-08-16T20:23:14.062129Z", + "shell.execute_reply": "2026-08-16T20:23:14.060577Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "largest departure from a straight line: 8.3 dB\n", + "displacement steps for equal dB steps: [1. 0.6 0.5 0.4 0.5 1.5] mm\n", + "monotone: True within [0, 1]: True\n" + ] + } + ], + "source": [ + "p = np.linspace(0, 1, 2001)\n", + "mm = p * TRAVEL_MM\n", + "curve = db(np.array([key.gain_at(v) for v in p]))\n", + "\n", + "inband = (mm >= TABLE_MM[0]) & (mm <= TABLE_MM[-1])\n", + "# The straight line the kernel deliberately is not: -50 dB at the measured floor, 0 dB at full\n", + "# press, linear in displacement between.\n", + "frac = (mm - TABLE_MM[0]) / (TABLE_MM[-1] - TABLE_MM[0])\n", + "line = -50.0 * (1.0 - frac)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(mm[inband], curve[inband], color=C[0], lw=2.0, label=\"published curve, interpolated\")\n", + "ax.plot(mm[inband], line[inband], color=C[3], lw=1.0, ls=\"--\", label=\"a straight line, for comparison\")\n", + "ax.plot(TABLE_MM, want, \"o\", color=C[2], ms=7, zorder=5, label=\"Quartier et al. 2015, Table II\")\n", + "ax.set_xlabel(\"key displacement (mm)\"); ax.set_ylabel(\"gain (dB, referenced to full press)\")\n", + "ax.set_title(\"the intensity key's law — measured points, and what a line would have said\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "dev = np.max(np.abs(curve[inband] - line[inband]))\n", + "print(f\"largest departure from a straight line: {dev:.1f} dB\")\n", + "print(f\"displacement steps for equal dB steps: {np.round(np.diff(TABLE_MM), 2)} mm\")\n", + "\n", + "# Monotone, and inside the envelope — the properties that make the interpolant safe.\n", + "g = np.array([key.gain_at(v) for v in p])\n", + "print(f\"monotone: {bool(np.all(np.diff(g) >= -1e-12))} within [0, 1]: {bool(g.min() >= 0 and g.max() <= 1 + 1e-12)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1d72ab22", + "metadata": {}, + "source": [ + "## 3 · The dead zone is the instrument's\n", + "\n", + "Normalized position spans the *physical* travel the paper describes (gestures span roughly\n", + "3–9.5 mm), not the measured band inside it. So the bottom of the throw is silent — and that is\n", + "not a modelling choice. The key's first phase is pure bending of the elastic strip, before it\n", + "even reaches the powder bag; 4.3 mm is where the instrument arrives at its own noise floor.\n", + "\n", + "The consequence is musical rather than cosmetic: the useful 50 dB is packed into 4.5 mm right\n", + "after a long silent approach, which is precisely what lets a player produce very sharp attacks\n", + "with a slow-looking gesture." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "035e84ac", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T20:23:14.064615Z", + "iopub.status.busy": "2026-08-16T20:23:14.064370Z", + "iopub.status.idle": "2026-08-16T20:23:14.219652Z", + "shell.execute_reply": "2026-08-16T20:23:14.218508Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "silent fraction of the throw: 45%\n", + "gain at rest: 0.0 at full press: 1.0\n" + ] + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 2.8))\n", + "ax.plot(mm, np.array([key.gain_at(v) for v in p]), color=C[0], lw=2.0)\n", + "ax.axvspan(0, TABLE_MM[0], color=C[3], alpha=0.15)\n", + "ax.text(TABLE_MM[0] / 2, 0.55, \"silent:\\nthe key is still\\nbending\", ha=\"center\", color=C[3], fontsize=9)\n", + "ax.axvspan(TABLE_MM[-1], TRAVEL_MM, color=\"0.85\", alpha=0.5)\n", + "ax.text((TABLE_MM[-1] + TRAVEL_MM) / 2, 0.55, \"clamped\", ha=\"center\", color=\"0.4\", fontsize=9)\n", + "ax.set_xlabel(\"key displacement (mm)\"); ax.set_ylabel(\"linear gain\")\n", + "ax.set_xlim(0, TRAVEL_MM)\n", + "ax.set_title(\"50 dB in 4.5 mm, after a long silent approach\")\n", + "plt.show()\n", + "\n", + "print(f\"silent fraction of the throw: {TABLE_MM[0] / TRAVEL_MM:.0%}\")\n", + "print(f\"gain at rest: {key.gain_at(0.0)} at full press: {key.gain_at(1.0)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "7d6d3aee", + "metadata": {}, + "source": [ + "## 4 · Against the two obvious alternatives\n", + "\n", + "If you needed an expressive volume control and did not have this measurement, you would reach\n", + "for one of two things: a linear fade, or a fade that is linear in dB. Neither is what the\n", + "instrument does. Below, the same triangular gesture through all three, measured as the energy\n", + "that actually comes out." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "70f4a222", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-16T20:23:14.223486Z", + "iopub.status.busy": "2026-08-16T20:23:14.223218Z", + "iopub.status.idle": "2026-08-16T20:23:14.790782Z", + "shell.execute_reply": "2026-08-16T20:23:14.789386Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " linear in amplitude: rms 0.1633 half-travel gain 0.5000\n", + " linear in dB: rms 0.0834 half-travel gain 0.0562\n", + " the published curve: rms 0.1163 half-travel gain 0.0045\n" + ] + } + ], + "source": [ + "gesture = np.concatenate([np.linspace(0, 1, int(1.5 * sr)), np.linspace(1, 0, int(1.5 * sr))])\n", + "t = np.arange(gesture.size) / sr\n", + "tone = 0.4 * np.sin(2 * np.pi * 220.0 * t)\n", + "\n", + "laws = {\n", + " \"linear in amplitude\": gesture,\n", + " \"linear in dB\": np.where(gesture > 0, 10 ** ((-50.0 * (1 - gesture)) / 20), 0.0),\n", + " \"the published curve\": tap.Touche(sr, smooth_ms=0).process(np.ones_like(gesture), position=gesture),\n", + "}\n", + "\n", + "fig, ax = plt.subplots()\n", + "for i, (label, g) in enumerate(laws.items()):\n", + " ax.plot(t, g, color=C[i], lw=1.6, label=label)\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"gain\")\n", + "ax.set_title(\"one gesture, three laws\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "for label, g in laws.items():\n", + " out = tone * g\n", + " print(f\"{label:>22}: rms {np.sqrt(np.mean(out ** 2)):.4f} \"\n", + " f\"half-travel gain {np.interp(0.5, gesture[:gesture.size // 2], g[:gesture.size // 2]):.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9aaa2242", + "metadata": {}, + "source": [ + "## Checkpoint\n", + "\n", + "- The seven published points come back out of the object to better than a hundredth of a dB.\n", + " That is the whole contract.\n", + "- The law is monotone, stays inside the measured envelope, and departs from a straight line by\n", + " a wide margin — which is the property worth having.\n", + "- The silent bottom of the throw is the key's own first phase, not a modelling artifact.\n", + "- And it is audibly neither of the two laws you would otherwise have reached for.\n", + "\n", + "Every number above lives twice: as a cell here and as a pinned scenario in\n", + "`tests/touche_test.cpp`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 0e8887f..2a3d5d9 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -28,6 +28,7 @@ add_executable(taptools_kernel_tests step_seq_test.cpp stammer_test.cpp tapecho_test.cpp + touche_test.cpp tune_test.cpp tr808_clap_test.cpp tr808_cymbal_test.cpp diff --git a/tests/touche_test.cpp b/tests/touche_test.cpp new file mode 100644 index 0000000..ed65aa8 --- /dev/null +++ b/tests/touche_test.cpp @@ -0,0 +1,223 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.touche~ kernel (touche.h). +/// @details This kernel's contract is unusual for the library: the curve is not a design +/// choice to be measured after the fact, it is a *published measurement* the code +/// is obliged to reproduce. So the load-bearing scenario simply checks that every +/// one of Quartier et al.'s seven points comes back out of the object, and the rest +/// pin the properties that make the interpolation trustworthy — monotone, no +/// overshoot between points, exact endpoints, and demonstrably not the straight +/// line a lazier implementation would have fitted. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + + using tap::tools::touche::key; + namespace T = tap::tools::touche; + + key make() { + key k; + k.prepare(k_sr); + k.set_smooth_ms(0.0); + return k; + } + + /// Normalized position of a displacement in millimetres — over the physical travel, which + /// is wider than the measured band (the bottom of the throw is silent). + double pos_of_mm(double mm) { + return mm / T::k_travel_mm; + } + +} // namespace + +// The whole point of the object: it reproduces the published table. Every measured nuance +// boundary must come back at the dB the paper reports, referenced to full press. +SCENARIO("the published measurement comes back out of the curve") { + key k = make(); + + for (int i = 0; i < T::k_points; ++i) { + const double mm = T::k_table_mm[static_cast(i)]; + const double want_db = T::k_table_db[static_cast(i)] - T::k_table_db[T::k_points - 1]; + const double got_db = k.db_at(pos_of_mm(mm)); + INFO("point " << i << ": " << mm << " mm, published " << T::k_table_db[static_cast(i)] << " dB_SPL -> " + << want_db << " dB relative; got " << got_db); + CHECK(std::abs(got_db - want_db) < 0.05); // dense-table resolution, not curve error + } +} + +SCENARIO("the range is exactly the published 50 dB over the published travel") { + key k = make(); + INFO("full press " << k.db_at(1.0) << " dB, floor " << k.db_at(pos_of_mm(T::k_min_mm)) << " dB"); + CHECK(std::abs(k.db_at(1.0)) < 1e-9); // full press is exactly unity + CHECK(std::abs(k.gain_at(1.0) - 1.0) < 1e-12); + CHECK(std::abs(k.db_at(pos_of_mm(T::k_min_mm)) + T::k_range_db) < 0.05); // the floor is -50 dB + CHECK(std::abs(T::k_max_mm - T::k_min_mm - 4.5) < 1e-9); // over 4.5 mm of travel +} + +// The dead zone is the instrument's, not a modelling artifact: the key bends before it reaches +// the powder bag, so the bottom of the throw makes no sound at all. +SCENARIO("the bottom of the throw is silent, and that is the key's own first phase") { + key k = make(); + for (double mm : {0.0, 1.0, 2.5, 4.0}) { + INFO(mm << " mm"); + CHECK(k.gain_at(pos_of_mm(mm)) == 0.0); + } + CHECK(k.gain_at(pos_of_mm(4.4)) > 0.0); // and it opens just past the measured floor + INFO("silent fraction of the throw: " << T::k_min_mm / T::k_travel_mm); + CHECK(T::k_min_mm / T::k_travel_mm > 0.4); // roughly the first 45 % +} + +SCENARIO("the curve is monotone and never overshoots between measured points") { + key k = make(); + + double last = -1.0; + bool mono = true; + bool inside = true; + for (int i = 0; i <= 4000; ++i) { + const double p = static_cast(i) / 4000.0; + const double g = k.gain_at(p); + mono = mono && (g >= last - 1e-12); + inside = inside && (g >= 0.0) && (g <= 1.0 + 1e-12); + last = g; + } + REQUIRE(mono); // pressing harder is never quieter + REQUIRE(inside); // and the interpolant stays inside the measured envelope +} + +// The reason the kernel interpolates rather than fits. Equal dB steps in the published table +// correspond to displacement steps of 1.0, 0.6, 0.5, 0.4, 0.5, 1.5 mm — the curve steepens +// through the middle and flattens at the top, and a straight line in dB-against-mm would be +// visibly and audibly wrong. +SCENARIO("the law is emphatically not a straight line in dB against displacement") { + key k = make(); + + // Compare across the *measured* band only — the silent dead zone below it is not part of + // the curve and would swamp the comparison. + const double lo = pos_of_mm(T::k_min_mm); + const double hi = pos_of_mm(T::k_max_mm); + double worst = 0.0; + for (int i = 1; i < 100; ++i) { + const double f = static_cast(i) / 100.0; + const double p = lo + f * (hi - lo); + const double linear = -T::k_range_db * (1.0 - f); + worst = std::max(worst, std::abs(k.db_at(p) - linear)); + } + INFO("largest departure from a straight line: " << worst << " dB"); + REQUIRE(worst > 6.0); // nowhere near a line — this is the expressiveness + + // And the departure has the measured shape: halfway along the measured band is louder than + // a line would predict, because the steep part of the curve happens early. + const double mid = k.db_at(lo + 0.5 * (hi - lo)); + INFO("at half the measured band: " << mid << " dB, a line would say " << -T::k_range_db * 0.5); + CHECK(mid > -T::k_range_db * 0.5); +} + +SCENARIO("below the measured floor is exact silence, not extrapolation") { + key k = make(); + REQUIRE(k.gain_at(0.0) == 0.0); + + // And through the audio path: a key at rest passes nothing at all. + k.set_position(0.0); + bool silent = true; + for (int i = 0; i < 2000; ++i) { + silent = silent && (k.process(0.7) == 0.0); + } + REQUIRE(silent); +} + +SCENARIO("above full press the curve clamps rather than extrapolating") { + key k = make(); + CHECK(k.gain_at(1.0) == k.gain_at(2.0)); + k.set_position_mm(20.0); // far past the 9.5 mm travel + CHECK(k.position() == 1.0); +} + +SCENARIO("the force column reproduces its own published points") { + key k = make(); + k.set_mode(T::mode_force); + + for (int i = 0; i < T::k_points; ++i) { + const double n = T::k_table_n[static_cast(i)]; + const double p = n / T::k_travel_n; + const double want_db = T::k_table_db[static_cast(i)] - T::k_table_db[T::k_points - 1]; + INFO("point " << i << ": " << n << " N, want " << want_db << " dB, got " << k.db_at(p)); + CHECK(std::abs(k.db_at(p) - want_db) < 0.2); // coarser: the force axis is far from uniform + } +} + +// The paper's finding that the map does not depend on the speed of the gesture is why a static +// curve is legitimate at all. The kernel-side consequence a test can pin: the gain depends only +// on where the key is, not on what the audio is doing or how it got there. +SCENARIO("the gain depends only on position, not on the signal or the approach") { + key fast = make(); + key slow = make(); + + // Same destination, reached instantly vs over a long ramp — once settled, identical. + fast.set_position(0.62); + slow.set_smooth_ms(200.0); + slow.set_position(0.62); + for (int i = 0; i < static_cast(0.5 * k_sr); ++i) { + fast.process(0.0); + slow.process(0.0); + } + INFO("fast " << fast.gain() << ", slow " << slow.gain()); + CHECK(std::abs(fast.gain() - slow.gain()) < 1e-12); + + // And it is a pure gain: the ratio out/in is the same whatever the input. + key k = make(); + k.set_position(0.4); + k.process(0.0); // settle + const double g = k.gain(); + for (double x : {0.01, 0.5, -0.3, 1.0}) { + INFO("input " << x); + CHECK(std::abs(k.process(x) - x * g) < 1e-12); + } +} + +SCENARIO("a position move is slewed, so the key does not click") { + key k = make(); + k.set_smooth_ms(50.0); + k.set_position(0.0); + k.process(1.0); + + k.set_position(1.0); // slam it open + double worst = 0.0, last = k.process(1.0); + for (int i = 0; i < static_cast(0.1 * k_sr); ++i) { + const double y = k.process(1.0); + worst = std::max(worst, std::abs(y - last)); + last = y; + } + INFO("largest single-sample step on a full-travel move: " << worst); + REQUIRE(worst < 0.01); // no discontinuity anywhere in the sweep +} + +SCENARIO("the signal-rate path tracks a control signal") { + key k = make(); + + // Sweep the position as a signal and check the output follows the curve sample by sample. + bool exact = true; + for (int i = 0; i <= 100; ++i) { + const double p = static_cast(i) / 100.0; + const double y = k.process(1.0, p); + exact = exact && (std::abs(y - k.gain_at(p)) < 1e-12); + } + REQUIRE(exact); +} + +SCENARIO("unprepared, the key still follows its curve") { + key k; + k.set_smooth_ms(0.0); + k.set_position(1.0); + CHECK(std::abs(k.process(0.5) - 0.5) < 1e-9); +} diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 7b3f855..7375cd3 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -1229,6 +1230,69 @@ int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, return with(h, [&](tapecho_machine& m) { m.process(in, outL, outR, static_cast(n)); }); } +// ---- tap.touche~ --------------------------------------------------------------------------------- + +using touche_key = tap::tools::touche::key; + +taptools_touche taptools_touche_create(void) { + return static_cast(new touche_key()); +} + +void taptools_touche_destroy(taptools_touche h) { + delete static_cast(h); +} + +int taptools_touche_prepare(taptools_touche h, double sr) { + return with(h, [&](touche_key& k) { k.prepare(sr); }); +} + +int taptools_touche_set_position(taptools_touche h, double p) { + return with(h, [&](touche_key& k) { k.set_position(p); }); +} + +int taptools_touche_set_position_mm(taptools_touche h, double mm) { + return with(h, [&](touche_key& k) { k.set_position_mm(mm); }); +} + +int taptools_touche_set_force_n(taptools_touche h, double n) { + return with(h, [&](touche_key& k) { k.set_force_n(n); }); +} + +int taptools_touche_set_mode(taptools_touche h, int mode) { + return with(h, [&](touche_key& k) { k.set_mode(mode); }); +} + +int taptools_touche_set_smooth_ms(taptools_touche h, double ms) { + return with(h, [&](touche_key& k) { k.set_smooth_ms(ms); }); +} + +int taptools_touche_clear(taptools_touche h) { + return with(h, [&](touche_key& k) { k.clear(); }); +} + +double taptools_touche_gain_at(taptools_touche h, double p) { + const touche_key* k = static_cast(h); + return k ? k->gain_at(p) : std::nan(""); +} + +int taptools_touche_process(taptools_touche h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](touche_key& k) { k.process(in, out, static_cast(n)); }); +} + +int taptools_touche_process_mod(taptools_touche h, const double* in, const double* position, double* out, int n) { + if (!in || !position || !out || n < 0) { + return -1; + } + return with(h, [&](touche_key& k) { + for (int i = 0; i < n; ++i) { + out[i] = k.process(in[i], position[i]); + } + }); +} + // ---- tap.fuzz~ ----------------------------------------------------------------------------------- using fuzz_pedal = tap::tools::fuzz::pedal; diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 213be34..1588f31 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -393,6 +393,26 @@ TAPTOOLS_API int taptools_tapecho_clear(taptools_tapecho h); /// Process n samples mono-in / stereo-out (the dry path is mixed to both busses). TAPTOOLS_API int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, double* outR, int n); +// ---- tap.touche~ (tap::tools::touche::key) ------------------------------------------------------- + +typedef void* taptools_touche; + +TAPTOOLS_API taptools_touche taptools_touche_create(void); +TAPTOOLS_API void taptools_touche_destroy(taptools_touche h); +TAPTOOLS_API int taptools_touche_prepare(taptools_touche h, double sr); +TAPTOOLS_API int taptools_touche_set_position(taptools_touche h, double p); // 0..1 of the travel +TAPTOOLS_API int taptools_touche_set_position_mm(taptools_touche h, double mm); // published units +TAPTOOLS_API int taptools_touche_set_force_n(taptools_touche h, double n); +TAPTOOLS_API int taptools_touche_set_mode(taptools_touche h, int mode); // 0 displacement, 1 force +TAPTOOLS_API int taptools_touche_set_smooth_ms(taptools_touche h, double ms); +TAPTOOLS_API int taptools_touche_clear(taptools_touche h); +/// The curve itself: linear gain at a normalized position (NaN on a bad handle). No state touched. +TAPTOOLS_API double taptools_touche_gain_at(taptools_touche h, double p); +TAPTOOLS_API int taptools_touche_process(taptools_touche h, const double* in, double* out, int n); +/// Signal-rate position: `position` drives the gain sample by sample. +TAPTOOLS_API int taptools_touche_process_mod(taptools_touche h, const double* in, const double* position, double* out, + int n); + // ---- tap.fuzz~ (tap::tools::fuzz::pedal) --------------------------------------------------------- typedef void* taptools_fuzz; diff --git a/tools/render/radiohead_render.cpp b/tools/render/radiohead_render.cpp index 647e1a0..9771b7a 100644 --- a/tools/render/radiohead_render.cpp +++ b/tools/render/radiohead_render.cpp @@ -1,6 +1,7 @@ /// @file /// @brief Offline renderer for the Radiohead family — writes demo WAVs for listening checks. -/// @details Exercises tapecho.h, stammer.h and fuzz.h with no Max involved (the kernels' portability, demonstrated). +/// @details Exercises tapecho.h, stammer.h, fuzz.h and touche.h with no Max involved (the kernels' portability, +/// demonstrated). /// The tape echo is a *performed* effect, so these scenarios move the controls while /// they render rather than auditioning static settings — that is the only way to hear /// what the kernel is actually for. @@ -20,7 +21,10 @@ /// performance); and `fuzz_gain_sweep` (five gain settings back to back, so the /// sweep from edge-of-breakup to saturated is audible rather than described), /// `fuzz_tone` (the voicing section, which is most of that pedal class's identity), -/// and `fuzz_edge_and_bite` (the knee sharpening, then the even harmonics coming in). +/// and `fuzz_edge_and_bite` (the knee sharpening, then the even harmonics coming +/// in); and `touche_against_a_fade`, which swells one note three times — a linear +/// fade, a fade linear in dB, and the Ondes Martenot's published intensity-key +/// curve — because the measured law is audibly neither of the obvious two. /// /// Usage: radiohead_render [output-directory] (default: current directory) /// @author Timothy Place @@ -37,6 +41,7 @@ #include #include #include +#include namespace { @@ -421,6 +426,50 @@ namespace { write_scenario(dir + "/fuzz_edge_and_bite.wav", mono, 0.7, 1); } + // ---- tap.touche~ ----------------------------------------------------------------------------- + + /// The intensity key against the obvious alternative. The same note is swelled and released + /// three times: once through a straight linear fade, once through a straight fade in dB, and + /// once through the published curve. The point is that the measured law is neither — it + /// steepens through the middle of the travel and flattens at the top, which is what lets a + /// player place a crescendo where they want it instead of where the taper puts it. + void touche_against_a_fade(const std::string& dir) { + tap::tools::touche::key k; + k.prepare(k_r_sr); + k.set_smooth_ms(0.0); + + const double gesture = 3.0; // seconds up, then the same back down + const size_t frames = static_cast(2.0 * gesture * k_r_sr); + std::vector mono; + mono.reserve(3 * frames); + + for (int law = 0; law < 3; ++law) { + double phase = 0.0; + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + // A triangle over the gesture: press in, release out. + const double u = (t < gesture) ? (t / gesture) : (2.0 - t / gesture); + // A steady tone, so the only thing moving is the gain law. + phase += 220.0 / k_r_sr; + phase -= std::floor(phase); + const double tone = 0.4 * std::sin(2.0 * k_r_pi * phase); + + double g = 0.0; + if (law == 0) { + g = u; // linear in amplitude + } + else if (law == 1) { + g = (u <= 0.0) ? 0.0 : std::pow(10.0, (-50.0 * (1.0 - u)) / 20.0); // linear in dB + } + else { + g = k.gain_at(u); // the published curve + } + mono.push_back(tone * g); + } + } + write_scenario(dir + "/touche_against_a_fade.wav", mono, 0.9, 1); + } + } // namespace int main(int argc, char** argv) { @@ -435,5 +484,6 @@ int main(int argc, char** argv) { fuzz_gain_sweep(dir); fuzz_tone(dir); fuzz_edge_and_bite(dir); + touche_against_a_fade(dir); return 0; } From a9e45ed82418a86a1ebaf954544d21052373934f Mon Sep 17 00:00:00 2001 From: Timothy Place Date: Mon, 17 Aug 2026 02:53:49 +0000 Subject: [PATCH 14/22] Add the Ondes diffuseurs and the granular scrub MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two objects in one pass, both from book/PLAN-radiohead-family.md. diffuseur.h — tap.metallique~ and tap.palme~, the Ondes Martenot's resonating loudspeakers as DRIVEN resonators. garden.h's modal maths carries over; its strike envelopes do not. Five components under two thin cabinets: `mode` (the constant-peak-gain two-pole resonator, unit peak gain at any Q and exact nulls at DC and Nyquist, so the bank needs neither limiter nor blocker), `plate` (eight free-circular-plate modes as beating doublets), `sympathetic` and `harp` (twelve damped waveguide loops), and `transducer` (the moving-iron driver). The signal order is a claim about the instrument and is pinned by a null test: the cabinet is exactly transducer -> body, bitwise, and the reversed wiring differs by 28% of peak. The transducer's bound is 2/saturation rather than the 1/saturation the saturator alone would give, because removing the DC from a hard-driven squared law doubles the worst-case swing. The bodies are recreations of the general physics (Fletcher & Rossing), stated as such: no ondes-specific modal measurement exists in any of the sources. The palme gets twelve strings per the peer-reviewed source, not the twenty-four of the hobbyist build pages. scrub.h — tap.scrub~, a granular scrub pad whose position and pitch are two independent performable signals. The tape is stammer::capture itself, shared rather than copied, as that header's limits promised; the only addition the stutter needed was the fractional read its slices never used. Hann at hop size/2 overlap-adds to exactly 1, so held still at unity pitch the scrub is the input delayed, to 4.4e-16. One real defect found by measurement and fixed: anchoring grains at the position advances their origins at the write head's speed, so transposition applied only inside a grain, the average read rate came back to 1, and a steady tone emerged at its ORIGINAL pitch with a comb around it. The read head is now phase-continuous, wrapped back only after wandering +-1.5 grains (a bound chosen by sweep). A measurement warning is recorded with it: a single-bin probe read the fixed kernel as broken, 0.02 where the band figure was 0.43. Also here: 31 Catch2 scenarios across the two suites, the C ABI and ctypes surfaces (including the bare `Plate` and `Transducer` components), two executed notebooks, four radiohead_render scenarios, and the README's kernel tables brought up to date with the six objects that had fallen out of them. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- README.md | 8 +- book/PLAN-ondes.md | 34 +- book/PLAN-radiohead-family.md | 89 +++- include/taptools/diffuseur.h | 776 ++++++++++++++++++++++++++++ include/taptools/scrub.h | 460 +++++++++++++++++ include/taptools/stammer.h | 5 + include/taptools/taptools.h | 2 + notebooks/diffuseur.ipynb | 815 ++++++++++++++++++++++++++++++ notebooks/scrub.ipynb | 787 +++++++++++++++++++++++++++++ notebooks/taptools_py.py | 371 ++++++++++++++ tests/CMakeLists.txt | 2 + tests/diffuseur_test.cpp | 501 ++++++++++++++++++ tests/scrub_test.cpp | 386 ++++++++++++++ tools/capi/taptools_capi.cpp | 348 +++++++++++++ tools/capi/taptools_capi.h | 109 ++++ tools/render/radiohead_render.cpp | 158 +++++- 16 files changed, 4829 insertions(+), 22 deletions(-) create mode 100644 include/taptools/diffuseur.h create mode 100644 include/taptools/scrub.h create mode 100644 notebooks/diffuseur.ipynb create mode 100644 notebooks/scrub.ipynb create mode 100644 tests/diffuseur_test.cpp create mode 100644 tests/scrub_test.cpp diff --git a/README.md b/README.md index acd99a9..2fd7596 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,9 @@ header adds no nested namespace, the class) the kernel lives in. | `overdrive.h` | `tap.overdrive~` | LGW-voiced feedback overdrive (`tap::tools::od`) | | `vca.h` | `tap.vca~` | Voltage-controlled amplifier (`tap::tools::vca`) | | `adsr.h` | `tap.adsr~` | Virtual-analog ADSR envelope, legacy Jamoma curves as modes (`tap::tools::adsr`) | +| `fuzz.h` | `tap.fuzz~` | Two-stage tone-stacked fuzz on the DAFx-07 cascade (`tap::tools::fuzz`) | +| `touche.h` | `tap.touche~` | The Ondes Martenot intensity key as a published gain law (`tap::tools::touche`) | +| `diffuseur.h` | `tap.metallique~`, `tap.palme~` | The Ondes diffuseurs as driven resonators (`tap::tools::diffuseur`) | **Voices, drums, and sequencing** @@ -82,6 +85,9 @@ header adds no nested namespace, the class) the kernel lives in. | `discreet.h` | `tap.discreet~` | *Discreet Music* two-machine regeneration loop (`tap::tools::discreet`) | | `airport.h` | `tap.airport~` | *Music for Airports* incommensurate loop bank (`tap::tools::airport`) | | `garden.h` | `tap.garden~` | Generative event loop on the Bloom principle (`tap::tools::garden`) | +| `tapecho.h` | `tap.tapecho~` | Multi-head tape echo (`tap::tools::tapecho`) | +| `stammer.h` | `tap.stammer~` | Live buffer-stutter rig (`tap::tools::stammer`) | +| `scrub.h` | `tap.scrub~` | Granular scrub over live capture (`tap::tools::scrub`) | `taptools.h` is the umbrella header that pulls in every kernel above. `stft.h`, `tune.h`, `harmonizer.h` and `conv_engine.h` reach into `tap::dsp` (the pinned DspTap submodule) for the @@ -92,7 +98,7 @@ Plus, all Max-free: - **`tests/`** — Catch2 unit tests for the kernels (fetched via FetchContent; run with `ctest`). Wrapper-level tests (attributes, Min plumbing) stay with the externals on the min-api harness in the Max package. -- **`tools/render/`** — offline WAV renderers (`diode_render`, `tb303_render`, `ladder_render`, `vco_render`, +- **`tools/render/`** — offline WAV renderers (`diode_render`, `tb303_render`, `ladder_render`, `vco_render`, `radiohead_render`, `grm_comb_render`, `grm_pitchaccum_render`, `autowah_render`) for listening checks outside Max. - **`tools/capi/`** — a small C ABI (`taptools_capi`) over a *subset* of the kernels, for the notebooks and other non-C++ consumers. `tools/capi/taptools_capi.h` is the authoritative list of diff --git a/book/PLAN-ondes.md b/book/PLAN-ondes.md index a244084..c17a025 100644 --- a/book/PLAN-ondes.md +++ b/book/PLAN-ondes.md @@ -1,7 +1,8 @@ # Plan — `tap.ondes~`, after reading the sources -> **Status: in progress — `touche` shipped 2026-08-15 as `tap.touche~` (kernel side); the rest -> is design.** The source gate is closed — +> **Status: in progress — `touche` shipped 2026-08-15 as `tap.touche~`, and both diffuseurs +> shipped 2026-08-17 as `tap.metallique~` and `tap.palme~`; the `triode` and the heterodyne +> `source` are still design.** The source gate is closed — > `PLAN-radiohead-family.md` §3 records what was found and how far each paper was read. This > file is the design pass those findings forced, written before any code, because what the > papers describe is **not the object the family plan sketched**. @@ -116,7 +117,31 @@ port-Hamiltonian simulation runs at 768 kHz and their plugin consumes 85 % of a that is the road not taken, and the header should say so, so nobody assumes the simple path was chosen out of ignorance. -## The diffuseurs — driven, not struck +## The diffuseurs — driven, not struck — ✅ shipped + +> **Shipped 2026-08-17**: `include/taptools/diffuseur.h`, `tests/diffuseur_test.cpp` (18 +> scenarios), the C ABI + ctypes surface (`Metallique`, `Palme`, plus the bare `Plate` and +> `Transducer` components), the executed `notebooks/diffuseur.ipynb`, the `metallique_stages` +> and `palme_halo` render scenarios, and both Max vertical slices. +> +> Everything below survived contact with the code. The one thing the design pass did not say, +> and the build made explicit, is that **the order is a claim worth a null test**: the +> transducer drives the body, so the cabinet must be exactly `transducer -> plate`, bitwise, +> and the reversed wiring must measurably differ (it does — 28 % of peak). Two smaller findings: +> the modal bank needs no limiter and no DC blocker at all, because Steiglitz's +> constant-peak-gain resonator has unit peak gain at any Q and its zeros at ±1 null DC and +> Nyquist exactly; and the transducer's output bound is **2/saturation, not 1/saturation**, +> because taking the DC out of a hard-driven squared law doubles the worst-case swing. +> +> The transducer question the plan left open — model the nonlinearity or state its absence — +> was answered by modelling it: the squared law is defensible from the moving-iron principle +> alone, and it is measured against its own prediction (second harmonic at exactly +> asymmetry × amplitude / 2, to 1.4e-4, with nothing at the third). The bounding saturator +> after it is labelled what it is: a modelling necessity, not a measured stage. +> +> Still open, and stated in the header rather than hidden: no radiation or cabinet model, no +> soundboard resonance, and no string stiffness (a real steel string's partials stretch sharp; +> a delay loop's are exactly harmonic). The correction that matters most for reusing `garden.h`'s idiom. Wijnand et al.: @@ -144,8 +169,7 @@ peer-reviewed source says 12. Prefer 12 and say why. 1. **`touche`** — fully specified, small, independently useful, and it can ship as `tap.touche~` before the rest of the instrument exists. Do this first. -2. **The diffuseurs** — also independently useful, and the modal machinery is familiar. - `tap.palme~` and `tap.metallique~`. +2. ~~**The diffuseurs**~~ — ✅ shipped 2026-08-17 as `tap.metallique~` and `tap.palme~`. 3. **`triode`** — needs a listening comparison to settle the curve question. 4. **`source`** and the composition — last, because it is the cheapest piece and the one most constrained by the others. diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 46a96a6..2bca904 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,8 +1,10 @@ # Plan — the Radiohead family -> **Status: in progress — `tap.tapecho~`, `tap.stammer~` and `tap.fuzz~` have all shipped -> end-to-end, chapters included (2026-08-15). `tap.ondes~`'s sources are read and its gate is -> open; `tap.scrub~` is still plan.** This is the drafting record of the +> **Status: in progress — `tap.tapecho~`, `tap.stammer~` and `tap.fuzz~` shipped end-to-end, +> chapters included (2026-08-15); `tap.touche~`, the two diffuseurs and `tap.scrub~` shipped +> as kernels plus Max slices (2026-08-15/17), chapters still to come for those three.** +> `tap.ondes~`'s remaining pieces (the `triode` stage and the heterodyne `source`) are design. +> This is the drafting record of the > 2026-08-15 survey ("are there Radiohead-inspired objects we should consider?"), amended the > same day against the Eno components wave (`d4cf28a`) before any code was written. It stays > after the objects ship, the plans-directory way; the chapters have their own drafting @@ -35,7 +37,8 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. | `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | Heterodyne source + triode nonlinearity + `garden.h` modal idiom; **not** `vco.h` — see the source hunt | planned — sources read, gate open, needs a design pass | | `tap.fuzz~` | `fuzz.h` | Two-stage tone-stacked fuzz (the OK Computer-era dirt) | `overdrive.h` sibling; the DAFx-07 cascade | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | -| `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `tape::reel` + the `grm_pitchaccum.h` grain engine | planned | +| `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `stammer::capture` (shared, not copied) + a Hann grain scheduler | ✅ shipped 2026-08-17 (kernel, notebook, Max slice) | +| `tap.metallique~` / `tap.palme~` | `diffuseur.h` | The Ondes diffuseurs as driven resonators | `garden.h`'s modal maths without its strike envelopes; `grm_comb.h`'s sustained resonance | ✅ shipped 2026-08-17 (kernel, notebook, Max slices) | Parked (surveyed, deliberately not planned): a spectral freeze on the `stft.h` scaffold (`tap.sustain~` and `tap.discreet~` now cover most of that ground between them), a Klatt @@ -306,15 +309,60 @@ are the house precedent for schematic-based recreation. **Naming is an open ques (below): the garden precedent (Bloom → garden) says don't ship a live trademark; "ShredMaster" is Marshall's mark, and the header will cite it as provenance either way. -### 5. `tap.scrub~` — the Kaoss school *(after stammer; shares its capture)* +### 5. `tap.scrub~` — the Kaoss school *(after stammer; shares its capture)* — ✅ shipped -Live *Everything In Its Right Place*: the voice sampled on the fly and scrubbed, reversed, -smeared from a pad. A continuously recording `tape::reel` with a **performable granular -playhead**: position and speed as signals (the pad is two axes — that is the Max-side -mapping story), Hermite grains from the `grm_pitchaccum.h` engine, overlap and grain size -exposed. Distinct from `tap.reel~` (free-running loop, no performable head) and from -`tap.pitchaccum~` (transposition, not scrubbing); shares machinery with both, and the plan -is to make that sharing literal, not copied. +> **Shipped 2026-08-17**: `include/taptools/scrub.h` (`head` + `machine`), +> `tests/scrub_test.cpp` (13 scenarios), the C ABI + ctypes surface (`Scrub`), the executed +> `notebooks/scrub.ipynb`, two `radiohead_render` scenarios, and the Max slice. +> +> **The sharing is literal**, as planned: the tape is `stammer::capture` itself, not a second +> copy of it, and the only addition the stutter needed was `read_frac` — the fractional Hermite +> read its ±1-rate slices never used. The plan's "position and speed as signals" became +> **position and pitch**, which is the stronger claim: on tape, moving the head *is* the pitch +> change, and decoupling them is what makes this an instrument rather than a varispeed. +> +> **The load-bearing null**: Hann overlap-adds to exactly 1 at hop = size/2, so held still at +> unity pitch with no spray the scrub is the input delayed, to 4.4e-16. +> +> **One real defect, found by measurement and worth carrying.** The first cut anchored every +> grain at the position. Origins then advance at the *write head's* speed while each grain plays +> at `rate`, so the transposition applies only inside a grain, the average read rate returns to +> 1, and a steady tone comes out at its **original** pitch with a comb of grain-rate sidebands. +> The pitch knob did nothing but add texture — and no other test on the page could see it. The +> fix is a phase-continuous read head wrapped back toward the position only after it has +> wandered ±1.5 grains, a bound chosen by sweep (band energy retained 0.933 / 0.958 / 0.965 / +> 0.990 / 0.993 at ±0.5 / ±1 / ±2 / ±3 / ±4 grains; flat past 3, and every extra grain is a +> grain of position error). +> +> **And a measurement warning.** A single-bin probe reads the fixed kernel as badly broken: the +> wraps spread the transposed partial into a comb a few Hz wide, and a rectangular-window +> Goertzel on one line saw 0.02 where the band figure was 0.43. Measured properly, 98.8 % of a +> perfect shifter's energy lands within ±15 Hz of the transposed pitch (worst 91.7 %); what the +> wraps cost is concentration — 92.0 % as focused as a clean shift, 75.0 % at worst. Measure the +> band, not the bin. + +### 6. The diffuseurs — `tap.metallique~` and `tap.palme~` — ✅ shipped + +> **Shipped 2026-08-17**: `include/taptools/diffuseur.h` (`mode`, `plate`, `sympathetic`, +> `harp`, `transducer`, and the two cabinets over a shared `cabinet` base), +> `tests/diffuseur_test.cpp` (18 scenarios), the C ABI + ctypes surface (`Metallique`, `Palme`, +> and the bare `Plate` / `Transducer` components), the executed `notebooks/diffuseur.ipynb`, +> two `radiohead_render` scenarios, and both Max slices. Design record in `PLAN-ondes.md`. +> +> Three things the build settled. **The order is the argument**: the transducer drives the body, +> so the nonlinearity is upstream of the resonator, and a null test pins that the cabinet is +> exactly `transducer -> body` (bitwise) while the reverse wiring differs by 28 % of peak. +> **Unit peak gain per mode** (Steiglitz's constant-peak-gain resonator) plus weights that sum +> to exactly 1 makes the body bounded by its input with no limiter and no DC blocker — the +> zeros at ±1 handle DC and Nyquist. **The transducer's bound is 2/saturation, not +> 1/saturation**: a hard-driven squared law is a nearly-constant positive waveform, and removing +> its DC doubles the worst-case swing (measured 1.49 against the naive 1.25). +> +> Honest about what it is: the bodies are **recreations of the general physics** (Fletcher & +> Rossing's free circular plate, and the harmonic series), because no ondes-specific modal +> measurement exists in any of the four sources; the string tuning is a design choice; and both +> nonlinear coefficients are voiced by ear, since the source establishes *that* the moving-iron +> driver is nonlinear without handing over a curve. ## Cross-cutting commitments @@ -370,9 +418,20 @@ is to make that sharing literal, not copied. - ~~**Echo head layout.**~~ Resolved at ship: free ratios with a nominal even-spacing default (0.25 / 0.5 / 0.75 / 1.0), rather than a named-machine preset — no head spacings are claimed as measured from any unit, and a Copicat-style three is two lines to set. -- **One capture component or two.** Stammer and scrub both record the live input into a - reel; whether that is one shared class with two heads of use, or two thin wrappers over - `tape::reel`, is a design call to make when the stammer lands. +- ~~**One capture component or two.**~~ Resolved at the scrub's ship: **one**. `scrub.h` + includes `stammer.h` and uses `stammer::capture` directly; the only change the stutter needed + was a fractional read it does not itself call. +- **`tap.pitchaccum~` has the same warble, and worse.** Measured on the same sweep the scrub was + measured on (5 fundamentals × 7 intervals, band energy retained around the transposed pitch): + the scrub returns mean 0.988 / worst 0.917, `tap.pitchaccum~` returns mean 0.908 / **worst + 0.004** — a near-total cancellation at 311 Hz up 19 semitones, where its ratio is exactly 3 + and the two taps land a half-window apart. That is a real finding about a shipped object, + recorded rather than acted on: fixing it is its own job, with its own tests and its own + consumers, and it should not ride along on an unrelated kernel. +- **Chapters for the three newest objects.** `tap.touche~`, the diffuseurs and `tap.scrub~` have + kernels, notebooks and Max slices but no book chapters yet. The touche's belongs inside an + Ondes-family chapter once the `triode` and `source` exist; the diffuseurs' probably with it; + the scrub's belongs beside the stammer in Part V, since they share a tape. - **Diffuseur delivery.** Ship the resonators inside `tap.ondes~` only, or as standalone externals (`tap.palme~` / `tap.metallique~`) from day one? The components chapter's lesson leans standalone-from-day-one. diff --git a/include/taptools/diffuseur.h b/include/taptools/diffuseur.h new file mode 100644 index 0000000..9c17b52 --- /dev/null +++ b/include/taptools/diffuseur.h @@ -0,0 +1,776 @@ +/// @file +/// @brief Portable driven-resonator kernels for the Ondes Martenot diffuseurs +/// (tap.metallique~, tap.palme~) — no Max/Min dependency. +/// @details The Ondes Martenot does not have one loudspeaker, it has a rack of them, and the +/// player chooses which. Beyond the plain cabinet (the *principal*) Martenot built +/// resonating *diffuseurs* whose whole job is to colour the signal with a physical +/// body: the **métallique** (1944–45, patented 1947), a gong driven by a motor +/// transducer, and the **palme** (1949–50), an electromagnet driving twelve metal +/// strings stretched on a soundboard. Najnudel, Hélie, Roze & Boutin ("Simulation of +/// an ondes Martenot circuit", IEEE/ACM TASLP 28, 2020) name the diffuseur as the +/// stage that "converts the electrical waveform into sound and in turn modifies its +/// spectral content"; Wijnand, Boutin, Jossic & Maniguet (Forum Acusticum 2023) +/// describe the instruments themselves and measure the transducer. +/// +/// **The correction that shapes this file: these are DRIVEN, not struck.** garden.h's +/// modal maths carries over intact — mode ratios, doublet splitting, per-mode decay — +/// but its strike envelopes do not. There is no `decay_env` here and no trigger. The +/// input signal excites the body continuously and the body rings at its own rates, +/// which is grm_comb.h's sustained-resonance situation rather than the chime's. +/// +/// Signal order follows the instrument, and it matters: the electrical signal reaches +/// the *transducer* first, and the transducer's motion is what excites the body. So +/// the nonlinearity sits UPSTREAM of the resonator, not after it — drive the +/// transducer hard and you are driving a distorted waveform into a gong, which is a +/// different sound from distorting a gong. +/// +/// Five classes, the family's parts-plus-thin-composition habit: +/// - `mode` — one driven resonant mode: the constant-peak-gain two-pole resonator +/// (zeros at ±1, b0 = (1−R²)/2; Steiglitz, and Smith, *Introduction to Digital +/// Filters*). Peak gain is 1 at any Q, so a bank of weighted modes is bounded by +/// the sum of its weights and needs no output limiter, and the zeros put exact +/// nulls at DC and Nyquist so no DC blocker is needed either. +/// - `plate` — the métallique's body: eight modes at the free circular plate's +/// transverse ratios, each split into a slowly beating doublet. +/// - `sympathetic` — one string: a damped, DC-blocked delay loop (the waveguide +/// idiom, same fractional Hermite read as delay.h / grm_comb.h), returning its +/// *ringing* rather than its through-signal so a caller can balance the two. +/// - `harp` — the palme's body: twelve sympathetic strings on one soundboard. +/// - `transducer` — the moving-iron driver. +/// - `metallique` / `palme` — a transducer, a body, a balance, a level. Nothing else. +/// +/// **Provenance, and where recreation begins.** The instruments, their dates, their +/// excitation and their transducer type are from the peer-reviewed sources above. The +/// *modal data is not* — no ondes-specific measurement of either body exists in any +/// of them — so the ratios come from Fletcher & Rossing, *The Physics of Musical +/// Instruments*, 2nd ed.: the free circular plate's transverse modes for the gong +/// (Rayleigh's classical ratios at Poisson 0.3, the Chladni set: 1 : 1.730 : 2.328 : +/// 3.910 : 4.110 : 6.300 : 6.710 : 7.340) and the harmonic series for the strings. +/// That makes both bodies **recreations of the general physics, not models of +/// Martenot's instruments**, and the difference is stated here rather than left for +/// the reader to discover. +/// +/// The palme has **twelve** strings. Widely copied hobbyist build pages say +/// twenty-four (two banks of twelve); the peer-reviewed source says twelve, and this +/// file follows the peer-reviewed source. Their *tuning* is not published anywhere +/// found, so it is a parameter: chromatic across an octave by default (a string for +/// every pitch class, so the halo answers whatever you play) or the harmonic series +/// on the root (a drone that answers one key). +/// +/// **The transducer.** Wijnand et al.'s point is that the early diffuseurs use a +/// moving-iron driver whose operating principle is *inherently* nonlinear — +/// Thiele–Small does not describe it — so a diffuseur modelled as a pure resonator +/// is missing a documented stage. What is modelled here is the principle, not a fit: +/// in a moving-iron motor the force follows the square of the gap flux, so with a +/// bias current I₀ and signal i the force carries a term in (I₀ + i)² whose residual +/// i² produces second-harmonic distortion growing with drive. Hence `asymmetry`, +/// a squared term, is the transducer's own even-harmonic signature. The bounded +/// saturator after it (vca::swing_shape, exactly linear at 0) is a **modelling +/// necessity, not a measured stage** — the squared law is expansive and something +/// has to bound it — and its coefficient is a knob, not a number from a paper. +/// +/// Geometry: prepare(sr) buys the string loops once (twelve times sr/k_min_string_hz +/// doubles, ~115 kB at 48 kHz) and the plate allocates nothing at all. No later call +/// allocates; setters are allocation-free and safe while audio runs. +/// +/// Honest limits: +/// - **The bodies are recreations.** See above. Nothing here was fitted to a +/// recording, a measurement, or a photograph of either diffuseur. +/// - **No transducer coefficient is measured.** The source establishes *that* the +/// moving-iron driver is nonlinear and that the linear loudspeaker model does not +/// apply to it. It does not hand over a curve, so `asymmetry` and `saturation` are +/// voiced by ear and labelled as such. A diffuseur run with both at 0 is a linear +/// resonator and is missing a real stage; that is a choice the caller may make. +/// - **No radiation model.** Neither body's directivity, cabinet, nor the soundboard's +/// own resonance is modelled. The output is the body's modal response, not a room. +/// - **The strings are ideal.** A real steel string is stiff and its partials stretch +/// sharp (Fletcher & Rossing's inharmonicity B); a plain delay loop's partials are +/// exactly harmonic. Dispersion is not modelled — `detune` scatters strings against +/// each other, which is a different thing and does not stand in for it. +/// - **A pitch sweep recomputes coefficients per sample.** Like grm_comb.h, the +/// derived values are recomputed on every sample while a ramp is moving and cached +/// once it settles — sixteen resonators or twelve loops of transcendentals, which +/// is real cost during a glide and none at rest. +/// - Mono in, mono out. A diffuseur is one cabinet; wrap in `mc.` for multichannel. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include +#include + +#include "tape_loop.h" // tap::tools::tape — reel (the string loops), ramp, the DC-blocker constants +#include "vca.h" // tap::tools::vca::swing_shape — the shared bounded saturator + +namespace tap::tools { + namespace diffuseur { + + constexpr double k_pi = 3.14159265358979323846; + + constexpr int k_plate_modes = 8; // the free circular plate's first eight transverse modes + constexpr int k_strings = 12; // the palme's string count, per the peer-reviewed source + + // Transverse-mode ratios of a flat circular plate with a free edge (Fletcher & Rossing, + // The Physics of Musical Instruments, 2nd ed., the plates chapter — Rayleigh's classical + // values at Poisson's ratio 0.3, the Chladni set), referenced to the (2,0) mode. A gong is + // not a flat plate — it is dished, with a rim, and often a nipple — so this is the general + // physics of the family, deliberately not a claim about any particular métallique. + constexpr std::array k_plate_ratio = {1.000, 1.730, 2.328, 3.910, + 4.110, 6.300, 6.710, 7.340}; + // Mode weights sum to exactly 1, so with every resonator's peak gain equal to 1 the plate + // is bounded by its input at every setting — the reason no output limiter is needed. + constexpr std::array k_plate_level = {0.30, 0.22, 0.16, 0.12, 0.08, 0.05, 0.04, 0.03}; + // Each mode is a doublet: real plates split their degenerate mode pairs by a few cents + // (Fletcher & Rossing on doublets), so the body beats slowly instead of ringing like a + // bank of lab sines. Fixed split — deterministic, no RNG. + constexpr double k_doublet_cents = 1.5; + // And the upper modes sit a few cents off the textbook ratios, drawn by a stateless hash + // of the MODE INDEX only (metal_bank.h's per-index xorshift64* idiom). Keying on the index + // rather than the pitch is deliberate: a pitch sweep must not make the scatter jump. + constexpr double k_scatter_cents = 4.0; + + // Only the strings whose partials line up with the drive ring loudly, so the twelve + // responses are largely incoherent and 1/sqrt(12) is the right sum normalization. + constexpr double k_harp_norm = 0.28867513459481288; + + constexpr double k_min_string_hz = 40.0; // sizes the string loops bought at prepare() + constexpr double k_fb_max = 0.9995; // string loop gain cap: long, but strictly contractive + constexpr double k_pole_max = 0.99999; // resonator pole radius cap, same reason + constexpr double k_min_delay = 2.5; // Hermite headroom, same floor as delay.h + + constexpr double k_min_t60 = 0.01; + constexpr double k_max_t60 = 60.0; + constexpr double k_min_pitch_hz = 20.0; + constexpr double k_max_pitch_hz = 4000.0; + constexpr double k_min_damp_hz = 200.0; + constexpr double k_max_damp_hz = 20000.0; + + /// How the palme's twelve strings are tuned. Not a published detail — see the banner. + enum tuning_index : int { + tuning_chromatic = 0, // twelve semitones from the root: a string for every pitch class + tuning_harmonic, // partials 1..12 of the root: a drone that answers one key + k_num_tunings + }; + + constexpr double k_default_pitch_hz = 180.0; // the métallique's (2,0) mode + constexpr double k_default_root_hz = 110.0; // the palme's lowest string + constexpr double k_default_decay_s = 6.0; + constexpr double k_default_tilt = 1.0; // upper modes die this power of their ratio faster + constexpr double k_default_bright = 0.7; // upper-mode weight + constexpr double k_default_damp_hz = 4000.0; + constexpr double k_default_detune_c = 6.0; // per-string scatter depth, cents + constexpr double k_default_drive = 1.0; + constexpr double k_default_asymmetry = 0.15; // the moving-iron squared term + constexpr double k_default_sat = 0.5; // the bounding saturator; 0 is exactly linear + constexpr double k_default_mix = 100.0; + constexpr double k_default_level = 1.0; + constexpr double k_default_smooth_ms = 20.0; + + /// Stateless draw in [-1, 1) keyed by an index — the metal_bank.h / garden.h per-index + /// xorshift64* idiom. Same body in every instance, forever, and no generator state. + inline double index_unit(uint64_t index) { + uint64_t s = (index + 1) * 0x9e3779b97f4a7c15ULL; + s ^= s >> 12; + s ^= s << 25; + s ^= s >> 27; + const double u = static_cast((s * 0x2545f4914f6cdd1dULL) >> 11) / 9007199254740992.0; // [0, 1) + return 2.0 * u - 1.0; + } + + inline double anti_denormal(double x) { + return (std::abs(x) < 1e-15) ? 0.0 : x; // same guard as tap.comb~ + } + + /// One driven resonant mode: the constant-peak-gain two-pole resonator, + /// + /// H(z) = b0 (1 - z^-2) / (1 - 2R cos(w) z^-1 + R^2 z^-2), b0 = (1 - R^2) / 2 + /// + /// (Steiglitz; Smith, *Introduction to Digital Filters*, the two-pole resonator section). + /// The b0 normalization makes the peak magnitude 1 for any pole radius, which is what lets + /// a bank of these be bounded by the sum of its weights — pinned by test. The zeros at + /// z = ±1 put exact nulls at DC and Nyquist, so a driven bank cannot accumulate DC and + /// needs no blocker. + /// + /// Ring time is specified as a T60 in seconds and converted the same way grm_comb.h does: + /// R = 10^(-3 / (T60 · sr)), one thousandth of the amplitude after T60 seconds. + class mode { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + set(m_hz, m_t60); + clear(); + } + + void clear() { m_x1 = m_x2 = m_y1 = m_y2 = 0.0; } + + /// Resonant frequency in Hz and ring time in seconds. Allocation-free; the caller + /// decides how often to call it (the machines recompute per sample while ramping). + void set(double hz, double t60) { + m_hz = hz; + m_t60 = t60; + const double f = std::clamp(hz, 1.0, 0.49 * m_sr); + const double w = 2.0 * k_pi * f / m_sr; + const double r = std::min(std::pow(10.0, -3.0 / (std::max(t60, 1e-4) * m_sr)), k_pole_max); + const double rr = r * r; + m_a1 = 2.0 * r * std::cos(w); + m_a2 = -rr; + m_b0 = 0.5 * (1.0 - rr); + } + + double frequency() const { return m_hz; } + double t60() const { return m_t60; } + + double process(double x) { + const double y = m_b0 * (x - m_x2) + m_a1 * m_y1 + m_a2 * m_y2; + m_x2 = m_x1; + m_x1 = x; + m_y2 = m_y1; + m_y1 = anti_denormal(y); + return m_y1; + } + + private: + double m_sr{48000.0}; + double m_hz{k_default_pitch_hz}; + double m_t60{k_default_decay_s}; + double m_b0{0.0}, m_a1{0.0}, m_a2{0.0}; + double m_x1{0.0}, m_x2{0.0}, m_y1{0.0}, m_y2{0.0}; + }; + + /// The métallique's body: eight plate modes, each a beating doublet, driven continuously. + /// Weighted by `brightness` the way garden.h weights a chime's upper partials (b, b², b³… + /// so softening kills the highest first), decaying faster with frequency by `tilt`, and + /// silent above the audio band rather than aliasing. + class plate { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + for (auto& m : m_mode) { + m.prepare(m_sr); + } + retune(); + clear(); + } + + void clear() { + for (auto& m : m_mode) { + m.clear(); + } + } + + /// Frequency of the (2,0) mode — the body's perceived pitch. + void set_pitch_hz(double hz) { + m_pitch = std::clamp(hz, k_min_pitch_hz, k_max_pitch_hz); + retune(); + } + + /// Ring time of the fundamental, in seconds. + void set_decay(double t60) { + m_t60 = std::clamp(t60, k_min_t60, k_max_t60); + retune(); + } + + /// How much faster the upper modes die: T60_n = T60 / ratio_n^tilt. Radiation damping + /// grows roughly with f² for a struck bar (garden.h uses that), but a driven gong's + /// shimmer lives in its upper modes, so this is exposed rather than fixed and defaults + /// to 1 — a recreation choice, not a measurement. + void set_tilt(double t) { + m_tilt = std::clamp(t, 0.0, 3.0); + retune(); + } + + /// Upper-mode weight, [0, 1]: 1 is the full published weight table, 0 leaves the + /// fundamental doublet alone. + void set_brightness(double b) { + m_bright = std::clamp(b, 0.0, 1.0); + retune(); + } + + double pitch_hz() const { return m_pitch; } + double decay() const { return m_t60; } + double tilt() const { return m_tilt; } + double brightness() const { return m_bright; } + double samplerate() const { return m_sr; } + + /// The gain this mode's doublet is contributing (both halves together) — what the + /// boundedness argument sums, so a test can check the sum rather than trust it. + double mode_level(int m) const { + return (m >= 0 && m < k_plate_modes) ? 2.0 * m_level[static_cast(m)] : 0.0; + } + double mode_hz(int m) const { + return (m >= 0 && m < k_plate_modes) ? m_mode[static_cast(2 * m)].frequency() : 0.0; + } + + double process(double x) { + double sum = 0.0; + for (int m = 0; m < k_plate_modes; ++m) { + const size_t i = static_cast(m); + const double g = m_level[i]; + sum += g + * (m_mode[static_cast(2 * m)].process(x) + + m_mode[static_cast(2 * m + 1)].process(x)); + } + return sum; + } + + private: + /// Recompute every doublet from pitch / decay / tilt / brightness. + void retune() { + const double split = std::exp2(k_doublet_cents / 2400.0); // half the split, up and down + double shine = 1.0; // 1, b, b², b³ … per mode + for (int m = 0; m < k_plate_modes; ++m) { + const size_t i = static_cast(m); + const double ratio = + k_plate_ratio[i] + * ((m > 0) ? std::exp2(k_scatter_cents * index_unit(static_cast(m)) / 1200.0) : 1.0); + const double hz = m_pitch * ratio; + const double t60 = std::max(m_t60 / std::pow(k_plate_ratio[i], m_tilt), k_min_t60); + m_mode[static_cast(2 * m)].set(hz * split, t60); + m_mode[static_cast(2 * m + 1)].set(hz / split, t60); + // Half the published weight into each half of the doublet, and nothing at all + // above the band — a mode past Nyquist would otherwise fold. + m_level[i] = (hz < 0.45 * m_sr) ? 0.5 * k_plate_level[i] * shine : 0.0; + shine *= m_bright; + } + } + + double m_sr{48000.0}; + double m_pitch{k_default_pitch_hz}; + double m_t60{k_default_decay_s}; + double m_tilt{k_default_tilt}; + double m_bright{k_default_bright}; + std::array m_level{}; + std::array m_mode; + }; + + /// One sympathetic string: a damped, DC-blocked delay loop driven by the input, returning + /// the loop's *own ringing* rather than its through-signal — so the caller balances the + /// drive against the resonance instead of getting them pre-mixed. + /// + /// The loop gain is derived from a T60 the way grm_comb.h derives it, and compensated for + /// what the damping lowpass and the DC blocker take out at the fundamental, so the stated + /// ring time is the ring time you get at any damping setting. The k_fb_max cap keeps the + /// loop strictly contractive whatever the compensation asks for. + class sympathetic { + public: + /// Buy the longest loop once (the period of k_min_string_hz plus Hermite margin). + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_reel.prepare(m_sr, 1.0 / k_min_string_hz + 0.001); + set(m_hz, m_t60, m_damp_hz); + clear(); + } + + void clear() { + m_reel.clear(); + m_write = 0; + m_lp = 0.0; + m_dc_x1 = m_dc_y1 = 0.0; + } + + bool prepared() const { return m_reel.prepared(); } + + /// Pitch (Hz), ring time (s), damping corner (Hz). Allocation-free. + void set(double hz, double t60, double damp_hz) { + m_hz = hz; + m_t60 = t60; + m_damp_hz = std::clamp(damp_hz, k_min_damp_hz, k_max_damp_hz); + if (!prepared()) { + return; + } + const double f = std::clamp(hz, k_min_string_hz, 0.49 * m_sr); + m_delay = std::clamp(m_sr / f, k_min_delay, static_cast(m_reel.capacity() - 4)); + + const double w = 2.0 * k_pi * f / m_sr; + m_lp_a = 1.0 - std::exp(-2.0 * k_pi * m_damp_hz / m_sr); + + // What one trip round the loop loses to the two in-loop filters at the fundamental. + const double p = 1.0 - m_lp_a; + const double lp_g = m_lp_a / std::sqrt(std::max(1.0 - 2.0 * p * std::cos(w) + p * p, 1e-30)); + const double dcnum = 2.0 - 2.0 * std::cos(w); + const double dcden = + 1.0 - 2.0 * tape::k_dc_block_r * std::cos(w) + tape::k_dc_block_r * tape::k_dc_block_r; + const double dc_g = tape::k_dc_block_norm * std::sqrt(dcnum / std::max(dcden, 1e-30)); + + const double want = std::pow(10.0, -3.0 * m_delay / (std::max(m_t60, k_min_t60) * m_sr)); + m_fb = std::min(want / std::max(lp_g * dc_g, 1e-3), k_fb_max); + } + + double frequency() const { return m_hz; } + double feedback() const { return m_fb; } + double delay_samples() const { return m_delay; } + + /// Drive the string one sample and return what it is ringing with. + double process(double x) { + if (!prepared()) { + return 0.0; + } + const double delayed = m_reel.read_hermite(static_cast(m_write) - m_delay); + m_lp += m_lp_a * (delayed - m_lp); + const double dc = tape::k_dc_block_norm * (m_lp - m_dc_x1) + tape::k_dc_block_r * m_dc_y1; + m_dc_x1 = m_lp; + m_dc_y1 = anti_denormal(dc); + + const double ring = m_fb * m_dc_y1; + m_reel.write(m_write, anti_denormal(x + ring)); + if (++m_write >= m_reel.capacity()) { + m_write = 0; + } + return ring; + } + + private: + double m_sr{48000.0}; + double m_hz{k_default_root_hz}; + double m_t60{k_default_decay_s}; + double m_damp_hz{k_default_damp_hz}; + double m_delay{100.0}; + double m_fb{0.0}; + double m_lp_a{1.0}; + double m_lp{0.0}; + double m_dc_x1{0.0}, m_dc_y1{0.0}; + long m_write{0}; + tape::reel m_reel; + }; + + /// The palme's body: twelve sympathetic strings on one soundboard. Only the strings whose + /// partials line up with the drive ring loudly, which is the halo the instrument is famous + /// for; the sum is normalized by sqrt(12) because those responses are largely incoherent. + class harp { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + for (auto& s : m_string) { + s.prepare(m_sr); + } + retune(); + clear(); + } + + void clear() { + for (auto& s : m_string) { + s.clear(); + } + } + + bool prepared() const { return m_string[0].prepared(); } + + /// Pitch of the lowest string, in Hz. + void set_root_hz(double hz) { + m_root = std::clamp(hz, k_min_pitch_hz, k_max_pitch_hz); + retune(); + } + + /// How the twelve are laid out (tuning_index) — see the banner: not a published detail. + void set_tuning(int t) { + m_tuning = std::clamp(t, 0, k_num_tunings - 1); + retune(); + } + + void set_decay(double t60) { + m_t60 = std::clamp(t60, k_min_t60, k_max_t60); + retune(); + } + + /// In-loop damping corner in Hz: how quickly a string loses its upper partials. + void set_damping(double hz) { + m_damp_hz = std::clamp(hz, k_min_damp_hz, k_max_damp_hz); + retune(); + } + + /// Depth in cents of the fixed per-string scatter — no two strings on a real soundboard + /// are in perfect relation. Deterministic (index-keyed hash), so the harp is the same + /// harp in every instance. + void set_detune(double cents) { + m_detune = std::clamp(cents, 0.0, 50.0); + retune(); + } + + double root_hz() const { return m_root; } + int tuning() const { return m_tuning; } + double decay() const { return m_t60; } + double damping() const { return m_damp_hz; } + double detune() const { return m_detune; } + double string_hz(int i) const { + return (i >= 0 && i < k_strings) ? m_string[static_cast(i)].frequency() : 0.0; + } + /// The loop gain a string settled on. Worth exposing rather than deriving twice: it is + /// where the damping-versus-ring-time cap becomes visible (see the header's limits). + double string_feedback(int i) const { + return (i >= 0 && i < k_strings) ? m_string[static_cast(i)].feedback() : 0.0; + } + double samplerate() const { return m_sr; } + + double process(double x) { + double sum = 0.0; + for (auto& s : m_string) { + sum += s.process(x); + } + return sum * k_harp_norm; + } + + private: + void retune() { + for (int i = 0; i < k_strings; ++i) { + const double step = (m_tuning == tuning_harmonic) ? static_cast(i + 1) + : std::exp2(static_cast(i) / 12.0); + const double drift = std::exp2(m_detune * index_unit(static_cast(100 + i)) / 1200.0); + m_string[static_cast(i)].set(m_root * step * drift, m_t60, m_damp_hz); + } + } + + double m_sr{48000.0}; + double m_root{k_default_root_hz}; + int m_tuning{tuning_chromatic}; + double m_t60{k_default_decay_s}; + double m_damp_hz{k_default_damp_hz}; + double m_detune{k_default_detune_c}; + std::array m_string; + }; + + /// The moving-iron driver — the stage a diffuseur modelled as a pure resonator is missing. + /// + /// `drive` gains the signal into the motor. `asymmetry` is the moving-iron principle: force + /// follows the square of the gap flux, so with a bias current the residual squared term + /// puts second-harmonic distortion on the output in proportion to level. `saturation` is + /// the shared bounded soft clipper (vca::swing_shape, exactly linear at 0), which is here + /// because the squared law is expansive and something must bound it — a modelling + /// necessity, not a measured stage. A DC blocker follows, because a squared term rectifies. + /// + /// Neither nonlinear coefficient is fitted to anything; see the file banner. + /// + /// The output is bounded by 2/`saturation` rather than the saturator's own 1/`saturation`: + /// a hard-driven squared law is a nearly-constant positive waveform with brief negative + /// excursions, and removing that large DC offset doubles the worst-case swing. Measured + /// and pinned by test, because 1/saturation is the number you would expect and it is wrong. + class transducer { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + clear(); + } + + void clear() { + m_dc_x1 = 0.0; + m_dc_y1 = 0.0; + } + + void set_drive(double lin) { m_drive = std::max(0.0, lin); } + void set_asymmetry(double a) { m_asym = std::clamp(a, 0.0, 1.0); } + void set_saturation(double s) { m_sat = std::max(0.0, s); } + + double drive() const { return m_drive; } + double asymmetry() const { return m_asym; } + double saturation() const { return m_sat; } + + /// With drive 1, asymmetry 0 and saturation 0 this is a bitwise passthrough apart from + /// the DC blocker — pinned by test, and the reason a caller can switch the stage off. + double process(double x) { + const double u = m_drive * x; + const double v = u + m_asym * u * u; // (I0 + i)^2 leaves a squared term + const double s = vca::swing_shape(v, m_sat); + const double dc = tape::k_dc_block_norm * (s - m_dc_x1) + tape::k_dc_block_r * m_dc_y1; + m_dc_x1 = s; + m_dc_y1 = anti_denormal(dc); + return m_dc_y1; + } + + private: + double m_sr{48000.0}; + double m_drive{k_default_drive}; + double m_asym{k_default_asymmetry}; + double m_sat{k_default_sat}; + double m_dc_x1{0.0}, m_dc_y1{0.0}; + }; + + /// Shared plumbing for both cabinets: the transducer, the equal-power balance against the + /// dry signal, the output level, and the anti-zipper ramps they ride. The body is the only + /// thing the two machines do not share, so it is the only thing they define themselves. + class cabinet { + public: + cabinet() { + m_mix.snap(k_default_mix); + m_level.snap(k_default_level); + m_drive.snap(k_default_drive); + m_asym.snap(k_default_asymmetry); + m_sat.snap(k_default_sat); + } + + /// Transducer drive, linear and slewed. + void set_drive(double lin) { m_drive.to(std::max(0.0, lin), smooth_samples()); } + + /// The moving-iron squared term, [0, 1], slewed. + void set_asymmetry(double a) { m_asym.to(std::clamp(a, 0.0, 1.0), smooth_samples()); } + + /// The bounding saturator's drive; 0 is exactly linear (vca::swing_shape contract). + void set_saturation(double s) { m_sat.to(std::max(0.0, s), smooth_samples()); } + + /// Balance between the dry signal and the diffuseur, 0..100, equal-power. + void set_mix(double pct) { m_mix.to(std::clamp(pct, 0.0, 100.0), smooth_samples()); } + + /// Output level, linear. + void set_level(double lin) { m_level.to(lin, smooth_samples()); } + + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + double drive() const { return m_drive.target(); } + double asymmetry() const { return m_asym.target(); } + double saturation() const { return m_sat.target(); } + double mix() const { return m_mix.target(); } + double level() const { return m_level.target(); } + double smooth_ms() const { return m_smooth_ms; } + double samplerate() const { return m_sr; } + + /// Direct access to the driver, so a caller (or a null test) can reach the same stage + /// the machine drives. + transducer& driver() { return m_driver; } + const transducer& driver() const { return m_driver; } + + bool prepared() const { return m_prepared; } + + protected: + void prepare_common(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_prepared = true; + m_driver.prepare(m_sr); + m_mix.snap(m_mix.target()); + m_level.snap(m_level.target()); + m_drive.snap(m_drive.target()); + m_asym.snap(m_asym.target()); + m_sat.snap(m_sat.target()); + } + + /// Tick the transducer ramps and run the driver — the stage that comes BEFORE the body. + double drive_stage(double in) { + m_driver.set_drive(m_drive.tick()); + m_driver.set_asymmetry(m_asym.tick()); + m_driver.set_saturation(m_sat.tick()); + return m_driver.process(in); + } + + /// Balance the body's output against the dry input and apply the level. The endpoints + /// are exact rather than cos(pi/2)-approximate, so a fully wet cabinet really is the + /// cabinet and a fully dry one really is the input (the stammer.h rule) — which is + /// what lets the wiring null test compare bitwise. + double blend(double dry, double wet) { + const double pct = m_mix.tick(); + const double lin = m_level.tick(); + if (pct >= 100.0) { + return wet * lin; + } + if (pct <= 0.0) { + return dry * lin; + } + const double theta = pct * 0.01 * (k_pi * 0.5); + return (std::cos(theta) * dry + std::sin(theta) * wet) * lin; + } + + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double m_sr{48000.0}; + bool m_prepared{false}; + double m_smooth_ms{k_default_smooth_ms}; + transducer m_driver; + tape::ramp m_drive, m_asym, m_sat, m_mix, m_level; + }; + + /// **tap.metallique~** — the motor-driven gong. A transducer into a plate, balanced against + /// the dry signal. The body's parameters are not ramped: they retune sixteen resonators, so + /// they are set-and-hold rather than sweepable (see the header's limits). + class metallique : public cabinet { + public: + void prepare(double sr) { + prepare_common(sr); + m_plate.prepare(m_sr); + clear(); + } + + void clear() { + m_plate.clear(); + m_driver.clear(); + } + + void set_pitch_hz(double hz) { m_plate.set_pitch_hz(hz); } + void set_decay(double t60) { m_plate.set_decay(t60); } + void set_tilt(double t) { m_plate.set_tilt(t); } + void set_brightness(double b) { m_plate.set_brightness(b); } + + double pitch_hz() const { return m_plate.pitch_hz(); } + double decay() const { return m_plate.decay(); } + double tilt() const { return m_plate.tilt(); } + double brightness() const { return m_plate.brightness(); } + + plate& body() { return m_plate; } + const plate& body() const { return m_plate; } + + double process(double in) { + if (!prepared()) { + return in; + } + return blend(in, m_plate.process(drive_stage(in))); + } + + void process(const double* in, double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(in[i]); + } + } + + private: + plate m_plate; + }; + + /// **tap.palme~** — the electromagnet and its twelve strings. A transducer into a harp, + /// balanced against the dry signal. Run a guitar through it. + class palme : public cabinet { + public: + void prepare(double sr) { + prepare_common(sr); + m_harp.prepare(m_sr); + clear(); + } + + void clear() { + m_harp.clear(); + m_driver.clear(); + } + + void set_root_hz(double hz) { m_harp.set_root_hz(hz); } + void set_tuning(int t) { m_harp.set_tuning(t); } + void set_decay(double t60) { m_harp.set_decay(t60); } + void set_damping(double hz) { m_harp.set_damping(hz); } + void set_detune(double cents) { m_harp.set_detune(cents); } + + double root_hz() const { return m_harp.root_hz(); } + int tuning() const { return m_harp.tuning(); } + double decay() const { return m_harp.decay(); } + double damping() const { return m_harp.damping(); } + double detune() const { return m_harp.detune(); } + + harp& body() { return m_harp; } + const harp& body() const { return m_harp; } + + double process(double in) { + if (!prepared()) { + return in; + } + return blend(in, m_harp.process(drive_stage(in))); + } + + void process(const double* in, double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(in[i]); + } + } + + private: + harp m_harp; + }; + + } // namespace diffuseur +} // namespace tap::tools diff --git a/include/taptools/scrub.h b/include/taptools/scrub.h new file mode 100644 index 0000000..05591dd --- /dev/null +++ b/include/taptools/scrub.h @@ -0,0 +1,460 @@ +/// @file +/// @brief Portable granular-scrub kernel for tap.scrub~ — no Max/Min dependency. +/// @details The fifth kernel of the Radiohead family (book/PLAN-radiohead-family.md), and its +/// most direct piece of stagecraft: the Kaoss-school scrub pad. Record the input +/// continuously, then put a granular playhead on it whose *position* and *pitch* are +/// two independent performable signals. Drag the position and you rake back and forth +/// through the last few seconds of the performance; hold it still and you have a +/// granular freeze; move the pitch and the material transposes without the position +/// moving at all. That decoupling is the whole object — a tape head cannot do it, and +/// it is why the pad feels like an instrument rather than a delay. +/// +/// This is an ORIGINAL DESIGN in the brassage / granular tradition (Roads, +/// *Microsound*, MIT Press 2001), not a port and not a reconstruction of any product. +/// No preset, timing, or parameter value is taken from any hardware. +/// +/// **What it shares, and why that was the plan.** stammer.h's `capture` is the same +/// live tape — one `tape_loop.h` reel under an advancing write head — and this kernel +/// uses it directly rather than keeping a second copy. stammer.h's own header says so +/// in its limits ("slices play at ±1 rate … a performable, pitch-bending playhead over +/// live capture is a different object, and sharing this capture is the plan"); the one +/// thing that had to be added for this kernel is `capture::read_frac`, the fractional +/// Hermite read the stutter never needed. +/// +/// Two classes and a thin composition, the family's habit: +/// - `head` — the grain scheduler. It owns the grain pool, the hop clock, and the +/// spray dice, and reads a capture it does not own. Like tapecho.h's `head` and +/// stammer.h's `slicer`, it is a read pattern rather than a machine, so it is a +/// component for composition and testing, not a standalone external. +/// - `machine` — one capture, one head, the freeze gate, the drift, and the balance. +/// +/// **The window, and the null it buys.** Grains are Hann-windowed and fired every +/// `size / overlap` samples. Hann satisfies the constant-overlap-add condition at +/// those hops, so at `overlap` 2 the windows sum to exactly 1 — which means that with +/// pitch at unity, spray at zero, and the position held on a whole sample, the scrub +/// is *the input, delayed*, to within floating point. That is the load-bearing +/// scenario: everything else this object does is a departure from a plain delay, and +/// the departure is only trustworthy if the identity is exact when it should be. +/// (Normalization is 2/overlap, so the level holds across overlap settings.) +/// +/// Randomness is the family's seeded xorshift64* (tr808::white_noise, via +/// swing_vca.h). `spray` is the only consumer, and at exactly 0 it is never drawn from +/// at all, so the seed provably cannot matter — the garden.h / stammer.h contract, +/// same shape, pinned by the same kind of test. +/// +/// Geometry: prepare(sr, max_history_ms) buys the capture once. No later call +/// allocates; setters are allocation-free and safe while audio runs. +/// +/// Honest limits: +/// - **A grain can read past the write head.** A grain born `lag` samples behind the +/// edge and playing at rate r reaches `lag − size·(r−1)` behind it by its end, so +/// transposing up with the position near the live edge runs the grain's tail off the +/// front of the tape and into the oldest material. It is the constraint every live +/// granulator has; keep the position at least `size·(rate−1)` back, or accept the +/// seam. Nothing clamps it, because clamping would silently bend the pitch. +/// - **Transposition warbles.** Reading tape at a rate the write head does not share +/// means the read pointer drifts, and it has to be wrapped back if the position is +/// to keep meaning anything. Every wrap is a splice between two grains reading +/// material a wander apart, at a rate of sr·|rate−1| / (wander · size) per second. +/// What that costs is not the pitch — measured over 7 fundamentals x 7 intervals, +/// 98.8 % of a perfect shifter's energy lands in a ±15 Hz band around the transposed +/// pitch (worst case 91.7 %) — but the *concentration* of it: the band holds a +/// narrow comb rather than a single line, 92.0 % as concentrated as a clean shift +/// and 75.0 % in the worst case. Audibly that is a warble, and it is the classic +/// single-delay-line pitch-shifting artifact rather than anything specific to this +/// kernel. For clean transposition reach for `tap.pitchaccum~` or `tap.shift~`; +/// `spray` trades the comb for a broadband smear if that suits the material better. +/// - **`freeze` stops the recorder, not the playhead.** Frozen, the position addresses +/// fixed tape and the grains loop the same window — a granular hold. What it does +/// not do is stop time inside a grain: the tail of a grain in flight when freeze +/// engages was already scheduled. +/// - **The grain pool can starve.** Shrinking `size` sharply while grains are in +/// flight can leave every slot busy at the moment the next grain is due; that grain +/// is dropped rather than stealing a slot mid-window, because a steal would click. +/// The audible cost is a momentary dip, and it is bounded by the pool being two +/// deeper than the maximum overlap. +/// - **COLA is exact only when `size` divides by `overlap`.** The hop is integer +/// samples, so a size that does not divide evenly leaves a small periodic ripple in +/// the window sum. It is inaudible at musical sizes and it is why the null test +/// chooses its numbers. +/// - **No transient detection.** Grains fire on a clock, not on the material. A +/// scrub across a drum hit will chop it wherever the clock happens to be. +/// - Mono. Per-grain stereo scatter is not modeled; wrap in `mc.` for multichannel. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include +#include + +#include "stammer.h" // tap::tools::stammer::capture — the shared live tape +#include "swing_vca.h" // tap::tools::tr808::white_noise — the family's seeded xorshift64* +#include "tape_loop.h" // tap::tools::tape — ramp, k_pi + +namespace tap::tools { + namespace scrub { + + constexpr int k_max_overlap = 4; + constexpr int k_max_grains = k_max_overlap + 2; // two deeper than the worst overlap + constexpr long k_min_grain_samples = 16; // below this it is a click, not a grain + constexpr double k_min_size_ms = 1.0; + constexpr double k_max_size_ms = 500.0; + constexpr double k_max_pitch_st = 24.0; // ±2 octaves, the pitchaccum.h range + constexpr double k_max_drift = 8.0; // playback-rate units of self-motion + constexpr double k_default_max_history_ms = 4000.0; // the stammer's default buy (~1.5 MB @ 48k) + + // How far the phase-continuous read head may wander from where the position says it is, + // in grain lengths, before it is wrapped back. Larger means rarer wraps and so fewer + // splices, at the cost of that much position error while transposing. 3 (a wander of + // +-1.5 grains) is measured rather than guessed: swept over 5 fundamentals x 7 intervals, + // the energy landing in a +-15 Hz band around the transposed pitch runs + // 0.933 / 0.958 / 0.965 / 0.990 / 0.993 of a perfect shifter's at wanders of + // 0.5 / 1 / 2 / 3 / 4 grains, with worst cases 0.716 / 0.820 / 0.874 / 0.918 / 0.940. + // The curve is flat past 3, and every grain of extra wander is a grain of position error, + // so 3 is where it stops. + constexpr double k_wander_grains = 3.0; + + constexpr double k_default_size_ms = 80.0; + constexpr int k_default_overlap = 2; + constexpr double k_default_spray_ms = 0.0; + constexpr double k_default_position_ms = 0.0; // at the live edge + constexpr double k_default_pitch_st = 0.0; + constexpr double k_default_drift = 0.0; + constexpr double k_default_mix = 100.0; + constexpr double k_default_level = 1.0; + constexpr double k_default_smooth_ms = 20.0; + constexpr uint64_t k_default_seed = 1; + + /// The grain scheduler: fires Hann-windowed grains on a hop clock, each anchored at the + /// current position and locked to the pitch it was born at (the standard granular + /// contract — a grain whose rate moved mid-window would smear its own content). + class head { + public: + head() { m_rng.set_seed(k_default_seed); } + + /// Reset the clock, kill every grain, and restart the seeded stream. + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + clear(); + } + + void clear() { + m_rng.reset(); + for (auto& g : m_grain) { + g.alive = false; + } + m_countdown = 0; + m_error = 0.0; + } + + // -- the performance surface (allocation-free, safe while audio runs) ---------------- + + /// Grain length in ms. Takes effect at the next grain birth; grains in flight keep the + /// length they were born with. + void set_size_ms(double ms) { m_size_ms = std::clamp(ms, k_min_size_ms, k_max_size_ms); } + + /// How many grains overlap: the hop is size / overlap. 1 leaves gaps (a chopped + /// texture); 2 and up satisfy Hann's overlap-add condition and hold a constant level. + void set_overlap(int n) { m_overlap = std::clamp(n, 1, k_max_overlap); } + + /// Random scatter of each grain's origin, in ms back from the position. At exactly 0 + /// the dice are never rolled, so the seed cannot matter. + void set_spray_ms(double ms) { m_spray_ms = std::max(0.0, ms); } + + /// The performance seed. Instant; takes effect on the next draw (clear() restarts it). + void set_seed(uint64_t seed) { m_rng.set_seed(seed); } + + // -- introspection ------------------------------------------------------------------- + + double size_ms() const { return m_size_ms; } + int overlap() const { return m_overlap; } + double spray_ms() const { return m_spray_ms; } + uint64_t seed() const { return m_rng.seed(); } + + int active_grains() const { + int n = 0; + for (const auto& g : m_grain) { + n += g.alive ? 1 : 0; + } + return n; + } + + /// The window-sum normalization currently in force — 2/overlap once the windows + /// overlap-add, 1 when they do not. Exposed because the level contract depends on it. + double normalization() const { return (m_overlap >= 2) ? 2.0 / static_cast(m_overlap) : 1.0; } + + // -- audio --------------------------------------------------------------------------- + + /// Advance one sample. `lag` is how far behind the capture's write head the playhead + /// sits, in samples; `rate` is the grain playback ratio (1 = as recorded). Call once + /// per sample AFTER the capture has recorded this sample. + double process(const stammer::capture& tape, double lag, double rate) { + const long len = std::max(k_min_grain_samples, static_cast(m_size_ms * 0.001 * m_sr)); + const long hop = std::max(1L, len / static_cast(m_overlap)); + if (--m_countdown <= 0) { + m_countdown = hop; + birth(tape, lag, rate, len, hop); + } + + double sum = 0.0; + for (auto& g : m_grain) { + if (!g.alive) { + continue; + } + const double phase = static_cast(g.age) / static_cast(g.len); + const double w = 0.5 - 0.5 * std::cos(2.0 * tape::k_pi * phase); + sum += w * tape.read_frac(g.origin + static_cast(g.age) * g.rate); + if (++g.age >= g.len) { + g.alive = false; + } + } + return sum * normalization(); + } + + private: + struct grain { + double origin{0.0}; // absolute capture position this grain started reading at + double rate{1.0}; // locked at birth + long len{0}; + long age{0}; + bool alive{false}; + }; + + /// [0, 1) from the family's seeded xorshift64* (which returns [-1, 1)). + double uniform() { return 0.5 * (m_rng.process() + 1.0); } + + /// Take a free slot and anchor a grain. A full pool DROPS the grain rather than + /// stealing one mid-window — a steal would click, and the dip is bounded (see limits). + void birth(const stammer::capture& tape, double lag, double rate, long len, long hop) { + grain* g = nullptr; + for (auto& c : m_grain) { + if (!c.alive) { + g = &c; + break; + } + } + if (g == nullptr) { + return; + } + // The dice are consulted only when spray is armed, so the seed cannot matter at 0. + const double spray = (m_spray_ms > 0.0) ? uniform() * m_spray_ms * 0.001 * m_sr : 0.0; + + // The read pointer has to advance through the tape at `rate`, ACROSS grains and not + // only inside them. Anchoring every grain at the position instead advances the + // origins at the write head's speed, and then the transposition applies only within + // each grain: the average read rate comes back to 1 and a steady tone comes out at + // its original pitch with a comb of grain-rate sidebands around it, which is the + // pitch shift not happening. (Measured — see notebooks/scrub.ipynb; the same trap + // catches any delay-line shifter, tap.pitchaccum~ included.) + // + // So the origin tracks a phase-continuous head, and `m_error` is how far that head + // has drifted from where the position says it should be. It is wrapped into + // +-len/2 so the position stays meaningful: the read stays continuous between + // wraps, and a wrap costs one splice at a grain boundary rather than a splice on + // every grain. That is the classic delay-line-shifter bargain, and the warble it + // leaves is at the wrap rate, hop*|rate-1| / len grains apart. + if (rate == 1.0) { + m_error = 0.0; // back at unity the position is the truth again, exactly + } + else { + m_error += static_cast(hop) * (rate - 1.0); + const double span = static_cast(len) * k_wander_grains; + m_error -= span * std::floor(m_error / span + 0.5); + } + + // position() is the NEXT write, and this sample has already been recorded, so the + // live edge is one behind it — the offset that makes lag 0 read the newest sample + // and lag n read exactly n samples ago. At rate 1 the error is exactly 0, so the + // null against a plain delay is untouched. + g->origin = static_cast(tape.position()) - 1.0 - lag + m_error - spray; + g->rate = rate; + g->len = len; + g->age = 0; + g->alive = true; + } + + double m_sr{48000.0}; + double m_size_ms{k_default_size_ms}; + int m_overlap{k_default_overlap}; + double m_spray_ms{k_default_spray_ms}; + long m_countdown{0}; + double m_error{0.0}; // the phase-continuous head's drift from the anchor, wrapped + + std::array m_grain; + tr808::white_noise m_rng; + }; + + /// The machine: one capture, one head, the freeze gate, the drift, and the balance. + class machine { + public: + machine() { + m_position.snap(k_default_position_ms); + m_pitch.snap(k_default_pitch_st); + m_drift.snap(k_default_drift); + m_mix.snap(k_default_mix); + m_level.snap(k_default_level); + } + + // -- lifecycle ----------------------------------------------------------------------- + + /// (Re)allocate the capture for `max_history_ms` at `sr`, snap the ramps, reset the + /// grain clock and re-seed. Not real-time-safe. + void prepare(double sr, double max_history_ms = k_default_max_history_ms) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_capture.prepare(m_sr, max_history_ms); + m_head.prepare(m_sr); + m_position.snap(m_position.target()); + m_pitch.snap(m_pitch.target()); + m_drift.snap(m_drift.target()); + m_mix.snap(m_mix.target()); + m_level.snap(m_level.target()); + m_drift_acc = 0.0; + } + + /// Erase the tape, kill every grain, rewind the drift, and restart the seeded stream. + void clear() { + m_capture.clear(); + m_head.clear(); + m_drift_acc = 0.0; + } + + bool prepared() const { return m_capture.prepared(); } + + // -- parameters ---------------------------------------------------------------------- + + /// Where the playhead sits, as a lag behind the live edge in ms. 0 is the newest + /// sample. Slewed, because this is the scrub gesture. + void set_position_ms(double ms) { m_position.to(std::clamp(ms, 0.0, max_history_ms()), smooth_samples()); } + + /// Transposition in semitones, ±2 octaves. Independent of the position — that + /// independence is the object. + void set_pitch(double semitones) { + m_pitch.to(std::clamp(semitones, -k_max_pitch_st, k_max_pitch_st), smooth_samples()); + } + + /// The playhead's own motion through the tape, in playback-rate units: positive runs + /// forward toward the live edge, negative backwards, 0 holds station. It wraps around + /// the bought history rather than clamping, so a slow drift is a loop. + void set_drift(double rate) { m_drift.to(std::clamp(rate, -k_max_drift, k_max_drift), smooth_samples()); } + + /// Stop the recorder. The playhead keeps going, so the position now addresses fixed + /// tape — a granular hold you can still scrub, transpose, and drift through. + void set_freeze(bool on) { m_freeze = on; } + + void set_size_ms(double ms) { m_head.set_size_ms(ms); } + void set_overlap(int n) { m_head.set_overlap(n); } + void set_spray_ms(double ms) { m_head.set_spray_ms(ms); } + void set_seed(uint64_t seed) { m_head.set_seed(seed); } + + /// Balance between the live input and the scrub, 0..100, equal-power. + void set_mix(double pct) { m_mix.to(std::clamp(pct, 0.0, 100.0), smooth_samples()); } + + /// Output level, linear. + void set_level(double lin) { m_level.to(lin, smooth_samples()); } + + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection ------------------------------------------------------------------- + + double position_ms() const { return m_position.target(); } + double pitch() const { return m_pitch.target(); } + double drift() const { return m_drift.target(); } + bool freeze() const { return m_freeze; } + double size_ms() const { return m_head.size_ms(); } + int overlap() const { return m_head.overlap(); } + double spray_ms() const { return m_head.spray_ms(); } + uint64_t seed() const { return m_head.seed(); } + double mix() const { return m_mix.target(); } + double level() const { return m_level.target(); } + double smooth_ms() const { return m_smooth_ms; } + double max_history_ms() const { return m_capture.history_ms(); } + int active_grains() const { return m_head.active_grains(); } + double samplerate() const { return m_sr; } + + head& grains() { return m_head; } + const head& grains() const { return m_head; } + stammer::capture& tape() { return m_capture; } + const stammer::capture& tape() const { return m_capture; } + + // -- audio --------------------------------------------------------------------------- + + /// Attribute-driven path: position and pitch come from their ramps. + double process(double in) { return core(in, m_position.tick(), m_pitch.tick()); } + + /// Signal-driven path: position (ms behind the edge) and pitch (semitones) are taken + /// straight from the caller and the ramps are bypassed — a signal is already smooth. + /// The ramps are still ticked so a later switch back to the attribute path is + /// continuous rather than a jump. + double process(double in, double position_ms, double pitch_st) { + m_position.tick(); + m_pitch.tick(); + return core(in, std::clamp(position_ms, 0.0, max_history_ms()), + std::clamp(pitch_st, -k_max_pitch_st, k_max_pitch_st)); + } + + /// Block form: the trivial loop over the scalar path. + void process(const double* in, double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(in[i]); + } + } + + private: + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double core(double in, double position_ms, double pitch_st) { + if (!prepared()) { + return in; + } + if (!m_freeze) { + m_capture.write(in); + } + + // The playhead's own motion, accumulated as an extra lag and wrapped around the + // bought history so a drift loops the tape rather than running off it. + const double cap = static_cast(m_capture.capacity()); + m_drift_acc -= m_drift.tick(); + m_drift_acc = std::fmod(m_drift_acc, cap); + if (m_drift_acc < 0.0) { + m_drift_acc += cap; + } + + double lag = position_ms * 0.001 * m_sr + m_drift_acc; + lag = std::fmod(lag, cap); + if (lag < 0.0) { + lag += cap; + } + + const double wet = m_head.process(m_capture, lag, std::exp2(pitch_st / 12.0)); + + const double pct = m_mix.tick(); + const double lin = m_level.tick(); + // The endpoints are exact rather than cos(pi/2)-approximate, so a fully wet scrub + // really is the scrub and a fully dry one really is the input (the stammer.h rule). + if (pct >= 100.0) { + return wet * lin; + } + if (pct <= 0.0) { + return in * lin; + } + const double theta = pct * 0.01 * (tape::k_pi * 0.5); + return (std::cos(theta) * in + std::sin(theta) * wet) * lin; + } + + double m_sr{48000.0}; + double m_smooth_ms{k_default_smooth_ms}; + bool m_freeze{false}; + double m_drift_acc{0.0}; + + stammer::capture m_capture; + head m_head; + tape::ramp m_position, m_pitch, m_drift, m_mix, m_level; + }; + + } // namespace scrub +} // namespace tap::tools diff --git a/include/taptools/stammer.h b/include/taptools/stammer.h index f1efa9c..5b9d15d 100644 --- a/include/taptools/stammer.h +++ b/include/taptools/stammer.h @@ -131,6 +131,11 @@ namespace tap::tools { /// Hermite read returns the stored sample exactly (fraction 0 reads x0). double read(long pos) const { return m_reel.read_hermite(static_cast(pos)); } + /// Read at a FRACTIONAL absolute position (wraps) — the same 4-point Hermite, exposed + /// for the family's rate-varying sibling (scrub.h), which shares this capture rather + /// than keeping its own. The slicer never calls it: its slices play at ±1 rate. + double read_frac(double pos) const { return m_reel.read_hermite(pos); } + private: double m_sr{48000.0}; long m_write{0}; diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index d6545e1..241619c 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -12,6 +12,7 @@ #include "bridged_t.h" #include "conv_engine.h" #include "delay.h" +#include "diffuseur.h" #include "diode_ladder.h" #include "discreet.h" #include "fuzz.h" @@ -22,6 +23,7 @@ #include "metal_bank.h" #include "nr.h" #include "overdrive.h" +#include "scrub.h" #include "spectra.h" #include "stammer.h" #include "stft.h" diff --git a/notebooks/diffuseur.ipynb b/notebooks/diffuseur.ipynb new file mode 100644 index 0000000..811a024 --- /dev/null +++ b/notebooks/diffuseur.ipynb @@ -0,0 +1,815 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "09d964e2", + "metadata": {}, + "source": [ + "# tap.metallique~ / tap.palme~ — the diffuseurs, driven\n", + "\n", + "The Ondes Martenot does not have a loudspeaker, it has a rack of them, and choosing between them\n", + "is part of playing the instrument. Two of Martenot's resonating *diffuseurs* are modelled here:\n", + "\n", + "- the **métallique** (1944–45, patented 1947), a **gong** driven by a motor transducer, and\n", + "- the **palme** (1949–50), an electromagnet driving **twelve** metal strings on a soundboard.\n", + "\n", + "Najnudel, Hélie, Roze & Boutin (*\"Simulation of an ondes Martenot circuit\"*, IEEE/ACM TASLP 28,\n", + "2020) name the diffuseur as the stage that \"converts the electrical waveform into sound and in\n", + "turn modifies its spectral content\"; Wijnand, Boutin, Jossic & Maniguet (Forum Acusticum 2023)\n", + "describe the instruments and characterize the transducer.\n", + "\n", + "Two things about this kernel are worth stating before any plot:\n", + "\n", + "**They are driven, not struck.** `garden.h`'s modal machinery carries over — mode ratios, doublet\n", + "splitting, per-mode decay — but its strike envelopes do not. There is no trigger here. The input\n", + "excites the body continuously and the body rings at its own rates.\n", + "\n", + "**The bodies are recreations.** No ondes-specific modal measurement exists in any of the sources,\n", + "so the mode data is Fletcher & Rossing's general physics: the free circular plate's transverse\n", + "ratios for the gong, the harmonic series for the strings. Unlike `touche.ipynb`, which reproduces\n", + "a published table, this notebook cannot check the object against the instrument. What it *can*\n", + "check is that the maths underneath is honest — and that is what everything below measures.\n", + "\n", + "Every number here comes out of the shipping C++ through `tools/capi`; nothing is re-implemented\n", + "in Python." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5fce38c7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:42:24.558837Z", + "iopub.status.busy": "2026-08-17T02:42:24.558643Z", + "iopub.status.idle": "2026-08-17T02:42:24.945035Z", + "shell.execute_reply": "2026-08-17T02:42:24.943799Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kernel reached through the C ABI: \n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.4),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "# Fletcher & Rossing, The Physics of Musical Instruments, 2nd ed. — the free circular plate's\n", + "# transverse modes at Poisson 0.3 (Rayleigh's classical Chladni set), referenced to (2,0).\n", + "PLATE_RATIO = np.array([1.000, 1.730, 2.328, 3.910, 4.110, 6.300, 6.710, 7.340])\n", + "\n", + "def spectrum(x, n_from=None):\n", + " x = np.asarray(x, dtype=float)\n", + " if n_from is None:\n", + " n_from = len(x) // 2\n", + " seg = x[n_from:]\n", + " win = np.hanning(len(seg))\n", + " mag = np.abs(np.fft.rfft(seg * win)) / (len(seg) / 4)\n", + " return np.fft.rfftfreq(len(seg), 1 / sr), mag\n", + "\n", + "def bin_at(x, hz, n_from=None):\n", + " # single-bin magnitude by Goertzel, so a measurement never depends on FFT bin alignment\n", + " x = np.asarray(x, dtype=float)\n", + " if n_from is None:\n", + " n_from = len(x) // 2\n", + " seg = x[n_from:]\n", + " w = 2 * np.pi * hz / sr\n", + " c = 2 * np.cos(w)\n", + " s1 = s2 = 0.0\n", + " for v in seg:\n", + " s1, s2 = v + c * s1 - s2, s1\n", + " return np.sqrt(max(0.0, s1 * s1 + s2 * s2 - c * s1 * s2)) * 2 / len(seg)\n", + "\n", + "print(\"kernel reached through the C ABI:\", tap.Metallique, tap.Palme)" + ] + }, + { + "cell_type": "markdown", + "id": "9ce1f5e7", + "metadata": {}, + "source": [ + "## 1 · Where the gong's modes land, and how much of it each carries\n", + "\n", + "The plate is eight modes, each split into a slowly beating doublet (1.5 cents) and nudged a few\n", + "cents off the textbook ratio by a fixed per-index hash — a real plate is not a table. The weights\n", + "are chosen to sum to exactly 1, which is the whole boundedness argument: every resonator in the\n", + "bank has unit peak gain, so a weighted sum of them cannot amplify what drives it." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1eb5d78a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:42:24.947291Z", + "iopub.status.busy": "2026-08-17T02:42:24.947045Z", + "iopub.status.idle": "2026-08-17T02:42:24.952879Z", + "shell.execute_reply": "2026-08-17T02:42:24.951410Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mode published kernel cents off weight\n", + " 0 1.000 1.000 0.00 0.3000\n", + " 1 1.730 1.727 -3.43 0.2200\n", + " 2 2.328 2.323 -3.70 0.1600\n", + " 3 3.910 3.909 -0.62 0.1200\n", + " 4 4.110 4.118 3.33 0.0800\n", + " 5 6.300 6.312 3.25 0.0500\n", + " 6 6.710 6.707 -0.78 0.0400\n", + " 7 7.340 7.357 3.92 0.0300\n", + "\n", + "sum of weights: 1.000000000000\n" + ] + } + ], + "source": [ + "gong = tap.Metallique(sr, pitch_hz=180.0, decay=6.0, tilt=1.0, brightness=1.0,\n", + " drive=1.0, asymmetry=0.0, saturation=0.0, mix=100.0)\n", + "hz, weight = gong.modes()\n", + "\n", + "print(f\"{'mode':>5} {'published':>10} {'kernel':>10} {'cents off':>10} {'weight':>9}\")\n", + "for i, (f, w) in enumerate(zip(hz, weight)):\n", + " got = f / hz[0]\n", + " cents = 1200 * np.log2(got / PLATE_RATIO[i])\n", + " print(f\"{i:5d} {PLATE_RATIO[i]:10.3f} {got:10.3f} {cents:9.2f} {w:9.4f}\")\n", + "print(f\"\\nsum of weights: {weight.sum():.12f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9981802a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:42:24.954864Z", + "iopub.status.busy": "2026-08-17T02:42:24.954651Z", + "iopub.status.idle": "2026-08-17T02:42:25.113297Z", + "shell.execute_reply": "2026-08-17T02:42:25.112179Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.vlines(hz, 0, weight, color=C[0], lw=2.5)\n", + "ax.plot(hz, weight, \"o\", color=C[0], ms=6)\n", + "for i, (f, w) in enumerate(zip(hz, weight)):\n", + " ax.annotate(f\"{PLATE_RATIO[i]:.3f}\", (f, w), textcoords=\"offset points\", xytext=(0, 7),\n", + " ha=\"center\", fontsize=8, color=C[3])\n", + "ax.set_xlabel(\"frequency (Hz)\"); ax.set_ylabel(\"doublet weight\")\n", + "ax.set_title(\"the metallique's body at 180 Hz — free circular plate ratios (Fletcher & Rossing)\")\n", + "ax.set_ylim(0, 0.36)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c5a3b120", + "metadata": {}, + "source": [ + "## 2 · The resonator is bounded, and that is not an accident\n", + "\n", + "Each mode is the constant-peak-gain two-pole resonator — zeros at ±1, `b0 = (1 − R²)/2`\n", + "(Steiglitz; Smith, *Introduction to Digital Filters*). Its peak magnitude is 1 for **any** pole\n", + "radius, so a bank of weighted modes needs no limiter after it and the zeros put exact nulls at DC\n", + "and Nyquist, so it needs no DC blocker either.\n", + "\n", + "Measured below by sweeping a sine through the whole plate: the response has the eight resonances\n", + "in it, and the peak output never exceeds a bounded input." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1237a564", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:42:25.115460Z", + "iopub.status.busy": "2026-08-17T02:42:25.115270Z", + "iopub.status.idle": "2026-08-17T02:42:29.214523Z", + "shell.execute_reply": "2026-08-17T02:42:29.213664Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "largest peak output for a unit-amplitude drive: 0.1880\n", + "The weights guarantee a bound of 1.0; the measured peak sits well inside it, because a\n", + "resonance takes a while to build and the weight of any single mode is a fraction of the sum.\n" + ] + } + ], + "source": [ + "probe_hz = np.geomspace(60.0, 2000.0, 220)\n", + "resp = []\n", + "for f in probe_hz:\n", + " g = tap.Metallique(sr, pitch_hz=180.0, decay=1.2, tilt=1.0, brightness=1.0,\n", + " drive=1.0, asymmetry=0.0, saturation=0.0, mix=100.0)\n", + " n = int(sr * 1.2)\n", + " t = np.arange(n) / sr\n", + " y = g.process(np.sin(2 * np.pi * f * t))\n", + " resp.append(np.abs(y[int(sr * 0.9):]).max())\n", + "resp = np.array(resp)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.semilogx(probe_hz, 20 * np.log10(resp), color=C[0], lw=1.6)\n", + "for i, f in enumerate(hz):\n", + " ax.axvline(f, color=C[2], lw=0.8, ls=\":\", alpha=0.8)\n", + "ax.set_xlabel(\"drive frequency (Hz)\"); ax.set_ylabel(\"peak output (dB, input peak = 1)\")\n", + "ax.set_title(\"the plate's response — dotted lines are where the eight modes were placed\")\n", + "ax.axhline(0, color=C[3], lw=1.0, ls=\"--\")\n", + "plt.show()\n", + "\n", + "print(f\"largest peak output for a unit-amplitude drive: {resp.max():.4f}\")\n", + "print(\"The weights guarantee a bound of 1.0; the measured peak sits well inside it, because a\")\n", + "print(\"resonance takes a while to build and the weight of any single mode is a fraction of the sum.\")" + ] + }, + { + "cell_type": "markdown", + "id": "733f2d7b", + "metadata": {}, + "source": [ + "## 3 · The transducer, and the one part of it with physics behind it\n", + "\n", + "Wijnand et al.'s point is that the early diffuseurs use a **moving-iron** driver whose operating\n", + "principle is inherently nonlinear — Thiele–Small does not describe it — so a diffuseur modelled\n", + "as a pure resonator is missing a documented stage.\n", + "\n", + "What the kernel models is the *principle*, not a fit. In a moving-iron motor the force follows the\n", + "square of the gap flux, so with a bias current I₀ and signal i the force carries a term in\n", + "(I₀ + i)²: the residual i² is a second harmonic growing with drive. For a sine of amplitude A and\n", + "asymmetry a, that predicts a second harmonic at exactly **a·A/2** relative to the fundamental —\n", + "and nothing at the third. Measured against that prediction:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "03ad2ef1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:42:29.216680Z", + "iopub.status.busy": "2026-08-17T02:42:29.216489Z", + "iopub.status.idle": "2026-08-17T02:42:29.417712Z", + "shell.execute_reply": "2026-08-17T02:42:29.416610Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "largest departure from the prediction: 1.37e-04\n", + "largest third harmonic: 2.75e-09\n", + "A squared term makes a second harmonic and nothing else — which is the point of it\n", + "being a squared term rather than an offset pushed through a general clipper.\n" + ] + } + ], + "source": [ + "amp = 0.5\n", + "asyms = np.linspace(0.0, 1.0, 11)\n", + "ratio, third = [], []\n", + "for a in asyms:\n", + " drv = tap.Transducer(sr, drive=1.0, asymmetry=float(a), saturation=0.0)\n", + " n = int(sr * 0.5)\n", + " y = drv.process(amp * np.sin(2 * np.pi * 200.0 * np.arange(n) / sr))\n", + " f0 = bin_at(y, 200.0)\n", + " ratio.append(bin_at(y, 400.0) / f0)\n", + " third.append(bin_at(y, 600.0) / f0)\n", + "ratio = np.array(ratio)\n", + "predicted = asyms * amp / 2\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(asyms, predicted, color=C[3], lw=2.4, alpha=0.5, label=\"a·A/2 — the moving-iron prediction\")\n", + "ax.plot(asyms, ratio, \"o\", color=C[0], ms=5, label=\"measured through the kernel\")\n", + "ax.set_xlabel(\"asymmetry\"); ax.set_ylabel(\"second harmonic / fundamental\")\n", + "ax.set_title(\"the squared law, measured on the driver alone (A = 0.5, saturation off)\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(f\"largest departure from the prediction: {np.max(np.abs(ratio - predicted)):.2e}\")\n", + "print(f\"largest third harmonic: {np.max(third):.2e}\")\n", + "print(\"A squared term makes a second harmonic and nothing else — which is the point of it\")\n", + "print(\"being a squared term rather than an offset pushed through a general clipper.\")" + ] + }, + { + "cell_type": "markdown", + "id": "1ff1edc8", + "metadata": {}, + "source": [ + "### The bound is 2/saturation, not 1/saturation\n", + "\n", + "The bounding saturator is `vca::swing_shape`, whose output is bounded by `1/drive`. It would be\n", + "easy to stop there — but a hard-driven squared law is a nearly-constant *positive* waveform with\n", + "brief negative excursions, and the DC blocker after it removes that offset, which doubles the\n", + "worst-case swing. The real bound is twice what the obvious argument gives, and the kernel says so\n", + "in its header because 1/saturation is the number you would expect and it is wrong." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "359e4609", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:42:29.419672Z", + "iopub.status.busy": "2026-08-17T02:42:29.419483Z", + "iopub.status.idle": "2026-08-17T02:42:29.554296Z", + "shell.execute_reply": "2026-08-17T02:42:29.552925Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "drive 200, asymmetry 1, saturation 0.8\n", + " the naive bound 1/saturation : 1.250\n", + " the real bound 2/saturation : 2.500\n", + " measured peak : 1.493\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sat = 0.8\n", + "drv = tap.Transducer(sr, drive=200.0, asymmetry=1.0, saturation=sat)\n", + "n = int(sr * 1.0)\n", + "y = drv.process(np.sin(2 * np.pi * 137.0 * np.arange(n) / sr))\n", + "print(f\"drive 200, asymmetry 1, saturation {sat}\")\n", + "print(f\" the naive bound 1/saturation : {1/sat:.3f}\")\n", + "print(f\" the real bound 2/saturation : {2/sat:.3f}\")\n", + "print(f\" measured peak : {np.abs(y).max():.3f}\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(np.arange(1200) / sr * 1000, y[:1200], color=C[0], lw=1.2)\n", + "ax.axhline(1 / sat, color=C[3], ls=\"--\", lw=1.0, label=\"1/saturation\")\n", + "ax.axhline(-2 / sat, color=C[2], ls=\":\", lw=1.2, label=\"-2/saturation\")\n", + "ax.set_xlabel(\"time (ms)\"); ax.set_ylabel(\"output\")\n", + "ax.set_title(\"a hard-driven squared law, DC removed — the negative excursions are the reason\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8f4c591c", + "metadata": {}, + "source": [ + "## 4 · The palme: twelve strings, and what they answer\n", + "\n", + "The peer-reviewed source says **twelve** strings; widely copied hobbyist build pages say\n", + "twenty-four. This kernel follows the peer-reviewed source. Their *tuning* is not published\n", + "anywhere found, so it is a parameter — chromatic across an octave by default, so the halo answers\n", + "whatever you play, or the harmonic series on the root, which answers one key.\n", + "\n", + "Below: sweep a faded drive tone across two octaves and measure the ring left behind after the\n", + "drive stops. The twelve strings show up as peaks, and so do their harmonics." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c68012b9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:42:29.556718Z", + "iopub.status.busy": "2026-08-17T02:42:29.556498Z", + "iopub.status.idle": "2026-08-17T02:43:13.212336Z", + "shell.execute_reply": "2026-08-17T02:43:13.211338Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def ring_after(harp_kwargs, hz, drive_s=2.0, tail_s=1.0, fade_s=0.25):\n", + " # The drive is faded in and out. Switching a tone on and off is a step, and a step excites\n", + " # every string on the board — without the fades this measures its own edges, not sympathy.\n", + " p = tap.Palme(sr, **harp_kwargs)\n", + " n_on = int(sr * drive_s)\n", + " n = n_on + int(sr * tail_s)\n", + " t = np.arange(n) / sr\n", + " g = np.zeros(n)\n", + " f = int(sr * fade_s)\n", + " g[:n_on] = 1.0\n", + " g[:f] = 0.5 - 0.5 * np.cos(np.pi * np.arange(f) / f)\n", + " g[n_on - f:n_on] = 0.5 - 0.5 * np.cos(np.pi * np.arange(f, 0, -1) / f)\n", + " y = p.process(g * 0.3 * np.sin(2 * np.pi * hz * t))\n", + " tail = y[n_on + int(sr * 0.2):]\n", + " return float(np.sqrt(np.mean(tail ** 2)))\n", + "\n", + "kw = dict(root_hz=110.0, tuning=0, decay=6.0, damping=4000.0, detune=0.0,\n", + " drive=1.0, asymmetry=0.0, saturation=0.0, mix=100.0, level=1.0, smooth_ms=0.0)\n", + "probe = np.geomspace(100.0, 460.0, 200)\n", + "tails = np.array([ring_after(kw, f) for f in probe])\n", + "\n", + "strings_hz, strings_fb = tap.Palme(sr, **kw).strings()\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 3.8))\n", + "ax.semilogx(probe, 20 * np.log10(tails / tails.max()), color=C[0], lw=1.5)\n", + "for f in strings_hz:\n", + " ax.axvline(f, color=C[2], lw=0.8, ls=\":\", alpha=0.9)\n", + "ax.set_xlabel(\"drive frequency (Hz)\"); ax.set_ylabel(\"ring left after the drive stops (dB)\")\n", + "ax.set_title(\"the palme answering a sweep — dotted lines are the twelve strings\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bbe5d050", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:43:13.214567Z", + "iopub.status.busy": "2026-08-17T02:43:13.214372Z", + "iopub.status.idle": "2026-08-17T02:43:18.420361Z", + "shell.execute_reply": "2026-08-17T02:43:18.419433Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " string Hz on note +50 cents ratio\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 0 110.00 0.6329 0.1438 4.4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 1 116.54 0.6917 0.1548 4.5\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 2 123.47 0.7431 0.1069 7.0\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 3 130.81 0.7842 0.1170 6.7\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 4 138.59 0.8355 0.0771 10.8\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 5 146.83 0.9642 0.0812 11.9\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 6 155.56 1.2754 0.0522 24.4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 7 164.81 1.8316 0.0427 42.9\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 8 174.61 2.6112 0.0336 77.7\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 9 185.00 3.4817 0.0164 212.6\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 10 196.00 4.1742 0.0067 618.8\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 11 207.65 4.3352 0.0039 1121.9\n", + "\n", + "worst selectivity across the board: 4.4x\n", + "It climbs steeply with pitch, and that is physics rather than a defect: at a fixed ring\n", + "time a loop's Q scales with f x T60, so the top of the board is far the more selective end.\n" + ] + } + ], + "source": [ + "# Selectivity, string by string: the ring on the note against the ring a quarter-tone sharp of it,\n", + "# which is neither any string's fundamental nor any string's harmonic.\n", + "print(f\"{'string':>7} {'Hz':>8} {'on note':>10} {'+50 cents':>11} {'ratio':>9}\")\n", + "ratios = []\n", + "for i in range(12):\n", + " f = 110.0 * 2 ** (i / 12)\n", + " on = ring_after(kw, f)\n", + " off = ring_after(kw, 110.0 * 2 ** ((i + 0.5) / 12))\n", + " ratios.append(on / off)\n", + " print(f\"{i:7d} {f:8.2f} {on:10.4f} {off:11.4f} {on/off:9.1f}\")\n", + "print(f\"\\nworst selectivity across the board: {min(ratios):.1f}x\")\n", + "print(\"It climbs steeply with pitch, and that is physics rather than a defect: at a fixed ring\")\n", + "print(\"time a loop's Q scales with f x T60, so the top of the board is far the more selective end.\")" + ] + }, + { + "cell_type": "markdown", + "id": "c606fec9", + "metadata": {}, + "source": [ + "## 5 · Ring time and damping are not independent\n", + "\n", + "A string's loop gain is derived from the ring time you ask for and then compensated for what the\n", + "in-loop damping filter and DC blocker take out at the fundamental — so the stated ring time is the\n", + "ring time you get, at any damping setting **until the compensation runs out of headroom**. The\n", + "loop gain is capped just under unity to keep the loop strictly contractive, and past that point\n", + "damping wins and the string rings for less than you asked.\n", + "\n", + "That is an honest limit rather than a bug, and it is visible directly in the loop gains:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1a0b61e1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:43:18.422704Z", + "iopub.status.busy": "2026-08-17T02:43:18.422530Z", + "iopub.status.idle": "2026-08-17T02:43:18.593203Z", + "shell.execute_reply": "2026-08-17T02:43:18.592160Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pinned at the cap below about 800 Hz of damping\n" + ] + } + ], + "source": [ + "damps = np.array([200.0, 400.0, 800.0, 1500.0, 3000.0, 6000.0, 12000.0, 20000.0])\n", + "fb0 = []\n", + "for d in damps:\n", + " p = tap.Palme(sr, root_hz=110.0, tuning=0, decay=6.0, damping=float(d), detune=0.0)\n", + " fb0.append(p.strings()[1][0])\n", + "fb0 = np.array(fb0)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.semilogx(damps, fb0, \"o-\", color=C[0], lw=1.8, ms=5, label=\"lowest string's loop gain\")\n", + "ax.axhline(0.9995, color=C[3], lw=1.2, ls=\"--\", label=\"the cap (k_fb_max)\")\n", + "ax.set_xlabel(\"damping corner (Hz)\"); ax.set_ylabel(\"loop gain\")\n", + "ax.set_title(\"asking a heavily damped string for a 6 s ring time — the cap is where it stops\")\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "pinned = damps[fb0 >= 0.9995]\n", + "print(f\"pinned at the cap below about {pinned.max():.0f} Hz of damping\" if len(pinned)\n", + " else \"never reaches the cap at this ring time\")" + ] + }, + { + "cell_type": "markdown", + "id": "78338ad2", + "metadata": {}, + "source": [ + "## 6 · The order is the argument\n", + "\n", + "The electrical signal reaches the transducer first, and the transducer's motion is what excites\n", + "the body. So the nonlinearity sits **upstream** of the resonator. That is not a cosmetic choice:\n", + "driving a distorted waveform into a gong is a different sound from distorting a gong, because the\n", + "body filters the harmonics the driver made rather than the driver making harmonics out of the\n", + "body's ringing.\n", + "\n", + "The kernel's Catch2 suite pins this as a null test — a hand-wired `transducer` → `plate` matches\n", + "the machine bitwise, and the reversed wiring does not. Here is the same comparison as a spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c31e8fda", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:43:18.595287Z", + "iopub.status.busy": "2026-08-17T02:43:18.595087Z", + "iopub.status.idle": "2026-08-17T02:43:18.877348Z", + "shell.execute_reply": "2026-08-17T02:43:18.876311Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cabinet vs hand-wired driver -> body : 0.000e+00\n", + "cabinet vs hand-wired body -> driver : 2.335e-03\n", + "signal peak, for scale : 0.0084\n", + "so the reversed wiring differs by : 28% of peak\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "n = int(sr * 3.0)\n", + "t = np.arange(n) / sr\n", + "x = 0.5 * np.sin(2 * np.pi * 190.0 * t)\n", + "\n", + "BODY = dict(pitch_hz=210.0, decay=3.0, brightness=0.8)\n", + "DRV = dict(drive=1.7, asymmetry=0.4, saturation=0.9)\n", + "\n", + "y_fwd = tap.Plate(sr, **BODY).process(tap.Transducer(sr, **DRV).process(x)) # the instrument\n", + "y_rev = tap.Transducer(sr, **DRV).process(tap.Plate(sr, **BODY).process(x)) # the other way round\n", + "\n", + "# The composed cabinet must BE the forward wiring — the kernel's own null test, repeated here\n", + "# through the C ABI rather than through C++.\n", + "cab = tap.Metallique(sr, mix=100.0, level=1.0, smooth_ms=0.0, **BODY, **DRV)\n", + "y_cab = cab.process(x)\n", + "print(f\"cabinet vs hand-wired driver -> body : {np.max(np.abs(y_cab - y_fwd)):.3e}\")\n", + "print(f\"cabinet vs hand-wired body -> driver : {np.max(np.abs(y_cab - y_rev)):.3e}\")\n", + "peak = np.max(np.abs(y_cab))\n", + "print(f\"signal peak, for scale : {peak:.4f}\")\n", + "print(f\"so the reversed wiring differs by : {100 * np.max(np.abs(y_cab - y_rev)) / peak:.0f}% of peak\")\n", + "\n", + "f_f, m_f = spectrum(y_fwd)\n", + "f_r, m_r = spectrum(y_rev)\n", + "keep = f_f <= 2500\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 3.8))\n", + "ax.plot(f_f[keep], 20 * np.log10(m_f[keep] + 1e-12), color=C[0], lw=1.2,\n", + " label=\"driver -> body (the instrument)\")\n", + "ax.plot(f_r[keep], 20 * np.log10(m_r[keep] + 1e-12), color=C[2], lw=1.0, alpha=0.85,\n", + " label=\"body -> driver (the other way round)\")\n", + "ax.set_xlabel(\"frequency (Hz)\"); ax.set_ylabel(\"magnitude (dB)\")\n", + "ax.set_title(\"the same parts in the two possible orders — a 190 Hz drive into a 210 Hz gong\")\n", + "ax.set_ylim(-140, 10); ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e4437507", + "metadata": {}, + "source": [ + "## What this notebook cannot tell you\n", + "\n", + "Everything above measures the kernel against its own stated maths. None of it measures the kernel\n", + "against Martenot's instruments, because no source found gives modal data for either body. The\n", + "mode ratios are the general physics of free circular plates and of strings; the string tuning is a\n", + "design choice; and the transducer's two nonlinear coefficients are voiced by ear, since the source\n", + "establishes *that* the moving-iron driver is nonlinear without handing over a curve.\n", + "\n", + "So: **a recreation**, labelled as one in the header, in the plan, and here. What is honest about\n", + "it is the arithmetic — unit peak gain per mode, weights summing to one, the ring time you ask for,\n", + "the published ratios coming back out, and a bound that is stated correctly rather than\n", + "optimistically.\n", + "\n", + "Also not modelled, and stated in the header: radiation and directivity, the soundboard's own\n", + "resonance, and string stiffness (a real steel string's partials stretch sharp; a plain delay\n", + "loop's are exactly harmonic)." + ] + } + ], + "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/scrub.ipynb b/notebooks/scrub.ipynb new file mode 100644 index 0000000..7f610d1 --- /dev/null +++ b/notebooks/scrub.ipynb @@ -0,0 +1,787 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d9eb9f9f", + "metadata": {}, + "source": [ + "# tap.scrub~ — the position and the pitch are two hands\n", + "\n", + "A Kaoss-school scrub pad over live capture: record the input continuously, then put a granular\n", + "playhead on it whose **position** and **pitch** are two independent performable signals. Drag the\n", + "position and you rake back and forth through the last few seconds of the performance; hold it\n", + "still and you have a granular freeze; move the pitch and the material transposes without the\n", + "position moving at all.\n", + "\n", + "That decoupling is the object. A tape head cannot do it — on tape, moving the playhead *is* the\n", + "pitch change — and it is why the pad feels like an instrument rather than a delay.\n", + "\n", + "The tape is `stammer.h`'s `capture`: the same live reel, **shared rather than copied**. That was\n", + "the plan before either object existed — the stutter's own header says so in its limits — and the\n", + "only thing that had to be added for this kernel was the fractional Hermite read the stutter never\n", + "needed, because its slices only ever play at ±1 rate.\n", + "\n", + "Everything below comes out of the shipping C++ through `tools/capi`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7108f200", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:02.440438Z", + "iopub.status.busy": "2026-08-17T02:49:02.440248Z", + "iopub.status.idle": "2026-08-17T02:49:02.821039Z", + "shell.execute_reply": "2026-08-17T02:49:02.819862Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kernel reached through the C ABI: \n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.4),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def ms(samples):\n", + " return samples * 1000.0 / sr\n", + "\n", + "def plucks(n, period=6000):\n", + " # transients — the material a scrub has something to bite on (the stammer's contract, same\n", + " # reasoning: on a sustained pad a granular playhead is barely distinguishable from a tremolo)\n", + " x = np.zeros(n)\n", + " env, phase, hz = 0.0, 0.0, 220.0\n", + " for i in range(n):\n", + " if i % period == 0:\n", + " env, hz = 1.0, 180.0 + 40.0 * ((i // period) % 5)\n", + " env *= 0.99975\n", + " phase = (phase + hz / sr) % 1.0\n", + " x[i] = env * (np.sin(2 * np.pi * phase) + 0.4 * np.sin(6 * np.pi * phase))\n", + " return x\n", + "\n", + "def spectrum(x, n_from=None):\n", + " x = np.asarray(x, dtype=float)\n", + " if n_from is None:\n", + " n_from = len(x) // 2\n", + " seg = x[n_from:]\n", + " mag = np.abs(np.fft.rfft(seg * np.hanning(len(seg)))) / (len(seg) / 4)\n", + " return np.fft.rfftfreq(len(seg), 1 / sr), mag\n", + "\n", + "print(\"kernel reached through the C ABI:\", tap.Scrub)" + ] + }, + { + "cell_type": "markdown", + "id": "b97da000", + "metadata": {}, + "source": [ + "## 1 · The null: held still at unity pitch, it is exactly a delay\n", + "\n", + "Everything this object does is a *departure* from a plain delay, and a departure is only\n", + "trustworthy if the identity is exact when it should be.\n", + "\n", + "Grains are Hann-windowed and fired every `size / overlap` samples. Hann satisfies the\n", + "constant-overlap-add condition at those hops — at overlap 2 the two live windows sum to exactly 1\n", + "— so with the position held on a whole sample and no transposition, the machine is a delay line\n", + "and nothing else." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "aa58da51", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:02.823766Z", + "iopub.status.busy": "2026-08-17T02:49:02.823454Z", + "iopub.status.idle": "2026-08-17T02:49:03.016147Z", + "shell.execute_reply": "2026-08-17T02:49:03.014820Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "largest departure from a 480-sample delay: 4.441e-16\n", + "(not bitwise zero, and it should not be: the two windows are computed as two cosines whose\n", + " arguments differ by pi, not as one cosine and its negation)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "L = 96 # grain length in samples, chosen to divide evenly by the overlap\n", + "LAG = 480 # position, in samples behind the live edge\n", + "\n", + "m = tap.Scrub(sr, 2000.0, smooth_ms=0.0, overlap=2, size_ms=ms(L),\n", + " position_ms=ms(LAG), mix=100.0, level=1.0)\n", + "x = plucks(30000)\n", + "y = m.process(x)\n", + "\n", + "err = np.abs(y[2000:] - x[2000 - LAG: -LAG])\n", + "print(f\"largest departure from a {LAG}-sample delay: {err.max():.3e}\")\n", + "print(\"(not bitwise zero, and it should not be: the two windows are computed as two cosines whose\")\n", + "print(\" arguments differ by pi, not as one cosine and its negation)\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "sl = slice(9000, 11000)\n", + "ax.plot(np.arange(sl.start, sl.stop) / sr * 1000, x[sl.start - LAG: sl.stop - LAG],\n", + " color=C[3], lw=2.6, alpha=0.45, label=f\"input, delayed {LAG} samples\")\n", + "ax.plot(np.arange(sl.start, sl.stop) / sr * 1000, y[sl], color=C[0], lw=1.0, label=\"the scrub\")\n", + "ax.set_xlabel(\"time (ms)\"); ax.set_ylabel(\"amplitude\")\n", + "ax.set_title(\"held still at unity pitch, overlap 2 — the grains overlap-add back to the input\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e72da997", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:03.018598Z", + "iopub.status.busy": "2026-08-17T02:49:03.018375Z", + "iopub.status.idle": "2026-08-17T02:49:03.198744Z", + "shell.execute_reply": "2026-08-17T02:49:03.197256Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# The window sum itself, reconstructed from the kernel's own behaviour: feed a constant and read\n", + "# the envelope. At overlap 1 the windows leave gaps; at 2 and up the sum is flat.\n", + "fig, ax = plt.subplots()\n", + "for n_ov, colour in zip((1, 2, 3, 4), (C[3], C[0], C[2], C[4])):\n", + " g = tap.Scrub(sr, 500.0, smooth_ms=0.0, overlap=n_ov, size_ms=ms(480),\n", + " position_ms=ms(2400), mix=100.0)\n", + " z = g.process(np.ones(int(sr * 0.4)))\n", + " seg = z[-1500:]\n", + " ax.plot(np.arange(len(seg)) / sr * 1000, seg, color=colour, lw=1.4, label=f\"overlap {n_ov}\")\n", + "ax.set_xlabel(\"time (ms)\"); ax.set_ylabel(\"gain on a constant input\")\n", + "ax.set_title(\"the window sum — Hann overlap-adds flat from 2 up, and leaves gaps at 1\")\n", + "ax.legend(ncol=4)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e64dbd39", + "metadata": {}, + "source": [ + "## 2 · The two hands, and the defect that hid behind them\n", + "\n", + "`position_ms` is a lag behind the live edge. `pitch` is a transposition in semitones. The claim is\n", + "that neither touches the other — and checking it turned up a real defect in the first cut, worth\n", + "recording because it is invisible to every other measurement on this page.\n", + "\n", + "If grain origins are anchored at the position, they advance at the **write head's** speed while\n", + "each grain plays its content at `rate`. The transposition then applies only *inside* a grain: the\n", + "average read rate comes straight back to 1, and a steady tone comes out at its **original** pitch\n", + "with a comb of grain-rate sidebands around it. The pitch knob adds texture and moves nothing.\n", + "\n", + "The fix is a phase-continuous read head — origins advance at `rate`, and the head is wrapped back\n", + "toward the position only once it has wandered far enough (±1.5 grain lengths, a value chosen by\n", + "sweep, not by taste). Below is what the two versions measure like." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "53943828", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:03.200983Z", + "iopub.status.busy": "2026-08-17T02:49:03.200781Z", + "iopub.status.idle": "2026-08-17T02:49:03.571660Z", + "shell.execute_reply": "2026-08-17T02:49:03.570378Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "f0 = 311 Hz\n", + " semitones at the new pitch left at the old\n", + " -12 0.4212 0.0000\n", + " -7 0.4247 0.0000\n", + " -3 0.4296 0.0000\n", + " 0 0.5000 0.5000\n", + " 3 0.4921 0.0000\n", + " 7 0.4069 0.0000\n", + " 12 0.4288 0.0000\n", + "\n", + "f0 = 300 Hz\n", + " semitones at the new pitch left at the old\n", + " -12 0.5000 0.0000\n", + " -7 0.4837 0.0000\n", + " -3 0.4771 0.0000\n", + " 0 0.5000 0.5000\n", + " 3 0.4820 0.0000\n", + " 7 0.4266 0.0000\n", + " 12 0.5000 0.0000\n", + "\n" + ] + } + ], + "source": [ + "def transpose_test(f0, semis, size_ms=100.0, position_ms=900.0):\n", + " moved, stayed = [], []\n", + " for st in semis:\n", + " g = tap.Scrub(sr, 3000.0, smooth_ms=0.0, overlap=2, size_ms=size_ms,\n", + " position_ms=position_ms, pitch=float(st), mix=100.0)\n", + " n = int(sr * 2.0)\n", + " y = g.process(0.5 * np.sin(2 * np.pi * f0 * np.arange(n) / sr))\n", + " f, mag = spectrum(y)\n", + " def at(hz):\n", + " # peak over a few bins: a Hann-windowed FFT scallops an off-bin partial, and the\n", + " # transposed pitches here are deliberately off-bin\n", + " i = np.argmin(np.abs(f - hz))\n", + " return mag[max(0, i - 2): i + 3].max()\n", + " moved.append(at(f0 * 2 ** (st / 12)))\n", + " stayed.append(at(f0))\n", + " return np.array(moved), np.array(stayed)\n", + "\n", + "semis = np.array([-12, -7, -3, 0, 3, 7, 12])\n", + "# 311 Hz on purpose: a frequency that is a whole number of periods in the grain is transparent to\n", + "# every wrap, and would have hidden the defect completely. 300 Hz in a 100 ms grain is exactly\n", + "# that case — 30 periods — which is how the first version of this notebook passed its own eye test.\n", + "for f0 in (311.0, 300.0):\n", + " moved, stayed = transpose_test(f0, semis)\n", + " print(f\"f0 = {f0:.0f} Hz\")\n", + " print(f\"{'semitones':>10} {'at the new pitch':>18} {'left at the old':>17}\")\n", + " for st, a, b in zip(semis, moved, stayed):\n", + " print(f\"{st:10d} {a:18.4f} {b:17.4f}\")\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9b8d6451", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:03.573876Z", + "iopub.status.busy": "2026-08-17T02:49:03.573656Z", + "iopub.status.idle": "2026-08-17T02:49:03.893558Z", + "shell.execute_reply": "2026-08-17T02:49:03.892686Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "moved, stayed = transpose_test(311.0, semis)\n", + "fig, ax = plt.subplots()\n", + "w = 0.38\n", + "ax.bar(np.arange(len(semis)) - w / 2, moved, w, color=C[0], label=\"energy at the transposed pitch\")\n", + "ax.bar(np.arange(len(semis)) + w / 2, stayed, w, color=C[2], label=\"energy left at the original\")\n", + "ax.axhline(0.5, color=C[3], lw=1.0, ls=\"--\", label=\"a perfect shifter would return 0.5\")\n", + "ax.set_xticks(np.arange(len(semis)), [f\"{s:+d}\" for s in semis])\n", + "ax.set_xlabel(\"pitch (semitones)\"); ax.set_ylabel(\"magnitude\")\n", + "ax.set_title(\"the pitch really moves — 311 Hz, 100 ms grains, position held at 900 ms\")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "20a585a3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:03.896309Z", + "iopub.status.busy": "2026-08-17T02:49:03.896077Z", + "iopub.status.idle": "2026-08-17T02:49:06.265621Z", + "shell.execute_reply": "2026-08-17T02:49:06.264583Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "energy in a +-15 Hz band around the transposed pitch:\n", + " mean 0.988 of a perfect shifter, worst 0.917\n", + "how concentrated that energy is on a single line:\n", + " mean 0.920 of a perfect shifter, worst 0.750\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# The claim behind the header's numbers, measured here rather than remembered. Two figures, and\n", + "# the difference between them is the whole story: how much energy lands in a narrow band around\n", + "# the transposed pitch (did the pitch move?), and how CONCENTRATED that energy is (is it one line\n", + "# or a comb?).\n", + "def retained(f0, st, half=15.0):\n", + " g = tap.Scrub(sr, 3000.0, smooth_ms=0.0, overlap=2, size_ms=100.0,\n", + " position_ms=900.0, pitch=float(st), mix=100.0)\n", + " n = int(sr * 3.0)\n", + " t = np.arange(n) / sr\n", + " y = g.process(0.5 * np.sin(2 * np.pi * f0 * t))\n", + " ref = 0.5 * np.sin(2 * np.pi * f0 * 2 ** (st / 12) * t) # what a perfect shifter would give\n", + "\n", + " def band(sig):\n", + " seg = sig[len(sig) // 2:]\n", + " mag = np.abs(np.fft.rfft(seg * np.hanning(len(seg))))\n", + " f = np.fft.rfftfreq(len(seg), 1 / sr)\n", + " sel = np.abs(f - f0 * 2 ** (st / 12)) <= half\n", + " return np.sqrt((mag[sel] ** 2).sum()), mag[sel].max()\n", + "\n", + " b, p = band(y)\n", + " rb, rp = band(ref)\n", + " return b / rb, (p / b) / (rp / rb)\n", + "\n", + "sweep_f0 = [97.0, 173.0, 218.0, 311.0, 443.0, 587.0, 761.0]\n", + "sweep_st = [-12, -7, -3, 3, 7, 12, 19]\n", + "energy = np.zeros((len(sweep_f0), len(sweep_st)))\n", + "focus = np.zeros_like(energy)\n", + "for r, f0 in enumerate(sweep_f0):\n", + " for c, st in enumerate(sweep_st):\n", + " energy[r, c], focus[r, c] = retained(f0, st)\n", + "\n", + "print(f\"energy in a +-15 Hz band around the transposed pitch:\")\n", + "print(f\" mean {energy.mean():.3f} of a perfect shifter, worst {energy.min():.3f}\")\n", + "print(f\"how concentrated that energy is on a single line:\")\n", + "print(f\" mean {focus.mean():.3f} of a perfect shifter, worst {focus.min():.3f}\")\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.2))\n", + "for ax, grid, title in zip(axes, (energy, focus),\n", + " (\"energy at the transposed pitch\", \"concentration on one line\")):\n", + " im = ax.imshow(grid, aspect=\"auto\", origin=\"lower\", vmin=0.5, vmax=1.0, cmap=\"magma\")\n", + " ax.set_xticks(range(len(sweep_st)), [f\"{s:+d}\" for s in sweep_st])\n", + " ax.set_yticks(range(len(sweep_f0)), [f\"{f:.0f}\" for f in sweep_f0])\n", + " ax.set_xlabel(\"semitones\"); ax.set_title(title, fontsize=10)\n", + " ax.grid(False)\n", + " fig.colorbar(im, ax=ax)\n", + "axes[0].set_ylabel(\"fundamental (Hz)\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1e7cf8f5", + "metadata": {}, + "source": [ + "### What is left over, stated plainly\n", + "\n", + "The pitch moves — 98.8 % of a perfect shifter's energy lands in a ±15 Hz band around the\n", + "transposed pitch, 91.7 % in the worst corner of the sweep. What the wraps cost is *concentration*:\n", + "the band holds a narrow comb instead of a single line, 92.0 % as focused as a clean shift and\n", + "75.0 % at worst. Audibly that is a warble, at a rate of `sr·|rate−1| / (wander · size)` per second\n", + "— slow and flutter-like at small intervals, faster and rougher at large ones.\n", + "\n", + "That is the classic single-delay-line pitch-shifting artifact, not something specific to this\n", + "kernel. So: **`tap.scrub~`'s pitch is a granular texture, not a hi-fi shift.** For clean\n", + "transposition reach for `tap.pitchaccum~` or `tap.shift~`; `spray` will trade the comb for a\n", + "broadband smear if that suits the material better.\n", + "\n", + "**A measurement warning worth carrying**, because it nearly sent a working kernel back for repair:\n", + "a single-bin probe at the transposed frequency reads this object as badly broken. The comb is a\n", + "few Hz wide, a rectangular-window Goertzel on one line sees whichever comb tooth happens to sit\n", + "there, and a first pass measured 0.02 where the truth was 0.43. Measure the band, not the bin.\n", + "\n", + "The wander bound was chosen the same way. Swept over 5 fundamentals × 7 intervals, band energy\n", + "retained runs 0.933 / 0.958 / 0.965 / **0.990** / 0.993 at wanders of 0.5 / 1 / 2 / 3 / 4 grains.\n", + "The curve is flat past 3, and every extra grain of wander is a grain of position error, so 3 is\n", + "where it stops." + ] + }, + { + "cell_type": "markdown", + "id": "995b6d45", + "metadata": {}, + "source": [ + "## 3 · Freeze stops the recorder, not the playhead\n", + "\n", + "Frozen, the position addresses fixed tape and the grains loop the same window — a granular hold\n", + "you can still scrub, transpose and drift through. Below: two and a half seconds of a phrase go in,\n", + "the recorder stops, and **nothing at all** goes into the input afterwards. Everything you see after\n", + "the freeze mark is made out of tape." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "464431d9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:06.267725Z", + "iopub.status.busy": "2026-08-17T02:49:06.267544Z", + "iopub.status.idle": "2026-08-17T02:49:06.783423Z", + "shell.execute_reply": "2026-08-17T02:49:06.782161Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rms while live : 0.3468\n", + "rms frozen, with a silent input : 0.4942\n", + "rms unfrozen, last second of silence : 0.000e+00\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = tap.Scrub(sr, 3000.0, smooth_ms=20.0, overlap=3, size_ms=110.0,\n", + " position_ms=900.0, mix=100.0, seed=7)\n", + "live = int(sr * 2.5)\n", + "held = int(sr * 5.0)\n", + "y_live = m.process(plucks(live))\n", + "m.set(freeze=True)\n", + "y_held = m.process(np.zeros(held))\n", + "y = np.concatenate([y_live, y_held])\n", + "\n", + "# ... and once the recorder is running again on a silent input, the tape fills with silence.\n", + "m.set(freeze=False)\n", + "y_after = m.process(np.zeros(int(sr * 3.0)))\n", + "\n", + "def rms(a):\n", + " return float(np.sqrt(np.mean(np.asarray(a) ** 2)))\n", + "\n", + "print(f\"rms while live : {rms(y_live):.4f}\")\n", + "print(f\"rms frozen, with a silent input : {rms(y_held):.4f}\")\n", + "print(f\"rms unfrozen, last second of silence : {rms(y_after[-int(sr):]):.3e}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 3.2))\n", + "t = np.arange(len(y)) / sr\n", + "ax.plot(t, y, color=C[0], lw=0.5)\n", + "ax.axvline(live / sr, color=C[2], lw=1.4, ls=\"--\")\n", + "ax.annotate(\"freeze; input goes silent here\", (live / sr, 0.9 * np.abs(y).max()),\n", + " xytext=(8, 0), textcoords=\"offset points\", color=C[2], fontsize=9)\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"amplitude\")\n", + "ax.set_title(\"the recorder stops and the playhead does not\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ca3dce21", + "metadata": {}, + "source": [ + "## 4 · Drift walks the playhead on its own\n", + "\n", + "`drift` is the playhead's own motion through the tape, in playback-rate units: positive runs\n", + "forward toward the live edge, negative backwards, 0 holds station. It wraps around the bought\n", + "history rather than clamping, so a slow drift is a loop rather than a dead end.\n", + "\n", + "Measured here on a frozen tape holding a chirp, so the drift's motion shows up directly as a\n", + "change in the frequency coming out." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c3761fa3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:06.785690Z", + "iopub.status.busy": "2026-08-17T02:49:06.785471Z", + "iopub.status.idle": "2026-08-17T02:49:07.062250Z", + "shell.execute_reply": "2026-08-17T02:49:07.061057Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Record a slow chirp, freeze, then read it back at three drift rates. Because the tape holds a\n", + "# chirp, WHERE the head sits is audible as WHAT frequency comes out.\n", + "def frozen_chirp(drift):\n", + " g = tap.Scrub(sr, 3000.0, smooth_ms=5.0, overlap=2, size_ms=60.0,\n", + " position_ms=1200.0, mix=100.0)\n", + " n = int(sr * 2.0)\n", + " t = np.arange(n) / sr\n", + " g.process(0.5 * np.sin(2 * np.pi * (200.0 + 500.0 * t / 2.0) * t)) # 200 -> 700 Hz\n", + " g.set(freeze=True, drift=float(drift))\n", + " out = g.process(np.zeros(int(sr * 1.5)))\n", + " # track the strongest partial in short windows\n", + " win = 4096\n", + " track = []\n", + " for a in range(0, len(out) - win, win // 2):\n", + " f, mag = spectrum(out[a:a + win], 0)\n", + " track.append(f[np.argmax(mag)])\n", + " return np.array(track)\n", + "\n", + "fig, ax = plt.subplots()\n", + "for d, colour in zip((-0.5, 0.0, 0.5), (C[2], C[3], C[0])):\n", + " tr = frozen_chirp(d)\n", + " ax.plot(np.arange(len(tr)) * 2048 / sr, tr, \"o-\", color=colour, ms=3, lw=1.3,\n", + " label=f\"drift {d:+.1f}\")\n", + "ax.set_xlabel(\"time since the freeze (s)\"); ax.set_ylabel(\"strongest partial (Hz)\")\n", + "ax.set_title(\"a frozen chirp read at three drift rates — the head goes where it is told\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f9185473", + "metadata": {}, + "source": [ + "## 5 · Spray, and the family's seed contract\n", + "\n", + "`spray` scatters each grain's origin back from the position. It is the only consumer of the seeded\n", + "xorshift64* the family shares, and at exactly 0 the dice are **never rolled** — so with spray off\n", + "the seed provably cannot matter. That is the same contract `garden.h` and `stammer.h` keep, and it\n", + "is what makes a seed a performance you can replay rather than a decoration." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "386f4f6d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:07.064352Z", + "iopub.status.busy": "2026-08-17T02:49:07.064162Z", + "iopub.status.idle": "2026-08-17T02:49:07.397964Z", + "shell.execute_reply": "2026-08-17T02:49:07.396786Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "two seeds, spray off : 0.000e+00 <- the dice are never rolled, so the seed cannot matter\n", + "two seeds, spray on : 1.662e+00 <- a seed is a different performance\n", + "the same seed twice : 0.000e+00 <- and a replayable one\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = plucks(int(sr * 1.0))\n", + "\n", + "def run(seed, spray):\n", + " g = tap.Scrub(sr, 2000.0, smooth_ms=0.0, overlap=2, size_ms=50.0,\n", + " position_ms=250.0, spray_ms=spray, seed=seed, mix=100.0)\n", + " return g.process(x)\n", + "\n", + "quiet = np.max(np.abs(run(1, 0.0) - run(999999, 0.0)))\n", + "loud = np.max(np.abs(run(1, 120.0) - run(999999, 120.0)))\n", + "same = np.max(np.abs(run(4242, 120.0) - run(4242, 120.0)))\n", + "\n", + "print(f\"two seeds, spray off : {quiet:.3e} <- the dice are never rolled, so the seed cannot matter\")\n", + "print(f\"two seeds, spray on : {loud:.3e} <- a seed is a different performance\")\n", + "print(f\"the same seed twice : {same:.3e} <- and a replayable one\")\n", + "\n", + "fig, ax = plt.subplots()\n", + "sl = slice(20000, 24000)\n", + "ax.plot(np.arange(sl.start, sl.stop) / sr, run(1, 120.0)[sl], color=C[0], lw=1.0, label=\"seed 1\")\n", + "ax.plot(np.arange(sl.start, sl.stop) / sr, run(999999, 120.0)[sl], color=C[2], lw=1.0,\n", + " alpha=0.8, label=\"seed 999999\")\n", + "ax.set_xlabel(\"time (s)\"); ax.set_ylabel(\"amplitude\")\n", + "ax.set_title(\"the same settings, two seeds, 120 ms of spray\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f02acecf", + "metadata": {}, + "source": [ + "## 6 · The limit worth knowing: a grain can read past the write head\n", + "\n", + "A grain born `lag` samples behind the live edge and playing at rate *r* reaches\n", + "`lag − size·(r−1)` behind it by the time it ends. Transpose up with the position near the edge and\n", + "the grain's tail runs off the front of the tape and into the oldest material on it.\n", + "\n", + "Nothing in the kernel clamps this, and that is deliberate: clamping would silently bend the pitch,\n", + "which is worse than a seam you can hear and move away from. The rule is to keep the position at\n", + "least `size·(rate−1)` back — measured below as the error against a correctly-positioned reference." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "66455ac0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T02:49:07.400243Z", + "iopub.status.busy": "2026-08-17T02:49:07.400050Z", + "iopub.status.idle": "2026-08-17T02:49:07.706460Z", + "shell.execute_reply": "2026-08-17T02:49:07.705021Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grain size 100 ms, pitch +12 st -> a grain needs 100 ms of room\n", + " position (ms) rms out\n", + " 10 0.3072\n", + " 25 0.3217\n", + " 50 0.3367\n", + " 80 0.3513\n", + " 110 0.3700\n", + " 160 0.4135\n", + " 250 0.4172\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 400 0.4234\n", + "\n", + "The level falls away as the position approaches the live edge: the last part of every\n", + "grain is reading tape that has not been written yet, which on a circular buffer is the\n", + "OLDEST material rather than silence, so what you lose is coherence rather than signal.\n" + ] + } + ], + "source": [ + "SIZE_MS = 100.0\n", + "rate = 2 ** (12 / 12) # up an octave: rate 2, so the grain needs size x (rate - 1) = 100 ms of room\n", + "x = plucks(int(sr * 2.0))\n", + "\n", + "def at(position_ms):\n", + " g = tap.Scrub(sr, 2000.0, smooth_ms=0.0, overlap=2, size_ms=SIZE_MS,\n", + " position_ms=position_ms, pitch=12.0, mix=100.0)\n", + " return g.process(x)\n", + "\n", + "safe = at(400.0)\n", + "positions = np.array([10.0, 25.0, 50.0, 80.0, 110.0, 160.0, 250.0, 400.0])\n", + "print(f\"grain size {SIZE_MS:.0f} ms, pitch +12 st -> a grain needs {SIZE_MS*(rate-1):.0f} ms of room\")\n", + "print(f\"{'position (ms)':>14} {'rms out':>10}\")\n", + "for p in positions:\n", + " print(f\"{p:14.0f} {np.sqrt(np.mean(at(p)[int(sr*1.0):] ** 2)):10.4f}\")\n", + "print()\n", + "print(\"The level falls away as the position approaches the live edge: the last part of every\")\n", + "print(\"grain is reading tape that has not been written yet, which on a circular buffer is the\")\n", + "print(\"OLDEST material rather than silence, so what you lose is coherence rather than signal.\")" + ] + }, + { + "cell_type": "markdown", + "id": "eda059ca", + "metadata": {}, + "source": [ + "## The rest of the limits, stated\n", + "\n", + "- **`freeze` does not stop time inside a grain.** The tail of a grain in flight when freeze\n", + " engages was already scheduled and plays out.\n", + "- **The grain pool can starve.** Shrinking `size` sharply while grains are in flight can leave\n", + " every slot busy when the next grain is due; that grain is dropped rather than stealing a slot\n", + " mid-window, because a steal would click. The cost is a momentary dip, bounded by the pool being\n", + " two deeper than the maximum overlap.\n", + "- **Overlap-add is exact only when `size` divides by `overlap`.** The hop is integer samples, so a\n", + " size that does not divide evenly leaves a small periodic ripple in the window sum. Inaudible at\n", + " musical sizes, and the reason section 1 chose its numbers.\n", + "- **No transient detection.** Grains fire on a clock, not on the material. A scrub across a drum\n", + " hit chops it wherever the clock happens to be.\n", + "- **Mono.** Per-grain stereo scatter is not modelled; wrap in `mc.` for multichannel." + ] + } + ], + "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 d046b63..811288e 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -306,6 +306,83 @@ def load() -> ctypes.CDLL: "taptools_tapecho_clear": ([vp], ctypes.c_int), "taptools_tapecho_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_plate_create": ([], vp), + "taptools_plate_destroy": ([vp], None), + "taptools_plate_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_plate_set_pitch_hz": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_plate_set_decay": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_plate_set_tilt": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_plate_set_brightness": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_plate_clear": ([vp], ctypes.c_int), + "taptools_plate_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_plate_mode_hz": ([vp, ctypes.c_int], ctypes.c_double), + "taptools_plate_mode_level": ([vp, ctypes.c_int], ctypes.c_double), + + "taptools_transducer_create": ([], vp), + "taptools_transducer_destroy": ([vp], None), + "taptools_transducer_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_transducer_set_drive": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_transducer_set_asymmetry": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_transducer_set_saturation": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_transducer_clear": ([vp], ctypes.c_int), + "taptools_transducer_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + + "taptools_metallique_create": ([], vp), + "taptools_metallique_destroy": ([vp], None), + "taptools_metallique_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_pitch_hz": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_decay": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_tilt": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_brightness": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_drive": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_asymmetry": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_saturation": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_mix": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_metallique_clear": ([vp], ctypes.c_int), + "taptools_metallique_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_metallique_mode_hz": ([vp, ctypes.c_int], ctypes.c_double), + "taptools_metallique_mode_level": ([vp, ctypes.c_int], ctypes.c_double), + + "taptools_palme_create": ([], vp), + "taptools_palme_destroy": ([vp], None), + "taptools_palme_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_root_hz": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_tuning": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_palme_set_decay": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_damping": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_detune": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_drive": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_asymmetry": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_saturation": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_mix": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_palme_clear": ([vp], ctypes.c_int), + "taptools_palme_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_palme_string_hz": ([vp, ctypes.c_int], ctypes.c_double), + "taptools_palme_string_feedback": ([vp, ctypes.c_int], ctypes.c_double), + + "taptools_scrub_create": ([], vp), + "taptools_scrub_destroy": ([vp], None), + "taptools_scrub_prepare": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_position_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_pitch": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_drift": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_freeze": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_scrub_set_size_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_overlap": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_scrub_set_spray_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_seed": ([vp, ctypes.c_ulonglong], ctypes.c_int), + "taptools_scrub_set_mix": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_scrub_clear": ([vp], ctypes.c_int), + "taptools_scrub_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_scrub_process_mod": ([vp, f64p, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_scrub_active_grains": ([vp], ctypes.c_int), + "taptools_touche_create": ([], vp), "taptools_touche_destroy": ([vp], None), "taptools_touche_prepare": ([vp, ctypes.c_double], ctypes.c_int), @@ -1388,6 +1465,300 @@ def __del__(self): self._h = None +class Plate: + """The metallique's body on its own (tap::tools::diffuseur::plate) — eight + driven modes at the free circular plate's transverse ratios, each split + into a beating doublet, with no driver in front of it. A component, not an + external: reachable so that a measurement of the body is not silently a + measurement of the transducer too.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_plate_create() + _check(_LIB.taptools_plate_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, pitch_hz=None, decay=None, tilt=None, brightness=None) -> "Plate": + for value, fn, name in ( + (pitch_hz, _LIB.taptools_plate_set_pitch_hz, "pitch_hz"), + (decay, _LIB.taptools_plate_set_decay, "decay"), + (tilt, _LIB.taptools_plate_set_tilt, "tilt"), + (brightness, _LIB.taptools_plate_set_brightness, "brightness"), + ): + if value is not None: + _check(fn(self._h, float(value)), name) + return self + + def modes(self): + """Where the eight modes landed: (Hz, doublet weight) arrays.""" + hz = np.array([_LIB.taptools_plate_mode_hz(self._h, i) for i in range(8)]) + lv = np.array([_LIB.taptools_plate_mode_level(self._h, i) for i in range(8)]) + return hz, lv + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_plate_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + _check(_LIB.taptools_plate_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_plate_destroy(h) + self._h = None + + +class Transducer: + """The diffuseurs' moving-iron driver on its own + (tap::tools::diffuseur::transducer) — a component, not an external. + + `asymmetry` is the moving-iron squared term: force follows the square of + the gap flux, so with a bias current the residual i² puts a second harmonic + on the output at exactly asymmetry x amplitude / 2 relative to the + fundamental, and nothing at the third. `saturation` is the bounding stage + (0 is exactly linear); the output is bounded by 2/saturation rather than + 1/saturation, because taking the DC out of a hard-driven squared law + doubles the worst-case swing.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_transducer_create() + _check(_LIB.taptools_transducer_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, drive=None, asymmetry=None, saturation=None) -> "Transducer": + for value, fn, name in ( + (drive, _LIB.taptools_transducer_set_drive, "drive"), + (asymmetry, _LIB.taptools_transducer_set_asymmetry, "asymmetry"), + (saturation, _LIB.taptools_transducer_set_saturation, "saturation"), + ): + if value is not None: + _check(fn(self._h, float(value)), name) + return self + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_transducer_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + _check(_LIB.taptools_transducer_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_transducer_destroy(h) + self._h = None + + +class Metallique: + """tap.metallique~'s kernel (tap::tools::diffuseur::metallique): the Ondes + Martenot's motor-driven gong diffuseur, as a *driven* resonator — a + moving-iron transducer feeding a bank of plate modes, in that order, + because that is the order the instrument wires them. + + The mode ratios are Fletcher & Rossing's free circular plate (Rayleigh's + Chladni set, 1 : 1.730 : 2.328 : 3.910 : 4.110 : 6.300 : 6.710 : 7.340), + each split into a slowly beating doublet. No ondes-specific modal + measurement exists in any of the sources, so the body is a **recreation of + the general physics**, not a model of Martenot's instrument. + + `drive` / `asymmetry` / `saturation` are the transducer: asymmetry is the + moving-iron squared term (force follows the square of the gap flux), and + saturation is the bounding stage that keeps the squared law finite. Neither + coefficient is fitted to a measurement — set both to 0 for a linear body.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_metallique_create() + _check(_LIB.taptools_metallique_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, pitch_hz=None, decay=None, tilt=None, brightness=None, drive=None, + asymmetry=None, saturation=None, mix=None, level=None, smooth_ms=None) -> "Metallique": + # configuration first, so ramped targets in the same call honor the new slew + if smooth_ms is not None: + _check(_LIB.taptools_metallique_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + for value, fn, name in ( + (pitch_hz, _LIB.taptools_metallique_set_pitch_hz, "pitch_hz"), + (decay, _LIB.taptools_metallique_set_decay, "decay"), + (tilt, _LIB.taptools_metallique_set_tilt, "tilt"), + (brightness, _LIB.taptools_metallique_set_brightness, "brightness"), + (drive, _LIB.taptools_metallique_set_drive, "drive"), + (asymmetry, _LIB.taptools_metallique_set_asymmetry, "asymmetry"), + (saturation, _LIB.taptools_metallique_set_saturation, "saturation"), + (mix, _LIB.taptools_metallique_set_mix, "mix"), + (level, _LIB.taptools_metallique_set_level, "level"), + ): + if value is not None: + _check(fn(self._h, float(value)), name) + return self + + def modes(self): + """Where the eight modes landed: (Hz, doublet weight) arrays.""" + hz = np.array([_LIB.taptools_metallique_mode_hz(self._h, i) for i in range(8)]) + lv = np.array([_LIB.taptools_metallique_mode_level(self._h, i) for i in range(8)]) + return hz, lv + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_metallique_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + """Silence the body and reset the driver; parameters are untouched.""" + _check(_LIB.taptools_metallique_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_metallique_destroy(h) + self._h = None + + +class Palme: + """tap.palme~'s kernel (tap::tools::diffuseur::palme): the Ondes Martenot's + string diffuseur — an electromagnet driving twelve metal strings on a + soundboard, here a moving-iron transducer into twelve damped waveguide + loops. Only the strings whose partials line up with the drive ring loudly, + which is the halo the instrument is known for. + + **Twelve** strings, per the peer-reviewed source; the widely copied + hobbyist figure of twenty-four is not followed. Their tuning is not + published anywhere found, so it is a parameter: `tuning` 0 lays them out + chromatically across an octave from `root_hz` (a string for every pitch + class), 1 as the harmonic series on the root. + + Note that `decay` and `damping` are not independent — a heavily damped + string cannot ring for the time you ask, and `string_feedback()` shows the + loop gain pinned at its cap when they fight.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_palme_create() + _check(_LIB.taptools_palme_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, root_hz=None, tuning=None, decay=None, damping=None, detune=None, + drive=None, asymmetry=None, saturation=None, mix=None, level=None, + smooth_ms=None) -> "Palme": + if tuning is not None: + _check(_LIB.taptools_palme_set_tuning(self._h, int(tuning)), "tuning") + if smooth_ms is not None: + _check(_LIB.taptools_palme_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + for value, fn, name in ( + (root_hz, _LIB.taptools_palme_set_root_hz, "root_hz"), + (decay, _LIB.taptools_palme_set_decay, "decay"), + (damping, _LIB.taptools_palme_set_damping, "damping"), + (detune, _LIB.taptools_palme_set_detune, "detune"), + (drive, _LIB.taptools_palme_set_drive, "drive"), + (asymmetry, _LIB.taptools_palme_set_asymmetry, "asymmetry"), + (saturation, _LIB.taptools_palme_set_saturation, "saturation"), + (mix, _LIB.taptools_palme_set_mix, "mix"), + (level, _LIB.taptools_palme_set_level, "level"), + ): + if value is not None: + _check(fn(self._h, float(value)), name) + return self + + def strings(self): + """Where the twelve strings ended up: (Hz, loop gain) arrays.""" + hz = np.array([_LIB.taptools_palme_string_hz(self._h, i) for i in range(12)]) + fb = np.array([_LIB.taptools_palme_string_feedback(self._h, i) for i in range(12)]) + return hz, fb + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_palme_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + """Damp every string and reset the driver; parameters are untouched.""" + _check(_LIB.taptools_palme_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_palme_destroy(h) + self._h = None + + +class Scrub: + """tap.scrub~'s kernel (tap::tools::scrub::machine): a granular scrub pad + over live capture. The tape is stammer.h's `capture` — the same live reel, + shared rather than copied — and the playhead is a Hann-windowed grain + scheduler whose position and pitch are two independent performable signals. + + `position_ms` is a lag behind the live edge; `pitch` transposes without the + position moving; `freeze` stops the recorder so the position addresses + fixed tape; `drift` walks the playhead through the tape on its own. + + Hann satisfies the overlap-add condition at hop = size/overlap, so at + overlap 2 with pitch 0, no spray and a held whole-sample position, the + scrub *is* the input delayed — pinned to under 1e-12 by the kernel tests.""" + + def __init__(self, sr: float = 48000.0, max_history_ms: float = 4000.0, **params): + self._h = _LIB.taptools_scrub_create() + _check(_LIB.taptools_scrub_prepare(self._h, float(sr), float(max_history_ms)), "prepare") + self.set(**params) + + def set(self, *, position_ms=None, pitch=None, drift=None, freeze=None, size_ms=None, + overlap=None, spray_ms=None, seed=None, mix=None, level=None, + smooth_ms=None) -> "Scrub": + if overlap is not None: + _check(_LIB.taptools_scrub_set_overlap(self._h, int(overlap)), "overlap") + if freeze is not None: + _check(_LIB.taptools_scrub_set_freeze(self._h, 1 if freeze else 0), "freeze") + if seed is not None: + _check(_LIB.taptools_scrub_set_seed(self._h, int(seed)), "seed") + if smooth_ms is not None: + _check(_LIB.taptools_scrub_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + for value, fn, name in ( + (position_ms, _LIB.taptools_scrub_set_position_ms, "position_ms"), + (pitch, _LIB.taptools_scrub_set_pitch, "pitch"), + (drift, _LIB.taptools_scrub_set_drift, "drift"), + (size_ms, _LIB.taptools_scrub_set_size_ms, "size_ms"), + (spray_ms, _LIB.taptools_scrub_set_spray_ms, "spray_ms"), + (mix, _LIB.taptools_scrub_set_mix, "mix"), + (level, _LIB.taptools_scrub_set_level, "level"), + ): + if value is not None: + _check(fn(self._h, float(value)), name) + return self + + @property + def active_grains(self) -> int: + return int(_LIB.taptools_scrub_active_grains(self._h)) + + def process(self, x, position_ms=None, pitch=None) -> np.ndarray: + """Run n samples. Pass arrays for `position_ms` / `pitch` to drive the + performance surface at signal rate (both must be given together).""" + x = _f64(x) + out = np.zeros_like(x) + if position_ms is None and pitch is None: + _check(_LIB.taptools_scrub_process(self._h, _p64(x), _p64(out), x.size), "process") + else: + pos = _f64(np.broadcast_to(np.asarray(position_ms if position_ms is not None else 0.0, + dtype=np.float64), x.shape)) + pit = _f64(np.broadcast_to(np.asarray(pitch if pitch is not None else 0.0, + dtype=np.float64), x.shape)) + _check(_LIB.taptools_scrub_process_mod(self._h, _p64(x), _p64(pos), _p64(pit), + _p64(out), x.size), "process_mod") + return out + + def clear(self) -> None: + """Erase the tape, kill every grain, and restart the seeded stream.""" + _check(_LIB.taptools_scrub_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_scrub_destroy(h) + self._h = None + + class Touche: """tap.touche~'s kernel (tap::tools::touche::key): the Ondes Martenot intensity key as a gain law. The curve is not modelled — it is Quartier diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 2a3d5d9..4988fc0 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -16,6 +16,7 @@ add_executable(taptools_kernel_tests airport_test.cpp autowah_test.cpp delay_test.cpp + diffuseur_test.cpp diode_ladder_test.cpp discreet_test.cpp garden_test.cpp @@ -24,6 +25,7 @@ add_executable(taptools_kernel_tests harmonizer_test.cpp nr_test.cpp overdrive_test.cpp + scrub_test.cpp spectra_test.cpp step_seq_test.cpp stammer_test.cpp diff --git a/tests/diffuseur_test.cpp b/tests/diffuseur_test.cpp new file mode 100644 index 0000000..7a5d2ea --- /dev/null +++ b/tests/diffuseur_test.cpp @@ -0,0 +1,501 @@ +/// @file +/// @brief Catch2 scenarios pinning the Ondes Martenot diffuseur kernels (diffuseur.h). +/// @details Two things make this kernel's contract unusual enough to shape the suite. First, +/// the bodies are **recreations** — the mode data is Fletcher & Rossing's general +/// physics, not a measurement of Martenot's instruments — so there is no published +/// table to reproduce the way tests/touche_test.cpp reproduces one. What can be +/// pinned instead is that the maths is honest: unit peak gain per mode, weights that +/// sum to one, the ring time you asked for, and the published ratios coming back out. +/// Second, the signal order is a *claim about the instrument* — the transducer drives +/// the body, so the nonlinearity is upstream — and a claim like that is worth a null +/// test, which is what "the cabinet is its parts, wired in the order the instrument +/// wires them" is. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + constexpr double k_pi = 3.14159265358979323846; + + namespace D = tap::tools::diffuseur; + + /// Magnitude of `x[from .. from+n)` at `hz` — the house's independent detector for a single + /// bin (same Goertzel the fuzz suite measures harmonics with). + double bin(const std::vector& x, double hz, size_t from, size_t n) { + const double w = 2.0 * k_pi * hz / k_sr; + const double c = 2.0 * std::cos(w); + double s1 = 0.0, s2 = 0.0; + for (size_t i = 0; i < n; ++i) { + const double s = x[from + i] + c * s1 - s2; + s2 = s1; + s1 = s; + } + return std::sqrt(std::max(0.0, s1 * s1 + s2 * s2 - c * s1 * s2)) * 2.0 / static_cast(n); + } + + std::vector sine(double hz, double amp, size_t n) { + std::vector x(n); + for (size_t i = 0; i < n; ++i) { + x[i] = amp * std::sin(2.0 * k_pi * hz * static_cast(i) / k_sr); + } + return x; + } + + /// Peak of a mode's response to a settled sine at `hz`, measured over the last tenth. + double mode_response(double f0, double t60, double hz, double settle_s) { + D::mode m; + m.prepare(k_sr); + m.set(f0, t60); + const int n = static_cast(settle_s * k_sr); + double peak = 0.0; + const int start = n - static_cast(0.1 * k_sr); + for (int i = 0; i < n; ++i) { + const double y = m.process(std::sin(2.0 * k_pi * hz * static_cast(i) / k_sr)); + if (i >= start) { + peak = std::max(peak, std::abs(y)); + } + } + return peak; + } + +} // namespace + +// The whole boundedness argument rests on this: Steiglitz's b0 = (1 - R^2)/2 makes the peak +// magnitude 1 whatever the pole radius, so a bank of weighted modes is bounded by the sum of its +// weights and needs no limiter after it. If this drifts, every other claim in the file goes with it. +SCENARIO("a driven mode peaks at unity gain whatever its ring time") { + for (double t60 : {0.02, 0.2, 2.0}) { + // Settle for several ring times, and probe at the pole angle and a little either side — + // a very high-Q mode is narrower than a coarse probe grid, which is a measurement trap. + const double f0 = 440.0; + const double settle = std::max(0.5, 4.0 * t60); + double peak = 0.0; + for (int k = -4; k <= 4; ++k) { + peak = std::max(peak, mode_response(f0, t60, f0 * (1.0 + 0.0002 * k), settle)); + } + INFO("t60 " << t60 << " s: peak gain " << peak); + CHECK(peak > 0.98); + CHECK(peak < 1.0001); // never above unity: that is what "bounded by the weights" means + } +} + +SCENARIO("the ring time a mode is asked for is the ring time it delivers") { + D::mode m; + m.prepare(k_sr); + m.set(180.0, 4.0); + + std::vector y(static_cast(k_sr * 5.0)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = m.process((i == 0) ? 1.0 : 0.0); + } + auto peak_at = [&](double t) { + double p = 0.0; + const size_t a = static_cast(t * k_sr); + for (size_t i = 0; i < 9600; ++i) { + p = std::max(p, std::abs(y[a + i])); + } + return p; + }; + // 60 dB in 4 s is 45 dB in 3 s, and the envelope is exponential so that is exact. + const double drop = 20.0 * std::log10(peak_at(3.5) / peak_at(0.5)); + INFO("decay over 3 s: " << drop << " dB (a 4 s T60 predicts -45)"); + CHECK(std::abs(drop + 45.0) < 0.2); +} + +// The zeros at z = +-1 are why a driven bank cannot accumulate DC and needs no blocker after it. +SCENARIO("a mode passes nothing at DC and nothing at Nyquist") { + D::mode m; + m.prepare(k_sr); + m.set(440.0, 0.5); + + double dc = 0.0; + for (int i = 0; i < 48000; ++i) { + dc = m.process(1.0); + } + INFO("settled response to a constant: " << dc); + CHECK(std::abs(dc) < 1e-9); + + D::mode n; + n.prepare(k_sr); + n.set(440.0, 0.5); + double nyq = 0.0; + for (int i = 0; i < 48000; ++i) { + nyq = n.process((i % 2 == 0) ? 1.0 : -1.0); + } + INFO("settled response to alternating ones: " << nyq); + CHECK(std::abs(nyq) < 1e-9); +} + +SCENARIO("the plate's weights sum to one, so the body cannot amplify what drives it") { + D::plate p; + p.prepare(k_sr); + p.set_pitch_hz(180.0); + p.set_decay(20.0); + p.set_brightness(1.0); + + double sum = 0.0; + for (int m = 0; m < D::k_plate_modes; ++m) { + sum += p.mode_level(m); + } + INFO("sum of doublet weights: " << sum); + CHECK(std::abs(sum - 1.0) < 1e-12); + + // And measured: a long ring time, full brightness, and a bounded input never exceeds it. + unsigned r = 12345u; + double peak = 0.0; + for (int i = 0; i < static_cast(k_sr * 5.0); ++i) { + r = r * 1664525u + 1013904223u; + const double x = (r / 2147483648.0) - 1.0; + peak = std::max(peak, std::abs(p.process(x))); + } + INFO("peak output for |x| <= 1: " << peak); + CHECK(peak <= 1.0); +} + +SCENARIO("the plate's modes sit at the published free-plate ratios") { + D::plate p; + p.prepare(k_sr); + p.set_pitch_hz(150.0); + + for (int m = 0; m < D::k_plate_modes; ++m) { + const double got = p.mode_hz(m) / p.mode_hz(0); + const double want = D::k_plate_ratio[static_cast(m)]; + INFO("mode " << m << ": " << got << " vs published " << want); + // Within the fixed per-mode scatter (k_scatter_cents) and nothing more — the ratios are + // the citation, the scatter is the imperfection, and the two must not be confused. + CHECK(std::abs(got / want - 1.0) < 0.003); + } +} + +SCENARIO("brightness closes the plate down toward its fundamental") { + auto upper_energy = [](double bright) { + D::plate p; + p.prepare(k_sr); + p.set_pitch_hz(150.0); + p.set_decay(2.0); + p.set_brightness(bright); + + std::vector y(static_cast(k_sr * 2.0)); + unsigned r = 999u; + for (size_t i = 0; i < y.size(); ++i) { + r = r * 1664525u + 1013904223u; + y[i] = p.process((r / 2147483648.0) - 1.0); + } + const size_t from = y.size() / 2; + return bin(y, p.mode_hz(4), from, y.size() - from) / bin(y, p.mode_hz(0), from, y.size() - from); + }; + + const double open = upper_energy(1.0); + const double closed = upper_energy(0.2); + INFO("mode 4 relative to the fundamental: brightness 1 -> " << open << ", brightness 0.2 -> " << closed); + CHECK(closed < 0.2 * open); // b^4 at 0.2 is 1.6e-3 of b^4 at 1; a factor of five is a floor, not a fit +} + +SCENARIO("a plate mode above the band is silenced rather than folded") { + D::plate p; + p.prepare(k_sr); + p.set_brightness(1.0); + p.set_pitch_hz(D::k_max_pitch_hz); // 4 kHz fundamental puts the 7.34 ratio past 0.45 sr + + CHECK(p.mode_level(0) > 0.0); + CHECK(p.mode_level(D::k_plate_modes - 1) == 0.0); +} + +SCENARIO("a lightly damped string rings for the time it is asked to") { + D::sympathetic s; + s.prepare(k_sr); + s.set(220.0, 3.0, 12000.0); + + std::vector y(static_cast(k_sr * 4.0)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = s.process((i < 8) ? 1.0 : 0.0); + } + // Measure the FUNDAMENTAL, not broadband energy: the in-loop lowpass kills the upper partials + // faster by design, so a wideband envelope decays faster than the string's stated ring time. + const size_t win = static_cast(0.4 * k_sr); + const double a = bin(y, 220.0, static_cast(0.3 * k_sr), win); + const double b = bin(y, 220.0, static_cast(2.3 * k_sr), win); + const double drop = 20.0 * std::log10(b / a); + INFO("fundamental decay over 2 s: " << drop << " dB (a 3 s T60 predicts -40)"); + CHECK(std::abs(drop + 40.0) < 3.0); +} + +// An honest limit made into a test, because it is the one that will surprise someone: the two +// controls are not independent, and the header says so. +SCENARIO("damping and ring time are not independent, and the cap is where the string stops") { + D::sympathetic light; + light.prepare(k_sr); + light.set(220.0, 3.0, 12000.0); + + D::sympathetic heavy; + heavy.prepare(k_sr); + heavy.set(220.0, 3.0, D::k_min_damp_hz); // the same 3 s asked of a heavily damped string + + INFO("loop gain: light " << light.feedback() << ", heavy " << heavy.feedback()); + CHECK(light.feedback() < D::k_fb_max); // the light string gets what it asked for + CHECK(heavy.feedback() == D::k_fb_max); // the heavy one is pinned at the cap + CHECK(heavy.feedback() * 0.95 < 1.0); // and the loop is still strictly contractive +} + +SCENARIO("the harp answers the strings it has and ignores the pitches between them") { + // The drive is faded in and out. Switching a tone on and off is a step, and a step excites + // every string on the board — measured without the fades, the "off-note" reading is mostly + // that transient rather than any sympathy, and the test would be measuring its own edges. + auto tail = [](double hz) { + D::harp h; + h.prepare(k_sr); + h.set_root_hz(110.0); + h.set_tuning(D::tuning_chromatic); + h.set_decay(6.0); + h.set_detune(0.0); + + const int on = static_cast(k_sr * 2.0); + const int all = static_cast(k_sr * 3.0); + const int fade = static_cast(k_sr * 0.25); + double energy = 0.0; + int count = 0; + for (int i = 0; i < all; ++i) { + double g = 0.0; + if (i < on) { + g = 1.0; + if (i < fade) { + g = 0.5 - 0.5 * std::cos(k_pi * static_cast(i) / static_cast(fade)); + } + if (i > on - fade) { + g = 0.5 - 0.5 * std::cos(k_pi * static_cast(on - i) / static_cast(fade)); + } + } + const double y = h.process(g * 0.3 * std::sin(2.0 * k_pi * hz * static_cast(i) / k_sr)); + if (i > on + static_cast(0.2 * k_sr)) { + energy += y * y; + ++count; + } + } + return std::sqrt(energy / static_cast(count)); + }; + + // Every one of the twelve, against a drive a quarter-tone sharp of it — which is neither any + // string's fundamental nor any string's harmonic. + for (int i = 0; i < D::k_strings; ++i) { + const double on_note = tail(110.0 * std::exp2(static_cast(i) / 12.0)); + const double off_note = tail(110.0 * std::exp2((static_cast(i) + 0.5) / 12.0)); + INFO("string " << i << ": ring on the note " << on_note << ", a quarter-tone off " << off_note << ", ratio " + << on_note / off_note); + CHECK(on_note > 4.0 * off_note); + } + // The ratio measured here climbs from about 4 on the lowest string to about a thousand on the + // highest, and that is physics rather than a defect: at a fixed ring time a loop's Q scales + // with f x T60, so the top of the board is far the more selective end of it. +} + +SCENARIO("the harp is the same harp in every instance") { + D::harp a, b; + a.prepare(k_sr); + b.prepare(k_sr); + a.set_detune(20.0); + b.set_detune(20.0); + + bool same = true; + for (int i = 0; i < D::k_strings; ++i) { + same = same && (a.string_hz(i) == b.string_hz(i)); + } + REQUIRE(same); // the scatter is an index-keyed hash, not a draw — no seed, no drift + + // And the strings are actually scattered, or the check above would be vacuous. + bool scattered = false; + for (int i = 0; i < D::k_strings; ++i) { + scattered = scattered || (std::abs(a.string_hz(i) - 110.0 * std::exp2(i / 12.0)) > 0.1); + } + CHECK(scattered); +} + +// The moving-iron principle, and the only part of the transducer with a physical argument behind +// it: force follows the square of the flux, so the residual squared term puts a second harmonic +// on the output at exactly (asymmetry x amplitude / 2) relative to the fundamental. +SCENARIO("the driver's asymmetry is exactly the moving-iron squared term") { + const double amp = 0.5; + for (double asym : {0.1, 0.3, 0.6, 1.0}) { + D::transducer t; + t.prepare(k_sr); + t.set_drive(1.0); + t.set_asymmetry(asym); + t.set_saturation(0.0); // the bounding stage off: this measures the squared law alone + + const std::vector x = sine(200.0, amp, static_cast(k_sr * 0.5)); + std::vector y(x.size()); + for (size_t i = 0; i < x.size(); ++i) { + y[i] = t.process(x[i]); + } + const size_t from = y.size() / 2; + const size_t n = y.size() - from; + const double ratio = bin(y, 400.0, from, n) / bin(y, 200.0, from, n); + INFO("asymmetry " << asym << ": second harmonic / fundamental = " << ratio << ", predicted " + << asym * amp * 0.5); + CHECK(std::abs(ratio - asym * amp * 0.5) < 0.002); + CHECK(bin(y, 600.0, from, n) < 1e-6); // a squared term makes a second harmonic and nothing else + } +} + +SCENARIO("with asymmetry and saturation at zero the driver is a plain gain") { + D::transducer t; + t.prepare(k_sr); + t.set_drive(2.0); + t.set_asymmetry(0.0); + t.set_saturation(0.0); + + const std::vector x = sine(1000.0, 0.4, static_cast(k_sr * 0.4)); + std::vector y(x.size()); + for (size_t i = 0; i < x.size(); ++i) { + y[i] = t.process(x[i]); + } + const size_t from = y.size() / 2; + const size_t n = y.size() - from; + INFO("fundamental " << bin(y, 1000.0, from, n) << " (drive 2 on 0.4 predicts 0.8)"); + CHECK(std::abs(bin(y, 1000.0, from, n) - 0.8) < 0.002); + CHECK(bin(y, 2000.0, from, n) < 1e-9); + CHECK(bin(y, 3000.0, from, n) < 1e-9); +} + +SCENARIO("the driver is bounded however hard it is driven") { + D::transducer t; + t.prepare(k_sr); + t.set_drive(200.0); + t.set_asymmetry(1.0); + t.set_saturation(0.8); // swing_shape is bounded by 1/drive + + double peak = 0.0; + for (int i = 0; i < 48000; ++i) { + peak = std::max(peak, std::abs(t.process(std::sin(2.0 * k_pi * 137.0 * i / k_sr)))); + } + // The bound is 2/saturation, not the saturator's own 1/saturation: a hard-driven squared law + // is a nearly-constant positive waveform with brief negative excursions, and taking that DC + // offset out doubles the worst-case swing. Measured at 1.49 here, against a 1.25 that the + // obvious argument would have predicted. + INFO("peak output at drive 200, asymmetry 1, saturation 0.8: " << peak); + CHECK(peak > 1.0 / 0.8); // the naive bound is genuinely exceeded — this is not slack + CHECK(peak < 2.0 / 0.8 + 1e-9); +} + +// The structural claim of the whole file: the electrical signal reaches the transducer first, and +// the transducer's motion excites the body. Wiring the parts by hand in that order reproduces the +// machine exactly; wiring them the other way round does not, so the order is a real choice. +SCENARIO("a cabinet is its parts, wired in the order the instrument wires them") { + D::metallique cab; + cab.prepare(k_sr); + cab.set_smooth_ms(0.0); + cab.set_drive(1.7); + cab.set_asymmetry(0.4); + cab.set_saturation(0.9); + cab.set_mix(100.0); + cab.set_level(1.0); + cab.set_pitch_hz(210.0); + cab.set_decay(3.0); + cab.set_brightness(0.8); + + D::transducer driver; + driver.prepare(k_sr); + driver.set_drive(1.7); + driver.set_asymmetry(0.4); + driver.set_saturation(0.9); + D::plate body; + body.prepare(k_sr); + body.set_pitch_hz(210.0); + body.set_decay(3.0); + body.set_brightness(0.8); + + // And the same parts the other way round, to show the order is audible rather than notional. + D::transducer rev_driver; + rev_driver.prepare(k_sr); + rev_driver.set_drive(1.7); + rev_driver.set_asymmetry(0.4); + rev_driver.set_saturation(0.9); + D::plate rev_body; + rev_body.prepare(k_sr); + rev_body.set_pitch_hz(210.0); + rev_body.set_decay(3.0); + rev_body.set_brightness(0.8); + + bool identical = true; + double difference = 0.0; + for (int i = 0; i < 24000; ++i) { + const double x = 0.7 * std::sin(2.0 * k_pi * 190.0 * i / k_sr); + const double a = cab.process(x); + const double b = body.process(driver.process(x)); + identical = identical && (a == b); + difference = std::max(difference, std::abs(a - rev_driver.process(rev_body.process(x)))); + } + REQUIRE(identical); // fully wet, the cabinet IS transducer -> body, bitwise + INFO("largest difference against the reversed wiring: " << difference); + CHECK(difference > 1e-3); // and the reversed wiring is a different machine +} + +SCENARIO("a cabinet's balance ends are exact at both extremes") { + D::palme p; + p.prepare(k_sr); + p.set_smooth_ms(0.0); + p.set_level(1.0); + + p.set_mix(0.0); + bool dry = true; + for (int i = 0; i < 4800; ++i) { + const double x = std::sin(2.0 * k_pi * 300.0 * i / k_sr); + dry = dry && (p.process(x) == x); + } + REQUIRE(dry); // fully dry is the input, bitwise — not cos(pi/2) times the input + + p.clear(); + p.set_mix(100.0); + double wet_energy = 0.0; + for (int i = 0; i < 48000; ++i) { + const double y = p.process(0.5 * std::sin(2.0 * k_pi * 110.0 * i / k_sr)); + wet_energy += y * y; + } + CHECK(wet_energy > 0.0); // fully wet is the body, and the body is doing something +} + +SCENARIO("a level move is slewed, so a cabinet does not click") { + D::metallique cab; + cab.prepare(k_sr); + cab.set_smooth_ms(50.0); + cab.set_mix(100.0); + cab.set_level(0.0); + // One continuous tone throughout: a break in the INPUT would show up as a step in the output + // and the test would be measuring its own seam rather than the level move. + auto tone = [](int i) { return 0.5 * std::sin(2.0 * k_pi * 180.0 * static_cast(i) / k_sr); }; + int n = 0; + for (; n < 24000; ++n) { + cab.process(tone(n)); + } + + cab.set_level(1.0); // slam it open + double last = cab.process(tone(n++)); + double worst = 0.0; + for (int i = 0; i < static_cast(0.1 * k_sr); ++i, ++n) { + const double y = cab.process(tone(n)); + worst = std::max(worst, std::abs(y - last)); + last = y; + } + INFO("largest single-sample step during a full-scale level move: " << worst); + CHECK(worst < 0.02); +} + +SCENARIO("unprepared, both cabinets pass their input through") { + D::metallique m; + D::palme p; + bool clean = true; + for (int i = 0; i < 100; ++i) { + const double x = 0.01 * static_cast(i); + clean = clean && (m.process(x) == x) && (p.process(x) == x); + } + REQUIRE(clean); +} diff --git a/tests/scrub_test.cpp b/tests/scrub_test.cpp new file mode 100644 index 0000000..eeae1a5 --- /dev/null +++ b/tests/scrub_test.cpp @@ -0,0 +1,386 @@ +/// @file +/// @brief Catch2 scenarios pinning the tap.scrub~ kernel (scrub.h). +/// @details Everything this object does is a departure from a plain delay — a moving position, +/// a transposition that does not move with it, a frozen tape, a scattered origin — +/// and a departure is only trustworthy if the identity is exact when it should be. So +/// the load-bearing scenario is the null: at unity pitch, overlap 2, no spray and a +/// held whole-sample position, the scrub is the input delayed and nothing else. The +/// rest pin the departures one at a time, and the seed contract the family shares. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + constexpr double k_pi = 3.14159265358979323846; + + namespace S = tap::tools::scrub; + + double ms_of(long samples) { + return static_cast(samples) * 1000.0 / k_sr; + } + + /// A pluck train: transients, which is what a scrub has something to bite on (the stammer's + /// material contract, same reasoning). + std::vector plucks(size_t n) { + std::vector x(n); + double env = 0.0, phase = 0.0, hz = 220.0; + for (size_t i = 0; i < n; ++i) { + if (i % 6000 == 0) { + env = 1.0; + hz = 180.0 + 40.0 * static_cast((i / 6000) % 5); + } + env *= 0.99975; + phase += hz / k_sr; + phase -= std::floor(phase); + x[i] = env * (std::sin(2.0 * k_pi * phase) + 0.4 * std::sin(6.0 * k_pi * phase)); + } + return x; + } + + double rms(const std::vector& x, size_t from) { + double s = 0.0; + for (size_t i = from; i < x.size(); ++i) { + s += x[i] * x[i]; + } + return std::sqrt(s / static_cast(x.size() - from)); + } + + double bin(const std::vector& x, double hz, size_t from, size_t n) { + const double w = 2.0 * k_pi * hz / k_sr; + const double c = 2.0 * std::cos(w); + double s1 = 0.0, s2 = 0.0; + for (size_t i = 0; i < n; ++i) { + const double s = x[from + i] + c * s1 - s2; + s2 = s1; + s1 = s; + } + return std::sqrt(std::max(0.0, s1 * s1 + s2 * s2 - c * s1 * s2)) * 2.0 / static_cast(n); + } + + S::machine make(double size_samples = 96.0, double lag_samples = 480.0) { + S::machine m; + m.prepare(k_sr, 2000.0); + m.set_smooth_ms(0.0); + m.set_overlap(2); + m.set_size_ms(ms_of(static_cast(size_samples))); + m.set_position_ms(ms_of(static_cast(lag_samples))); + m.set_mix(100.0); + m.set_level(1.0); + return m; + } + +} // namespace + +// The load-bearing scenario. Hann satisfies the overlap-add condition at hop = size/2, so with the +// position held on a whole sample and no transposition, the two live grains sum to exactly one and +// the machine is a delay line — to within the floating-point cost of computing two cosines whose +// arguments differ by pi rather than one cosine and its negation. +SCENARIO("held still at unity pitch, the scrub is exactly a delay") { + S::machine m = make(96.0, 480.0); + + const std::vector x = plucks(30000); + std::vector y(x.size()); + for (size_t i = 0; i < x.size(); ++i) { + y[i] = m.process(x[i]); + } + + double worst = 0.0; + for (size_t i = 2000; i < x.size(); ++i) { + worst = std::max(worst, std::abs(y[i] - x[i - 480])); + } + INFO("largest departure from a 480-sample delay: " << worst); + REQUIRE(worst < 1e-12); +} + +SCENARIO("the position is a lag in milliseconds, measured from the live edge") { + for (long lag : {0L, 240L, 4800L}) { + S::machine m = make(96.0, static_cast(lag)); + const std::vector x = plucks(20000); + std::vector y(x.size()); + for (size_t i = 0; i < x.size(); ++i) { + y[i] = m.process(x[i]); + } + double worst = 0.0; + for (size_t i = static_cast(lag) + 2000; i < x.size(); ++i) { + worst = std::max(worst, std::abs(y[i] - x[i - static_cast(lag)])); + } + INFO("lag " << lag << " samples: worst error " << worst); + CHECK(worst < 1e-12); + } +} + +// The object's reason to exist: pitch and position are two hands, not one. +SCENARIO("pitch transposes without the position moving") { + auto run = [](double semitones) { + S::machine m = make(4800.0, 24000.0); // a long grain and a deep position: room to transpose + m.set_pitch(semitones); + std::vector y(static_cast(k_sr * 2.0)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = m.process(0.5 * std::sin(2.0 * k_pi * 300.0 * static_cast(i) / k_sr)); + } + const size_t from = y.size() / 2; + const size_t n = y.size() - from; + return std::pair{bin(y, 300.0, from, n), bin(y, 300.0 * std::exp2(semitones / 12.0), from, n)}; + }; + + const auto up = run(7.0); + INFO("up a fifth: energy at 300 Hz " << up.first << ", at the transposed pitch " << up.second); + CHECK(up.second > 4.0 * up.first); + + const auto down = run(-5.0); + INFO("down a fourth: energy at 300 Hz " << down.first << ", at the transposed pitch " << down.second); + CHECK(down.second > 4.0 * down.first); + + const auto flat = run(0.0); + CHECK(flat.first > 0.4); // and at unity the pitch is simply the input's +} + +// The defect this scenario exists to catch, because the first cut had it and it is invisible to +// every other test here: if grain origins are anchored at the position, they advance at the WRITE +// head's speed while each grain plays at `rate`, so the transposition applies only inside a grain +// and the average read rate comes back to 1. A steady tone then comes out at its ORIGINAL pitch +// with a comb of grain-rate sidebands, and the pitch knob does nothing but add texture. The fix is +// a phase-continuous read head, wrapped back toward the position only when it has wandered far +// enough; this pins the outcome rather than the mechanism. +SCENARIO("the pitch control moves the pitch, and does not merely colour the original") { + auto run = [](double f0, double st) { + S::machine m = make(4800.0, 43200.0); // 100 ms grains, the position a comfortable 900 ms back + m.set_pitch(st); + std::vector y(static_cast(k_sr * 2.0)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = m.process(0.5 * std::sin(2.0 * k_pi * f0 * static_cast(i) / k_sr)); + } + return y; + }; + + double sum_moved = 0.0; + int count = 0; + // Fundamentals deliberately chosen NOT to be whole numbers of periods in the grain: that case + // is transparent to every wrap and would hide the defect completely. + for (double f0 : {173.0, 311.0, 443.0}) { + for (double st : {-12.0, -7.0, -3.0, 3.0, 7.0, 12.0}) { + const std::vector y = run(f0, st); + const size_t from = y.size() / 2; + const size_t n = y.size() - from; + const double target = f0 * std::exp2(st / 12.0); + double moved = 0.0; + for (int k = -6; k <= 6; ++k) { // the comb is a few Hz wide; a single bin misses it + moved = std::max(moved, bin(y, target + 0.5 * k, from, n)); + } + const double stayed = bin(y, f0, from, n); + INFO(f0 << " Hz, " << st << " semitones: energy at the transposed pitch " << moved + << ", left at the original " << stayed); + CHECK(moved > 10.0 * stayed); // the pitch moved; it was not merely coloured + sum_moved += moved; + ++count; + } + } + // And it is not merely quiet everywhere. Note the probe: a single-bin reading UNDERSTATES + // this object badly, because the wraps spread the transposed partial into a narrow comb a few + // Hz wide rather than moving it — an early version of this scenario measured one bin, read + // 0.02 where the real figure was 0.43, and nearly sent a correct kernel back for repair. The + // band figures are in the header and in notebooks/scrub.ipynb; here the bin is widened just + // enough to catch the comb. + INFO("mean energy at the transposed pitch: " << sum_moved / count); + CHECK(sum_moved / count > 0.3); +} + +SCENARIO("freeze stops the recorder, so the scrub holds while the input moves on") { + S::machine m = make(4800.0, 24000.0); + + // Half a second of tone, then freeze and switch the input to silence. + for (int i = 0; i < static_cast(k_sr * 0.5); ++i) { + m.process(0.5 * std::sin(2.0 * k_pi * 300.0 * i / k_sr)); + } + m.set_freeze(true); + + std::vector y(static_cast(k_sr * 1.0)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = m.process(0.0); // nothing going in at all + } + INFO("output rms with a frozen tape and a silent input: " << rms(y, y.size() / 2)); + CHECK(rms(y, y.size() / 2) > 0.1); + + // Unfrozen, with the input still silent, the tape fills with silence and the scrub follows it. + m.set_freeze(false); + std::vector z(static_cast(k_sr * 3.0)); + for (size_t i = 0; i < z.size(); ++i) { + z[i] = m.process(0.0); + } + INFO("output rms once the recorder is running again: " << rms(z, z.size() * 3 / 4)); + CHECK(rms(z, z.size() * 3 / 4) < 1e-9); +} + +SCENARIO("drift walks the playhead through the tape on its own") { + S::machine still = make(2400.0, 24000.0); + S::machine moving = make(2400.0, 24000.0); + moving.set_drift(0.5); + + const std::vector x = plucks(static_cast(k_sr * 2.0)); + std::vector a(x.size()), b(x.size()); + for (size_t i = 0; i < x.size(); ++i) { + a[i] = still.process(x[i]); + b[i] = moving.process(x[i]); + } + double diff = 0.0; + for (size_t i = x.size() / 2; i < x.size(); ++i) { + diff = std::max(diff, std::abs(a[i] - b[i])); + } + INFO("largest difference a drift of 0.5 makes: " << diff); + CHECK(diff > 1e-3); + + // Drift 0 changes nothing at all — the accumulator must not creep. + S::machine zero = make(2400.0, 24000.0); + zero.set_drift(0.0); + bool same = true; + S::machine ref = make(2400.0, 24000.0); + for (size_t i = 0; i < x.size(); ++i) { + same = same && (zero.process(x[i]) == ref.process(x[i])); + } + REQUIRE(same); +} + +// The family's seed contract, same shape as garden.h and stammer.h: the dice are only rolled when +// something is actually random, so with spray off the seed provably cannot matter. +SCENARIO("with spray off the seed cannot matter, and with it on the seed is the performance") { + const std::vector x = plucks(static_cast(k_sr * 1.0)); + + S::machine a = make(2400.0, 12000.0); + S::machine b = make(2400.0, 12000.0); + a.set_seed(1); + b.set_seed(999999); + bool identical = true; + for (size_t i = 0; i < x.size(); ++i) { + identical = identical && (a.process(x[i]) == b.process(x[i])); + } + REQUIRE(identical); // spray defaults to 0: no draw, no divergence + + S::machine c = make(2400.0, 12000.0); + S::machine d = make(2400.0, 12000.0); + c.set_spray_ms(120.0); + d.set_spray_ms(120.0); + c.set_seed(1); + d.set_seed(999999); + double diverged = 0.0; + for (size_t i = 0; i < x.size(); ++i) { + diverged = std::max(diverged, std::abs(c.process(x[i]) - d.process(x[i]))); + } + INFO("two seeds, sprayed: largest divergence " << diverged); + CHECK(diverged > 1e-3); + + // And a seed is replayable: the same seed twice is the same performance, bitwise. + S::machine e = make(2400.0, 12000.0); + S::machine f = make(2400.0, 12000.0); + e.set_spray_ms(120.0); + f.set_spray_ms(120.0); + e.set_seed(4242); + f.set_seed(4242); + bool replayed = true; + for (size_t i = 0; i < x.size(); ++i) { + replayed = replayed && (e.process(x[i]) == f.process(x[i])); + } + REQUIRE(replayed); +} + +SCENARIO("the level holds across overlap settings") { + std::vector level; + for (int n : {2, 3, 4}) { + S::machine m = make(4800.0, 24000.0); + m.set_overlap(n); + std::vector y(static_cast(k_sr * 1.5)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = m.process(0.5 * std::sin(2.0 * k_pi * 300.0 * static_cast(i) / k_sr)); + } + level.push_back(rms(y, y.size() / 2)); + INFO("overlap " << n << ": rms " << level.back() << ", normalization " << m.grains().normalization()); + } + for (double v : level) { + CHECK(std::abs(v / level[0] - 1.0) < 0.02); + } +} + +SCENARIO("the grain pool never overflows, and every grain retires") { + S::machine m = make(960.0, 12000.0); + m.set_overlap(S::k_max_overlap); + + int worst = 0; + for (int i = 0; i < static_cast(k_sr * 2.0); ++i) { + m.process(0.3 * std::sin(2.0 * k_pi * 200.0 * i / k_sr)); + worst = std::max(worst, m.active_grains()); + } + INFO("most grains alive at once: " << worst << " of " << S::k_max_grains); + CHECK(worst <= S::k_max_overlap); + + m.clear(); + CHECK(m.active_grains() == 0); +} + +SCENARIO("the signal path and the attribute path agree when they are told the same thing") { + S::machine a = make(2400.0, 0.0); + S::machine b = make(2400.0, 0.0); + a.set_position_ms(ms_of(1200)); + a.set_pitch(3.0); + + const std::vector x = plucks(20000); + bool same = true; + for (size_t i = 0; i < x.size(); ++i) { + same = same && (a.process(x[i]) == b.process(x[i], ms_of(1200), 3.0)); + } + REQUIRE(same); +} + +SCENARIO("fully dry, the scrub is a bitwise passthrough") { + S::machine m = make(2400.0, 12000.0); + m.set_mix(0.0); + bool dry = true; + for (int i = 0; i < 4800; ++i) { + const double x = std::sin(2.0 * k_pi * 300.0 * i / k_sr); + dry = dry && (m.process(x) == x); + } + REQUIRE(dry); // fully dry is the input, bitwise +} + +SCENARIO("a position move is slewed, so a scrub gesture does not click") { + S::machine m = make(2400.0, 0.0); + m.set_smooth_ms(50.0); + // One continuous tone throughout: a break in the INPUT would come straight back out of the + // delay and the test would be measuring its own seam rather than the scrub gesture. + auto tone = [](int i) { return 0.5 * std::sin(2.0 * k_pi * 300.0 * static_cast(i) / k_sr); }; + int n = 0; + for (; n < 48000; ++n) { + m.process(tone(n)); + } + + m.set_position_ms(500.0); // slam the playhead half a second back + double last = m.process(tone(n++)); + double worst = 0.0; + for (int i = 0; i < static_cast(0.2 * k_sr); ++i, ++n) { + const double y = m.process(tone(n)); + worst = std::max(worst, std::abs(y - last)); + last = y; + } + // A steady tone read from anywhere on the tape is the same tone, so the only thing a scrub + // across it can produce is a phase discontinuity — bounded here well under the tone's peak. + INFO("largest single-sample step during a half-second scrub: " << worst); + CHECK(worst < 0.1); +} + +SCENARIO("unprepared, the scrub passes its input through") { + S::machine m; + bool clean = true; + for (int i = 0; i < 100; ++i) { + const double x = 0.01 * static_cast(i); + clean = clean && (m.process(x) == x); + } + REQUIRE(clean); +} diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 7375cd3..71fc287 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -22,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -1230,6 +1232,352 @@ int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, return with(h, [&](tapecho_machine& m) { m.process(in, outL, outR, static_cast(n)); }); } +// ---- tap.transducer ------------------------------------------------------------------------------- + +using diffuseur_transducer = tap::tools::diffuseur::transducer; + +taptools_transducer taptools_transducer_create(void) { + return static_cast(new diffuseur_transducer()); +} + +void taptools_transducer_destroy(taptools_transducer h) { + delete static_cast(h); +} + +int taptools_transducer_prepare(taptools_transducer h, double sr) { + return with(h, [&](diffuseur_transducer& t) { t.prepare(sr); }); +} + +int taptools_transducer_set_drive(taptools_transducer h, double lin) { + return with(h, [&](diffuseur_transducer& t) { t.set_drive(lin); }); +} + +int taptools_transducer_set_asymmetry(taptools_transducer h, double a) { + return with(h, [&](diffuseur_transducer& t) { t.set_asymmetry(a); }); +} + +int taptools_transducer_set_saturation(taptools_transducer h, double s) { + return with(h, [&](diffuseur_transducer& t) { t.set_saturation(s); }); +} + +int taptools_transducer_clear(taptools_transducer h) { + return with(h, [&](diffuseur_transducer& t) { t.clear(); }); +} + +int taptools_transducer_process(taptools_transducer h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](diffuseur_transducer& t) { + for (int i = 0; i < n; ++i) { + out[i] = t.process(in[i]); + } + }); +} + +// ---- tap.plate ------------------------------------------------------------------------------------- + +using diffuseur_plate = tap::tools::diffuseur::plate; + +taptools_plate taptools_plate_create(void) { + return static_cast(new diffuseur_plate()); +} + +void taptools_plate_destroy(taptools_plate h) { + delete static_cast(h); +} + +int taptools_plate_prepare(taptools_plate h, double sr) { + return with(h, [&](diffuseur_plate& p) { p.prepare(sr); }); +} + +int taptools_plate_set_pitch_hz(taptools_plate h, double hz) { + return with(h, [&](diffuseur_plate& p) { p.set_pitch_hz(hz); }); +} + +int taptools_plate_set_decay(taptools_plate h, double t60_s) { + return with(h, [&](diffuseur_plate& p) { p.set_decay(t60_s); }); +} + +int taptools_plate_set_tilt(taptools_plate h, double tilt) { + return with(h, [&](diffuseur_plate& p) { p.set_tilt(tilt); }); +} + +int taptools_plate_set_brightness(taptools_plate h, double b) { + return with(h, [&](diffuseur_plate& p) { p.set_brightness(b); }); +} + +int taptools_plate_clear(taptools_plate h) { + return with(h, [&](diffuseur_plate& p) { p.clear(); }); +} + +int taptools_plate_process(taptools_plate h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](diffuseur_plate& p) { + for (int i = 0; i < n; ++i) { + out[i] = p.process(in[i]); + } + }); +} + +double taptools_plate_mode_hz(taptools_plate h, int mode) { + const diffuseur_plate* p = static_cast(h); + return p ? p->mode_hz(mode) : std::nan(""); +} + +double taptools_plate_mode_level(taptools_plate h, int mode) { + const diffuseur_plate* p = static_cast(h); + return p ? p->mode_level(mode) : std::nan(""); +} + +// ---- tap.metallique~ ------------------------------------------------------------------------------ + +using diffuseur_metallique = tap::tools::diffuseur::metallique; + +taptools_metallique taptools_metallique_create(void) { + return static_cast(new diffuseur_metallique()); +} + +void taptools_metallique_destroy(taptools_metallique h) { + delete static_cast(h); +} + +int taptools_metallique_prepare(taptools_metallique h, double sr) { + return with(h, [&](diffuseur_metallique& m) { m.prepare(sr); }); +} + +int taptools_metallique_set_pitch_hz(taptools_metallique h, double hz) { + return with(h, [&](diffuseur_metallique& m) { m.set_pitch_hz(hz); }); +} + +int taptools_metallique_set_decay(taptools_metallique h, double t60_s) { + return with(h, [&](diffuseur_metallique& m) { m.set_decay(t60_s); }); +} + +int taptools_metallique_set_tilt(taptools_metallique h, double tilt) { + return with(h, [&](diffuseur_metallique& m) { m.set_tilt(tilt); }); +} + +int taptools_metallique_set_brightness(taptools_metallique h, double b) { + return with(h, [&](diffuseur_metallique& m) { m.set_brightness(b); }); +} + +int taptools_metallique_set_drive(taptools_metallique h, double lin) { + return with(h, [&](diffuseur_metallique& m) { m.set_drive(lin); }); +} + +int taptools_metallique_set_asymmetry(taptools_metallique h, double a) { + return with(h, [&](diffuseur_metallique& m) { m.set_asymmetry(a); }); +} + +int taptools_metallique_set_saturation(taptools_metallique h, double s) { + return with(h, [&](diffuseur_metallique& m) { m.set_saturation(s); }); +} + +int taptools_metallique_set_mix(taptools_metallique h, double pct) { + return with(h, [&](diffuseur_metallique& m) { m.set_mix(pct); }); +} + +int taptools_metallique_set_level(taptools_metallique h, double lin) { + return with(h, [&](diffuseur_metallique& m) { m.set_level(lin); }); +} + +int taptools_metallique_set_smooth_ms(taptools_metallique h, double ms) { + return with(h, [&](diffuseur_metallique& m) { m.set_smooth_ms(ms); }); +} + +int taptools_metallique_clear(taptools_metallique h) { + return with(h, [&](diffuseur_metallique& m) { m.clear(); }); +} + +int taptools_metallique_process(taptools_metallique h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](diffuseur_metallique& m) { m.process(in, out, static_cast(n)); }); +} + +double taptools_metallique_mode_hz(taptools_metallique h, int mode) { + const diffuseur_metallique* m = static_cast(h); + return m ? m->body().mode_hz(mode) : std::nan(""); +} + +double taptools_metallique_mode_level(taptools_metallique h, int mode) { + const diffuseur_metallique* m = static_cast(h); + return m ? m->body().mode_level(mode) : std::nan(""); +} + +// ---- tap.palme~ ----------------------------------------------------------------------------------- + +using diffuseur_palme = tap::tools::diffuseur::palme; + +taptools_palme taptools_palme_create(void) { + return static_cast(new diffuseur_palme()); +} + +void taptools_palme_destroy(taptools_palme h) { + delete static_cast(h); +} + +int taptools_palme_prepare(taptools_palme h, double sr) { + return with(h, [&](diffuseur_palme& p) { p.prepare(sr); }); +} + +int taptools_palme_set_root_hz(taptools_palme h, double hz) { + return with(h, [&](diffuseur_palme& p) { p.set_root_hz(hz); }); +} + +int taptools_palme_set_tuning(taptools_palme h, int tuning) { + return with(h, [&](diffuseur_palme& p) { p.set_tuning(tuning); }); +} + +int taptools_palme_set_decay(taptools_palme h, double t60_s) { + return with(h, [&](diffuseur_palme& p) { p.set_decay(t60_s); }); +} + +int taptools_palme_set_damping(taptools_palme h, double hz) { + return with(h, [&](diffuseur_palme& p) { p.set_damping(hz); }); +} + +int taptools_palme_set_detune(taptools_palme h, double cents) { + return with(h, [&](diffuseur_palme& p) { p.set_detune(cents); }); +} + +int taptools_palme_set_drive(taptools_palme h, double lin) { + return with(h, [&](diffuseur_palme& p) { p.set_drive(lin); }); +} + +int taptools_palme_set_asymmetry(taptools_palme h, double a) { + return with(h, [&](diffuseur_palme& p) { p.set_asymmetry(a); }); +} + +int taptools_palme_set_saturation(taptools_palme h, double s) { + return with(h, [&](diffuseur_palme& p) { p.set_saturation(s); }); +} + +int taptools_palme_set_mix(taptools_palme h, double pct) { + return with(h, [&](diffuseur_palme& p) { p.set_mix(pct); }); +} + +int taptools_palme_set_level(taptools_palme h, double lin) { + return with(h, [&](diffuseur_palme& p) { p.set_level(lin); }); +} + +int taptools_palme_set_smooth_ms(taptools_palme h, double ms) { + return with(h, [&](diffuseur_palme& p) { p.set_smooth_ms(ms); }); +} + +int taptools_palme_clear(taptools_palme h) { + return with(h, [&](diffuseur_palme& p) { p.clear(); }); +} + +int taptools_palme_process(taptools_palme h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](diffuseur_palme& p) { p.process(in, out, static_cast(n)); }); +} + +double taptools_palme_string_hz(taptools_palme h, int index) { + const diffuseur_palme* p = static_cast(h); + return p ? p->body().string_hz(index) : std::nan(""); +} + +double taptools_palme_string_feedback(taptools_palme h, int index) { + const diffuseur_palme* p = static_cast(h); + return p ? p->body().string_feedback(index) : std::nan(""); +} + +// ---- tap.scrub~ ----------------------------------------------------------------------------------- + +using scrub_machine = tap::tools::scrub::machine; + +taptools_scrub taptools_scrub_create(void) { + return static_cast(new scrub_machine()); +} + +void taptools_scrub_destroy(taptools_scrub h) { + delete static_cast(h); +} + +int taptools_scrub_prepare(taptools_scrub h, double sr, double max_history_ms) { + return with(h, [&](scrub_machine& m) { m.prepare(sr, max_history_ms); }); +} + +int taptools_scrub_set_position_ms(taptools_scrub h, double ms) { + return with(h, [&](scrub_machine& m) { m.set_position_ms(ms); }); +} + +int taptools_scrub_set_pitch(taptools_scrub h, double semitones) { + return with(h, [&](scrub_machine& m) { m.set_pitch(semitones); }); +} + +int taptools_scrub_set_drift(taptools_scrub h, double rate) { + return with(h, [&](scrub_machine& m) { m.set_drift(rate); }); +} + +int taptools_scrub_set_freeze(taptools_scrub h, int on) { + return with(h, [&](scrub_machine& m) { m.set_freeze(on != 0); }); +} + +int taptools_scrub_set_size_ms(taptools_scrub h, double ms) { + return with(h, [&](scrub_machine& m) { m.set_size_ms(ms); }); +} + +int taptools_scrub_set_overlap(taptools_scrub h, int n) { + return with(h, [&](scrub_machine& m) { m.set_overlap(n); }); +} + +int taptools_scrub_set_spray_ms(taptools_scrub h, double ms) { + return with(h, [&](scrub_machine& m) { m.set_spray_ms(ms); }); +} + +int taptools_scrub_set_seed(taptools_scrub h, unsigned long long seed) { + return with(h, [&](scrub_machine& m) { m.set_seed(static_cast(seed)); }); +} + +int taptools_scrub_set_mix(taptools_scrub h, double pct) { + return with(h, [&](scrub_machine& m) { m.set_mix(pct); }); +} + +int taptools_scrub_set_level(taptools_scrub h, double lin) { + return with(h, [&](scrub_machine& m) { m.set_level(lin); }); +} + +int taptools_scrub_set_smooth_ms(taptools_scrub h, double ms) { + return with(h, [&](scrub_machine& m) { m.set_smooth_ms(ms); }); +} + +int taptools_scrub_clear(taptools_scrub h) { + return with(h, [&](scrub_machine& m) { m.clear(); }); +} + +int taptools_scrub_process(taptools_scrub h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](scrub_machine& m) { m.process(in, out, static_cast(n)); }); +} + +int taptools_scrub_process_mod(taptools_scrub h, const double* in, const double* position_ms, const double* pitch_st, + double* out, int n) { + if (!in || !position_ms || !pitch_st || !out || n < 0) { + return -1; + } + return with(h, [&](scrub_machine& m) { + for (int i = 0; i < n; ++i) { + out[i] = m.process(in[i], position_ms[i], pitch_st[i]); + } + }); +} + +int taptools_scrub_active_grains(taptools_scrub h) { + const scrub_machine* m = static_cast(h); + return m ? m->active_grains() : -1; +} + // ---- tap.touche~ --------------------------------------------------------------------------------- using touche_key = tap::tools::touche::key; diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 1588f31..77d10a6 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -393,6 +393,115 @@ TAPTOOLS_API int taptools_tapecho_clear(taptools_tapecho h); /// Process n samples mono-in / stereo-out (the dry path is mixed to both busses). TAPTOOLS_API int taptools_tapecho_process(taptools_tapecho h, const double* in, double* outL, double* outR, int n); +// ---- tap.transducer (tap::tools::diffuseur::transducer) ------------------------------------------ + +/// The diffuseurs' moving-iron driver on its own — a component, not an external. Reachable here +/// because the family's rule is that parts get C ABI reachability from the start, and because +/// measuring the driver through a body means measuring the body too. +typedef void* taptools_transducer; + +TAPTOOLS_API taptools_transducer taptools_transducer_create(void); +TAPTOOLS_API void taptools_transducer_destroy(taptools_transducer h); +TAPTOOLS_API int taptools_transducer_prepare(taptools_transducer h, double sr); +TAPTOOLS_API int taptools_transducer_set_drive(taptools_transducer h, double lin); +TAPTOOLS_API int taptools_transducer_set_asymmetry(taptools_transducer h, double a); +TAPTOOLS_API int taptools_transducer_set_saturation(taptools_transducer h, double s); +TAPTOOLS_API int taptools_transducer_clear(taptools_transducer h); +TAPTOOLS_API int taptools_transducer_process(taptools_transducer h, const double* in, double* out, int n); + +// ---- tap.plate (tap::tools::diffuseur::plate) ---------------------------------------------------- + +/// The metallique's body on its own — the mode bank without the driver in front of it. Same +/// reason as the transducer above: the parts are reachable so a measurement of one is not +/// silently a measurement of both. +typedef void* taptools_plate; + +TAPTOOLS_API taptools_plate taptools_plate_create(void); +TAPTOOLS_API void taptools_plate_destroy(taptools_plate h); +TAPTOOLS_API int taptools_plate_prepare(taptools_plate h, double sr); +TAPTOOLS_API int taptools_plate_set_pitch_hz(taptools_plate h, double hz); +TAPTOOLS_API int taptools_plate_set_decay(taptools_plate h, double t60_s); +TAPTOOLS_API int taptools_plate_set_tilt(taptools_plate h, double tilt); +TAPTOOLS_API int taptools_plate_set_brightness(taptools_plate h, double b); +TAPTOOLS_API int taptools_plate_clear(taptools_plate h); +TAPTOOLS_API int taptools_plate_process(taptools_plate h, const double* in, double* out, int n); +TAPTOOLS_API double taptools_plate_mode_hz(taptools_plate h, int mode); +TAPTOOLS_API double taptools_plate_mode_level(taptools_plate h, int mode); + +// ---- tap.metallique~ (tap::tools::diffuseur::metallique) ----------------------------------------- + +typedef void* taptools_metallique; + +TAPTOOLS_API taptools_metallique taptools_metallique_create(void); +TAPTOOLS_API void taptools_metallique_destroy(taptools_metallique h); +TAPTOOLS_API int taptools_metallique_prepare(taptools_metallique h, double sr); +TAPTOOLS_API int taptools_metallique_set_pitch_hz(taptools_metallique h, double hz); +TAPTOOLS_API int taptools_metallique_set_decay(taptools_metallique h, double t60_s); +/// Upper modes decay by ratio^tilt faster than the fundamental. +TAPTOOLS_API int taptools_metallique_set_tilt(taptools_metallique h, double tilt); +TAPTOOLS_API int taptools_metallique_set_brightness(taptools_metallique h, double b); // 0..1 +TAPTOOLS_API int taptools_metallique_set_drive(taptools_metallique h, double lin); +TAPTOOLS_API int taptools_metallique_set_asymmetry(taptools_metallique h, double a); // 0..1, moving-iron squared term +TAPTOOLS_API int taptools_metallique_set_saturation(taptools_metallique h, double s); // 0 is exactly linear +TAPTOOLS_API int taptools_metallique_set_mix(taptools_metallique h, double pct); // 0..100, equal-power +TAPTOOLS_API int taptools_metallique_set_level(taptools_metallique h, double lin); +TAPTOOLS_API int taptools_metallique_set_smooth_ms(taptools_metallique h, double ms); +TAPTOOLS_API int taptools_metallique_clear(taptools_metallique h); +TAPTOOLS_API int taptools_metallique_process(taptools_metallique h, const double* in, double* out, int n); +/// The body's tuning, so a notebook can plot where the modes landed (NaN on a bad handle). +TAPTOOLS_API double taptools_metallique_mode_hz(taptools_metallique h, int mode); +TAPTOOLS_API double taptools_metallique_mode_level(taptools_metallique h, int mode); + +// ---- tap.palme~ (tap::tools::diffuseur::palme) --------------------------------------------------- + +typedef void* taptools_palme; + +TAPTOOLS_API taptools_palme taptools_palme_create(void); +TAPTOOLS_API void taptools_palme_destroy(taptools_palme h); +TAPTOOLS_API int taptools_palme_prepare(taptools_palme h, double sr); +TAPTOOLS_API int taptools_palme_set_root_hz(taptools_palme h, double hz); +TAPTOOLS_API int taptools_palme_set_tuning(taptools_palme h, int tuning); // 0 chromatic, 1 harmonic +TAPTOOLS_API int taptools_palme_set_decay(taptools_palme h, double t60_s); +TAPTOOLS_API int taptools_palme_set_damping(taptools_palme h, double hz); +TAPTOOLS_API int taptools_palme_set_detune(taptools_palme h, double cents); +TAPTOOLS_API int taptools_palme_set_drive(taptools_palme h, double lin); +TAPTOOLS_API int taptools_palme_set_asymmetry(taptools_palme h, double a); +TAPTOOLS_API int taptools_palme_set_saturation(taptools_palme h, double s); +TAPTOOLS_API int taptools_palme_set_mix(taptools_palme h, double pct); +TAPTOOLS_API int taptools_palme_set_level(taptools_palme h, double lin); +TAPTOOLS_API int taptools_palme_set_smooth_ms(taptools_palme h, double ms); +TAPTOOLS_API int taptools_palme_clear(taptools_palme h); +TAPTOOLS_API int taptools_palme_process(taptools_palme h, const double* in, double* out, int n); +/// Where a string ended up after tuning and scatter, in Hz (NaN on a bad handle). +TAPTOOLS_API double taptools_palme_string_hz(taptools_palme h, int index); +/// The loop gain a string settled on — the cap is visible here when damping and ring time fight. +TAPTOOLS_API double taptools_palme_string_feedback(taptools_palme h, int index); + +// ---- tap.scrub~ (tap::tools::scrub::machine) ----------------------------------------------------- + +typedef void* taptools_scrub; + +TAPTOOLS_API taptools_scrub taptools_scrub_create(void); +TAPTOOLS_API void taptools_scrub_destroy(taptools_scrub h); +TAPTOOLS_API int taptools_scrub_prepare(taptools_scrub h, double sr, double max_history_ms); +TAPTOOLS_API int taptools_scrub_set_position_ms(taptools_scrub h, double ms); // lag behind the live edge +TAPTOOLS_API int taptools_scrub_set_pitch(taptools_scrub h, double semitones); +TAPTOOLS_API int taptools_scrub_set_drift(taptools_scrub h, double rate); // playback-rate units +TAPTOOLS_API int taptools_scrub_set_freeze(taptools_scrub h, int on); +TAPTOOLS_API int taptools_scrub_set_size_ms(taptools_scrub h, double ms); +TAPTOOLS_API int taptools_scrub_set_overlap(taptools_scrub h, int n); // 1..4 +TAPTOOLS_API int taptools_scrub_set_spray_ms(taptools_scrub h, double ms); +TAPTOOLS_API int taptools_scrub_set_seed(taptools_scrub h, unsigned long long seed); +TAPTOOLS_API int taptools_scrub_set_mix(taptools_scrub h, double pct); +TAPTOOLS_API int taptools_scrub_set_level(taptools_scrub h, double lin); +TAPTOOLS_API int taptools_scrub_set_smooth_ms(taptools_scrub h, double ms); +TAPTOOLS_API int taptools_scrub_clear(taptools_scrub h); +TAPTOOLS_API int taptools_scrub_process(taptools_scrub h, const double* in, double* out, int n); +/// Signal-rate performance path: position (ms behind the edge) and pitch (semitones) per sample. +TAPTOOLS_API int taptools_scrub_process_mod(taptools_scrub h, const double* in, const double* position_ms, + const double* pitch_st, double* out, int n); +TAPTOOLS_API int taptools_scrub_active_grains(taptools_scrub h); // -1 on a bad handle + // ---- tap.touche~ (tap::tools::touche::key) ------------------------------------------------------- typedef void* taptools_touche; diff --git a/tools/render/radiohead_render.cpp b/tools/render/radiohead_render.cpp index 9771b7a..24e9b91 100644 --- a/tools/render/radiohead_render.cpp +++ b/tools/render/radiohead_render.cpp @@ -24,7 +24,16 @@ /// and `fuzz_edge_and_bite` (the knee sharpening, then the even harmonics coming /// in); and `touche_against_a_fade`, which swells one note three times — a linear /// fade, a fade linear in dB, and the Ondes Martenot's published intensity-key -/// curve — because the measured law is audibly neither of the obvious two. +/// curve — because the measured law is audibly neither of the obvious two; then +/// `metallique_stages` (the same phrase dry, through the gong with a linear driver, +/// with the moving-iron squared term armed, and driven hard enough that the saturator +/// is working — the order is the argument for the transducer being a real stage) and +/// `palme_halo` (the twelve strings answering a phrase, chromatic then harmonic then +/// detuned); and `scrub_gesture` (the position raked across a running loop, then the +/// same rake with the pitch riding its own independent gesture — the two hands are +/// the object) and `scrub_freeze` (two seconds recorded, the recorder stopped, and +/// nine seconds built out of that fixed tape: held, crawled through with drift, then +/// scattered with spray). /// /// Usage: radiohead_render [output-directory] (default: current directory) /// @author Timothy Place @@ -38,7 +47,9 @@ #include #include +#include #include +#include #include #include #include @@ -470,6 +481,147 @@ namespace { write_scenario(dir + "/touche_against_a_fade.wav", mono, 0.9, 1); } + // ---- the diffuseurs --------------------------------------------------------------------------- + + /// The métallique against a bare signal. The same phrase runs four times: dry, then through + /// the gong with the transducer linear, then with the moving-iron squared term armed, then + /// with the drive pushed so the saturator is doing real work. The order is the argument — + /// a diffuseur modelled as a resonator alone is missing a documented stage, and the third + /// and fourth passes are what that stage sounds like. + void metallique_stages(const std::string& dir) { + const double pass = 9.0; + const size_t frames = static_cast(pass * k_r_sr); + std::vector mono; + mono.reserve(4 * frames); + + for (int stage = 0; stage < 4; ++stage) { + tap::tools::diffuseur::metallique m; + m.prepare(k_r_sr); + m.set_pitch_hz(146.0); + m.set_decay(7.0); + m.set_tilt(0.9); + m.set_brightness(0.85); + m.set_mix((stage == 0) ? 0.0 : 70.0); + m.set_drive((stage == 3) ? 6.0 : 1.0); + m.set_asymmetry((stage >= 2) ? 0.45 : 0.0); + m.set_saturation((stage >= 2) ? 0.6 : 0.0); + // Levelled so the four passes are comparable by ear: the body is a colouring, not a + // boost, and the hard-driven pass is far louder than the rest. + m.set_level((stage == 0) ? 1.0 : ((stage == 3) ? 0.45 : 1.9)); + + for (size_t i = 0; i < frames; ++i) { + mono.push_back(m.process(phrase(demo_phrase(), static_cast(i) / k_r_sr))); + } + } + write_scenario(dir + "/metallique_stages.wav", mono, 0.7, 1); + } + + /// The palme's halo. A phrase in A minor into the twelve chromatic strings, then the same + /// phrase into the harmonic tuning on the same root — the first answers every note, the + /// second answers only what belongs to A. Then the detune opened, so the board beats. + void palme_halo(const std::string& dir) { + const double pass = 11.0; + const size_t frames = static_cast(pass * k_r_sr); + std::vector mono; + mono.reserve(3 * frames); + + const int tunings[3] = {tap::tools::diffuseur::tuning_chromatic, tap::tools::diffuseur::tuning_harmonic, + tap::tools::diffuseur::tuning_chromatic}; + const double detunes[3] = {0.0, 0.0, 22.0}; + + for (int pass_index = 0; pass_index < 3; ++pass_index) { + tap::tools::diffuseur::palme p; + p.prepare(k_r_sr); + p.set_root_hz(110.0); + p.set_tuning(tunings[pass_index]); + p.set_decay(5.0); + p.set_damping(3500.0); + p.set_detune(detunes[pass_index]); + p.set_drive(1.0); + p.set_asymmetry(0.2); + p.set_saturation(0.35); + p.set_mix(55.0); + p.set_level(0.5); // twelve resonant loops add up + + for (size_t i = 0; i < frames; ++i) { + mono.push_back(p.process(phrase(demo_phrase(), static_cast(i) / k_r_sr))); + } + } + write_scenario(dir + "/palme_halo.wav", mono, 0.4, 1); // twelve high-Q loops peak hard + } + + // ---- tap.scrub~ ------------------------------------------------------------------------------- + + /// The scrub as it is actually played: the position dragged back and forth across the last + /// second and a half of a loop that keeps running underneath, first at unity pitch, then with + /// the pitch riding its own independent gesture. The two hands are the object, so the render + /// moves both. + void scrub_gesture(const std::string& dir) { + const double pass = 12.0; + const size_t frames = static_cast(pass * k_r_sr); + std::vector mono; + mono.reserve(2 * frames); + + for (int with_pitch = 0; with_pitch < 2; ++with_pitch) { + tap::tools::scrub::machine m; + m.prepare(k_r_sr, 3000.0); + m.set_size_ms(70.0); + m.set_overlap(2); + m.set_mix(100.0); + m.set_smooth_ms(8.0); + + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + // A rake back and forth: slow at first, then faster as the gesture takes hold. + const double rate = 0.25 + 0.45 * (t / pass); + const double sweep = 0.5 - 0.5 * std::cos(2.0 * k_r_pi * rate * t); + m.set_position_ms(1500.0 * sweep); + if (with_pitch != 0) { + m.set_pitch(7.0 * std::sin(2.0 * k_r_pi * 0.11 * t)); + } + mono.push_back(m.process(looping_phrase(t))); + } + } + write_scenario(dir + "/scrub_gesture.wav", mono, 0.8, 1); + } + + /// The frozen half of the object: two seconds of the phrase go in, the recorder stops, and + /// everything afterwards is made out of that fixed tape — first held still, then crawled + /// through with `drift`, then scattered with `spray`. Nothing is going into the input at all + /// after the freeze, which is the point. + void scrub_freeze(const std::string& dir) { + tap::tools::scrub::machine m; + m.prepare(k_r_sr, 3000.0); + m.set_size_ms(110.0); + m.set_overlap(3); + m.set_mix(100.0); + m.set_smooth_ms(20.0); + m.set_position_ms(900.0); + m.set_seed(7); + + const size_t live = static_cast(2.5 * k_r_sr); + const size_t held = static_cast(9.0 * k_r_sr); + std::vector mono; + mono.reserve(live + held); + + for (size_t i = 0; i < live; ++i) { + mono.push_back(m.process(looping_phrase(static_cast(i) / k_r_sr))); + } + m.set_freeze(true); + for (size_t i = 0; i < held; ++i) { + const double t = static_cast(i) / k_r_sr; + if (t > 3.0 && t <= 6.0) { + m.set_drift(-0.35); // crawl backwards through the frozen tape + } + else if (t > 6.0) { + m.set_drift(0.0); + m.set_spray_ms(260.0); // and then let the origin scatter + } + mono.push_back(m.process(0.0)); // nothing going in: all of this is the frozen tape + } + write_scenario(dir + "/scrub_freeze.wav", mono, 0.8, 1); + } + } // namespace int main(int argc, char** argv) { @@ -485,5 +637,9 @@ int main(int argc, char** argv) { fuzz_tone(dir); fuzz_edge_and_bite(dir); touche_against_a_fade(dir); + metallique_stages(dir); + palme_halo(dir); + scrub_gesture(dir); + scrub_freeze(dir); return 0; } From 01a280fb79b0e12f3568ace2d36c91f4150ad5c1 Mon Sep 17 00:00:00 2001 From: Timothy Place Date: Mon, 17 Aug 2026 12:30:11 +0000 Subject: [PATCH 15/22] Add the Ondes Martenot voice: the triode stages and the heterodyne source MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ondes.h — the last two pieces of the instrument, and the two the family plan had wrong. Three components under a thin composition: `triode` (one common-cathode stage solved on its load line), `detector` (the heterodyne pair and its envelope detector, in closed form), and `voice` (detector into two triode stages into the intensity key). Almost none of this is voiced by ear. Najnudel, Hélie, Roze & Boutin (IEEE/ACM TASLP 28, 2020) name the tube model — the enhanced Norman Koren law — write out its equations, and publish parameter sets fitted to the actual valves in ondes No. 169, along with every stage's supply voltage and cathode resistor. So the triode is a citation rather than a design: the static load-line solution at a published operating point, which is a memoryless nonlinearity in the DAFx-07 sense, so tabulating it is not an approximation of the model but the model itself. The fitted 6C5 lands at 8.85 mA against its datasheet's 8 mA typical. The plan's central instruction for the source was wrong, and catching it is the most valuable thing here. "Synthesize the difference tone directly as a sinusoid" would have thrown away the instrument's largest source of harmonics: the paper's licence to use a sinewave generator applies to the OSCILLATORS, and the demodulator is an envelope detector, not a mixer. The envelope of two summed oscillators is 2|cos|, whose series puts H2 at -14.0 dB and H3 at -21.3 dB before any valve touches the signal. What replaces the carrier is an identity rather than a simplification: the envelope of cos(P) + d*cos(P-p) is exactly sqrt(1 + d^2 + 2d cos p), so the 80 kHz carrier drops out of the arithmetic. Running the published 200 us RC detector on that closed form reproduces the full heterodyne-plus-diode-plus-RC simulation to within 0.10 dB on every harmonic at every pitch, with one uniform 3% level offset. It also makes oscillator balance a real physical timbre control, and the detector's pitch dependence falls out free. Two errors found by measurement and fixed: a stage that quietly un-inverted itself applied the tube's asymmetry to the wrong side of the waveform, so the drive knob REDUCED harmonics as it was turned up; and an oversampling probe that measured its own leakage rather than aliasing. Two things the sources do not settle — where the intensity key sits in the chain, and the winding sense of the transformer between the stages — are switches rather than silent guesses, because both measure as audible. Also: evidence for fuzz.h's open oversampler question. This object runs the same 8th-order chain around a comparably hard nonlinearity but as a SOURCE, with nothing zero-stuffed and therefore no images, and its sequence never reverses where fuzz.h's did. Recorded in both headers as evidence, not proof. 17 Catch2 scenarios, the C ABI and ctypes surfaces (Triode, Detector, Ondes, plus the bare tube law), the executed notebooks/ondes.ipynb, and four render scenarios including the whole instrument through each of its diffuseurs. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- README.md | 1 + book/PLAN-ondes.md | 115 ++-- book/PLAN-radiohead-family.md | 30 +- include/taptools/fuzz.h | 20 +- include/taptools/ondes.h | 735 +++++++++++++++++++++++ include/taptools/taptools.h | 1 + notebooks/ondes.ipynb | 943 ++++++++++++++++++++++++++++++ notebooks/taptools_py.py | 291 +++++++++ tests/CMakeLists.txt | 1 + tests/ondes_test.cpp | 493 ++++++++++++++++ tools/capi/taptools_capi.cpp | 254 ++++++++ tools/capi/taptools_capi.h | 83 +++ tools/render/radiohead_render.cpp | 183 +++++- 13 files changed, 3098 insertions(+), 52 deletions(-) create mode 100644 include/taptools/ondes.h create mode 100644 notebooks/ondes.ipynb create mode 100644 tests/ondes_test.cpp diff --git a/README.md b/README.md index 2fd7596..8171e14 100644 --- a/README.md +++ b/README.md @@ -39,6 +39,7 @@ header adds no nested namespace, the class) the kernel lives in. | `fuzz.h` | `tap.fuzz~` | Two-stage tone-stacked fuzz on the DAFx-07 cascade (`tap::tools::fuzz`) | | `touche.h` | `tap.touche~` | The Ondes Martenot intensity key as a published gain law (`tap::tools::touche`) | | `diffuseur.h` | `tap.metallique~`, `tap.palme~` | The Ondes diffuseurs as driven resonators (`tap::tools::diffuseur`) | +| `ondes.h` | `tap.ondes~`, `tap.triode~` | The Ondes Martenot voice: heterodyne detector and load-line triode stages (`tap::tools::ondes`) | **Voices, drums, and sequencing** diff --git a/book/PLAN-ondes.md b/book/PLAN-ondes.md index c17a025..003457e 100644 --- a/book/PLAN-ondes.md +++ b/book/PLAN-ondes.md @@ -1,8 +1,10 @@ # Plan — `tap.ondes~`, after reading the sources -> **Status: in progress — `touche` shipped 2026-08-15 as `tap.touche~`, and both diffuseurs -> shipped 2026-08-17 as `tap.metallique~` and `tap.palme~`; the `triode` and the heterodyne -> `source` are still design.** The source gate is closed — +> **Status: complete as an object — every piece has shipped.** `touche` 2026-08-15 as +> `tap.touche~`; both diffuseurs 2026-08-17 as `tap.metallique~` and `tap.palme~`; the `triode` +> and the heterodyne source 2026-08-17 as `tap.triode~` and `tap.ondes~`. What remains is the +> waveform registers, which are still unsourced (see the last section), and the book chapter. +> The source gate is closed — > `PLAN-radiohead-family.md` §3 records what was found and how far each paper was read. This > file is the design pass those findings forced, written before any code, because what the > papers describe is **not the object the family plan sketched**. @@ -85,37 +87,69 @@ The measurement is in `PLAN-radiohead-family.md`; the design consequences: Honest limit to state in the header: the table is one instrument (No. 320) and the paper notes variation between units can exceed 10 %. -## `triode` — where the timbre actually is +## `triode` — where the timbre actually is — ✅ shipped -The circuit paper attributes the harmonics to two successive triode stages after the -demodulator, and their plugin exposes demodulator input gain as a harmonics control — a knob -the real instrument does not have, and a good precedent for exposing one here. - -This is `fuzz.h` territory and should reuse its thinking rather than its code: a -conditioning filter, an asymmetric static curve (triodes are strongly asymmetric — even -harmonics are the point), an equalization filter, and oversampling. Two stages, cascaded, with -the gain-staging lesson from `fuzz.h` applied from the start: **the small-signal slope of the -curve family compounds**, so the drive floor must sit low enough that stage two is not -saturated at zero. - -Open question: whether to model the triode with a published grid-conduction curve or to reuse -the tanh family with an asymmetry bias. The former is more honest to the instrument; the -latter is already in the house and measured. Decide with a listening comparison, and document -whichever loses. - -## `source` — cheap, and deliberately so +> **Shipped 2026-08-17** as `tap.triode~`, in `include/taptools/ondes.h`. +> +> **The open question resolved itself on a closer read, and in the best possible direction.** The +> plan framed it as a choice between "a published grid-conduction curve" and "the tanh family with +> an asymmetry bias". It is neither, because the circuit paper does not merely *mention* a tube +> model — it names one (the **enhanced Norman Koren** model: Koren, *Glass Audio* 8(5), 1996, with +> Cohen & Hélie's grid-current extension, AES 129, 2010), writes out its equations, and publishes +> parameter sets **fitted to the actual valves in ondes No. 169** in its Table II, alongside the +> supply voltages and cathode resistors of every stage. So there was nothing to voice by ear and +> nothing to choose: the whole stage is a citation. +> +> A stage is then the static solution of `ipc(vpc, vgc) = (Vbias − Vk − vpc)/Rp` on its load line +> — a memoryless nonlinearity in the DAFx-07 sense, so tabulating it is not an approximation of +> the model, it *is* the model. The published operating points bias sanely (6C5 demodulator: +> Vk 2.70 V, Vp 86.5 V, Ip 2.70 mA, gain 4.86) and the curve is strongly asymmetric — a 2.17:1 +> ratio between the two directions at ±4 units — which is where a triode's even harmonics live. +> +> Two things the build added to the plan. **The stage must invert**, and the sign is load-bearing +> rather than cosmetic: the tube's asymmetry acts on whichever side of the waveform actually +> reaches its grid, and a stage that quietly un-inverted itself applied the curve to the wrong +> side. An early cut did exactly that, and its drive knob *reduced* harmonics as it was turned up. +> **And the demodulator's grid-leak detection inverts too** — a growing envelope drives that grid +> toward cutoff — so the two inversions put the demodulator's plate in phase with the envelope +> while its curve has meanwhile acted on the underside. +> +> The gain-staging lesson from `fuzz.h` was applied from the start and held: output is normalized +> by each stage's own small-signal gain, so `drive` sweeps total harmonic content 0.221 → 0.344 +> monotonically without the level running away. -A heterodyne pair whose difference tone is the note. Given the measured 0.03 % distortion, the -kernel should synthesize the difference tone **directly** as a sinusoid rather than simulating -two RF oscillators and a demodulator: same output, a fraction of the cost, and the paper is -the citation for why that is legitimate. The ribbon paper is the reference for how the -variable oscillator's frequency responds to the ribbon, which matters for glide feel. +## `source` — cheap, and deliberately so — ✅ shipped, and the plan was wrong about how -State plainly in the header that this is a *documented simplification of a published model*, -not a circuit solve — and note the number that justifies it. Najnudel et al.'s full -port-Hamiltonian simulation runs at 768 kHz and their plugin consumes 85 % of a laptop core; -that is the road not taken, and the header should say so, so nobody assumes the simple path -was chosen out of ignorance. +> **Shipped 2026-08-17** as `detector` inside `include/taptools/ondes.h`, and composed into +> `tap.ondes~`. +> +> **The plan's central instruction here was a mistake, and catching it is the most valuable thing +> this build did.** "Synthesize the difference tone **directly** as a sinusoid" would have thrown +> away the instrument's single largest source of harmonics. The paper's 0.03 % figure and its +> "replace with a sinewave generator" licence apply to the **oscillators**, not to the +> demodulator — and the demodulator is not a mixer that hands you a difference tone. It is an +> envelope detector, and the envelope of `cos(Φ) + cos(Φ − φ)` is `2|cos(φ/2)|`, whose Fourier +> series puts H2 at −14.0 dB, H3 at −21.3 dB and H4 at −26.4 dB. All of that exists before any +> valve touches the signal. +> +> **What replaces the carrier is better than a simplification: it is an identity.** For amplitudes +> 1 and `depth` the envelope is exactly `sqrt(1 + depth² + 2·depth·cos φ)`, so the 80 kHz carrier +> drops out of the arithmetic rather than being approximated away. Running the published RC +> detector (200 µs, from R4·C21) on that closed form reproduces the full heterodyne-plus-diode- +> plus-RC simulation to **within 0.10 dB on every harmonic at every pitch tried**, with one +> systematic difference — a uniform 3.0–3.2 % level offset, because a follower chasing real +> carrier half-cycles never quite reaches the peak between them. The detector's characteristic +> pitch dependence comes along free: H2 runs −14.0 dB at A2 to −19.3 dB at A6 and the level falls +> 2.0 dB across those five octaves, all out of the same 200 µs. +> +> A bonus the plan did not anticipate: because the closed form is parameterized by the two +> oscillator amplitudes, **oscillator balance becomes a real physical timbre control**. At `depth` +> 1 the envelope closes and the series is full; below that it never closes and the harmonics thin +> out. That is a mismatch between two real oscillators, not an invented knob. +> +> The ribbon law is the circuit paper's Eq. 7, and it is simple: `f = A1 · 2^(d/12·d0)` with +> A1 = 55 Hz. **The ribbon is linear in semitones**, which is exactly why an ondes glissando +> sounds the way it does, and why `set_ribbon` takes semitones rather than Hz. ## The diffuseurs — driven, not struck — ✅ shipped @@ -170,9 +204,10 @@ peer-reviewed source says 12. Prefer 12 and say why. 1. **`touche`** — fully specified, small, independently useful, and it can ship as `tap.touche~` before the rest of the instrument exists. Do this first. 2. ~~**The diffuseurs**~~ — ✅ shipped 2026-08-17 as `tap.metallique~` and `tap.palme~`. -3. **`triode`** — needs a listening comparison to settle the curve question. -4. **`source`** and the composition — last, because it is the cheapest piece and the one most - constrained by the others. +3. ~~**`triode`**~~ — ✅ shipped 2026-08-17 as `tap.triode~`. No listening comparison was needed: + the circuit paper publishes the tube model *and* parameter sets fitted to the instrument's own + valves, so there was no curve to choose. +4. ~~**`source`** and the composition~~ — ✅ shipped 2026-08-17 as `tap.ondes~`. That order deliberately front-loads the parts that are useful on their own, so the object delivers value before the flagship is finished. @@ -185,4 +220,14 @@ delivers value before the flagship is finished. - The waveform-register filter shapes. The circuit paper covers five stages but not the timbre registers in detail; Leipp (*Bulletin du GAM* n°60, 1972) and Laurendeau's monograph are the next places to look, neither yet obtained. If they do not settle it, the registers are a - recreation voiced by ear and the header says so. + recreation voiced by ear and the header says so. **This is now the only thing standing between + `tap.ondes~` and a complete instrument**, and the header states its absence rather than filling + it with invention. +- **Where the intensity key sits in the chain.** The paper's five stages do not include it, so + `tap.ondes~` offers both readings as a switch (`key_placement`): after the valves it is a clean + output law, before them the dirt comes up with the pressure. Measured, the difference is real + (THD 0.311 against 0.222 at a half-press with drive 6), so it is a choice worth exposing rather + than a detail to guess at. +- **The winding sense of the transformer between the two triode stages.** It decides which side of + the waveform the preamplifier's asymmetry acts on, and it is audible — THD 0.274 against 0.394 — + so it is a switch too (`polarity`). diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 2bca904..7a775ff 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -1,10 +1,11 @@ # Plan — the Radiohead family -> **Status: in progress — `tap.tapecho~`, `tap.stammer~` and `tap.fuzz~` shipped end-to-end, -> chapters included (2026-08-15); `tap.touche~`, the two diffuseurs and `tap.scrub~` shipped -> as kernels plus Max slices (2026-08-15/17), chapters still to come for those three.** -> `tap.ondes~`'s remaining pieces (the `triode` stage and the heterodyne `source`) are design. -> This is the drafting record of the +> **Status: every object in the plan has shipped.** `tap.tapecho~`, `tap.stammer~` and +> `tap.fuzz~` end-to-end with chapters (2026-08-15); `tap.touche~`, `tap.metallique~`, +> `tap.palme~`, `tap.scrub~`, `tap.triode~` and `tap.ondes~` as kernels plus Max slices +> (2026-08-15/17), chapters still to come for those six. The one piece of the Ondes Martenot +> still missing is its waveform registers, which no source obtained describes — see +> `PLAN-ondes.md`. This is the drafting record of the > 2026-08-15 survey ("are there Radiohead-inspired objects we should consider?"), amended the > same day against the Eno components wave (`d4cf28a`) before any code was written. It stays > after the objects ship, the plans-directory way; the chapters have their own drafting @@ -35,7 +36,8 @@ Max/MSP. A Radiohead family in a Max package is not a tribute; it is a return. |--------|--------|-----------|-------------|--------| | `tap.tapecho~` | `tapecho.h` | Multi-head tape echo (Copicat / Space Echo school) | `tape_loop.h` — almost pure composition | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.stammer~` | `stammer.h` | The live buffer-stutter rig (*Go To Sleep*, *The Gloaming*) | Original design; `tape::reel`, seeded rng | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | -| `tap.ondes~` | `ondes.h` + diffuseurs | The Ondes Martenot voice and its diffuseurs | Heterodyne source + triode nonlinearity + `garden.h` modal idiom; **not** `vco.h` — see the source hunt | planned — sources read, gate open, needs a design pass | +| `tap.ondes~` | `ondes.h` | The Ondes Martenot voice: heterodyne detector, two triode stages, the intensity key | The published circuit's own reductions; `fuzz.h`'s DAFx-07 architecture with a fitted tube model in place of a tanh | ✅ shipped 2026-08-17 (kernel, notebook, Max slice) | +| `tap.triode~` | `ondes.h` | One triode stage on its load line, from a published tube model | The enhanced Norman Koren model with the circuit paper's fitted parameters | ✅ shipped 2026-08-17 (kernel, notebook, Max slice) | | `tap.fuzz~` | `fuzz.h` | Two-stage tone-stacked fuzz (the OK Computer-era dirt) | `overdrive.h` sibling; the DAFx-07 cascade | ✅ shipped 2026-08-15 (kernel, Max slice, chapters) | | `tap.scrub~` | `scrub.h` | Kaoss-school granular scrub of live capture | `stammer::capture` (shared, not copied) + a Hann grain scheduler | ✅ shipped 2026-08-17 (kernel, notebook, Max slice) | | `tap.metallique~` / `tap.palme~` | `diffuseur.h` | The Ondes diffuseurs as driven resonators | `garden.h`'s modal maths without its strike envelopes; `grm_comb.h`'s sustained resonance | ✅ shipped 2026-08-17 (kernel, notebook, Max slices) | @@ -428,10 +430,18 @@ are the house precedent for schematic-based recreation. **Naming is an open ques and the two taps land a half-window apart. That is a real finding about a shipped object, recorded rather than acted on: fixing it is its own job, with its own tests and its own consumers, and it should not ride along on an unrelated kernel. -- **Chapters for the three newest objects.** `tap.touche~`, the diffuseurs and `tap.scrub~` have - kernels, notebooks and Max slices but no book chapters yet. The touche's belongs inside an - Ondes-family chapter once the `triode` and `source` exist; the diffuseurs' probably with it; - the scrub's belongs beside the stammer in Part V, since they share a tape. +- **Chapters for the six newest objects.** `tap.touche~`, the two diffuseurs, `tap.scrub~`, + `tap.triode~` and `tap.ondes~` have kernels, notebooks and Max slices but no book chapters. + The first three of those and the last two now belong together in one Ondes-family chapter, + since the instrument is complete enough to write about as an instrument; the scrub's belongs + beside the stammer in Part V, since they share a tape. +- ~~**The oversampler's non-monotone sequence** (`fuzz.h`'s open question)~~ — not resolved, but + no longer without evidence. `ondes.h` runs the same 8th-order chain around a comparably hard + nonlinearity as a **source**, with no zero-stuffing and therefore no images, and its sequence + never reverses: about 12 dB per doubling to 4× and 7–12 dB more at 8× in the top octave, where + `fuzz.h` got *worse* at 4×. Same filters, no upsampler, no reversal — which is what the imaging + hypothesis predicted. The next move is unchanged (cascaded 2× halfband resampling in `fuzz.h`), + but it now has a reason behind it rather than a guess. - **Diffuseur delivery.** Ship the resonators inside `tap.ondes~` only, or as standalone externals (`tap.palme~` / `tap.metallique~`) from day one? The components chapter's lesson leans standalone-from-day-one. diff --git a/include/taptools/fuzz.h b/include/taptools/fuzz.h index cdd0eca..5959d87 100644 --- a/include/taptools/fuzz.h +++ b/include/taptools/fuzz.h @@ -230,12 +230,20 @@ namespace tap::tools { /// The cause is not established. The obvious suspect — biquads going ill-conditioned at /// the low normalized cutoffs a high factor needs (0.056 at 8x) — was tested and ruled /// out: the cascade's impulse response decays cleanly to denormal at every factor. The - /// next hypothesis, untested, is imaging: zero-stuffing by N leaves N-1 images for one - /// filter to suppress, and residuals intermodulate in the clipper into products that are - /// not harmonics of the input, which is exactly what the probe measures. If that is - /// right, the fix is cascaded 2x (halfband/polyphase) resampling rather than a single - /// stage at 1/N — each step then suppresses one image at a comfortable normalized - /// frequency. That is the known next move on this file. + /// next hypothesis was imaging: zero-stuffing by N leaves N-1 images for one filter to + /// suppress, and residuals intermodulate in the clipper into products that are not + /// harmonics of the input, which is exactly what the probe measures. If that is right, + /// the fix is cascaded 2x (halfband/polyphase) resampling rather than a single stage at + /// 1/N — each step then suppresses one image at a comfortable normalized frequency. That + /// is the known next move on this file. + /// + /// **There is now evidence for it.** ondes.h runs the same butterworth8 chain around a + /// comparably hard nonlinearity, but as a SOURCE: nothing is zero-stuffed on the way up, + /// its generator simply runs at the high rate, so there are no images at all. Measured + /// the same way, its sequence never reverses — about 12 dB per doubling to 4x and 7-12 dB + /// more at 8x in the top octave (ondes.ipynb §5). Same filters, same order, no upsampler, + /// no reversal. Evidence rather than proof, since the nonlinearity differs too, but it is + /// the first evidence either way and it points at the upsampler. /// /// (Whether overdrive.h is owed the 8th-order change is a live question — different /// nonlinearity, different gain structure, so it needs its own measurement.) diff --git a/include/taptools/ondes.h b/include/taptools/ondes.h new file mode 100644 index 0000000..aad399c --- /dev/null +++ b/include/taptools/ondes.h @@ -0,0 +1,735 @@ +/// @file +/// @brief Portable Ondes Martenot voice kernels (tap.triode~, tap.ondes~) — no Max/Min dep. +/// @details The last two pieces of the instrument, and the two the family plan got wrong before +/// the sources were read. The plan assumed a `vco.h` descendant with waveform +/// registers. The Ondes Martenot is nothing of the kind: it is a **heterodyne** +/// instrument whose two 80 kHz oscillators measure as essentially pure (about 0.03 % +/// second-harmonic distortion even coupled to the rest of the circuit), and every bit +/// of its character comes from what happens *after* the two of them are summed — +/// the envelope detector, two triode gain stages, the intensity key, and the +/// diffuseur. +/// +/// The circuit is Najnudel, Hélie, Roze & Boutin, "Simulation of an ondes Martenot +/// circuit", IEEE/ACM TASLP **28**, 2651–2660, 2020, modelling instrument No. 169 as +/// five port-Hamiltonian stages. This file is **not** that: their full solve runs at +/// 768 kHz and their plugin costs 85 % of a laptop core. What this file takes from +/// them is their *own* published reductions plus their published component values, +/// and it says which is which. +/// +/// Three classes and a thin composition: +/// - `triode` — one common-cathode gain stage, solved on its load line from the +/// **enhanced Norman Koren tube model** at a **published operating point**. +/// - `detector` — the heterodyne pair and its envelope detector, in closed form. +/// - `voice` — detector into two triode stages into the intensity key. +/// +/// ## The tube (published model, published parameters) +/// +/// Koren's model (N. Koren, "Improved vacuum tube models for Spice simulations", +/// *Glass Audio* 8(5), 1996) as extended with a grid-current branch by Cohen & Hélie +/// (AES 129th Convention, 2010), which is what the circuit paper uses: +/// +/// E1 = (vpc/Kp) · ln(1 + exp(Kp · (1/mu + (vgc + Vct)/sqrt(Kvb + vpc²)))) +/// ipc = 2·E1^Ex / Kg for E1 >= 0, else 0 +/// igc = (vgc - Va)/Rgk for vgc >= Va, else 0 +/// +/// The parameter sets are **fitted to the actual tubes in ondes No. 169** and are +/// reproduced verbatim from the circuit paper's Table II — 6F5 in the oscillators, +/// 6C5 in the demodulator and preamplifier, 2A3 in the power amplifier — together +/// with that table's stage supply voltages and cathode resistors. Nothing here is +/// voiced by ear; the numbers are the citation. +/// +/// A stage is then the static solution of the load line +/// `ipc(vpc, vgc) = (Vbias − Vk − vpc)/Rp` with the cathode bias `Vk = Rk·Ipc` found +/// at the quiescent point — a **memoryless nonlinearity**, which is exactly the term +/// in Yeh, Abel & Smith's DAFx-07 simplified cascade (conditioning filter → +/// memoryless nonlinearity → equalization filter), the same architecture `fuzz.h` +/// uses. The curve is tabulated once per tube/operating-point change and read with +/// linear interpolation, so the audio path costs a lookup rather than a root find. +/// +/// ## The detector (exact, and cheaper than the thing it replaces) +/// +/// The circuit paper writes the oscillator sum as an amplitude-modulated sinewave, +/// `cos(Φ) + cos(Φ − φm) = 2 cos(Φ − φm/2) cos(φm/2)`, and detects its envelope with +/// a triode whose grid sits near zero bias — so the grid-cathode junction behaves as +/// a diode, conducting only on positive half-cycles — loaded by R4·C21, a time +/// constant of **200 µs**. +/// +/// Two consequences, and the second is the one the family plan missed. +/// +/// **The envelope is not a sinusoid.** For equal oscillator amplitudes it is +/// `2|cos(π f t)|`, whose Fourier series puts the second harmonic 14.0 dB below the +/// fundamental, the third 21.3 dB down and the fourth 26.4 dB down — a substantial +/// harmonic series generated *before any triode touches the signal*. The plan said to +/// synthesize the difference tone directly as a sinusoid; that would have thrown away +/// the instrument's single largest source of harmonics. (What the paper replaces with +/// a sinewave generator is the **oscillators**, not the demodulator.) +/// +/// **So the carrier need never be simulated.** For amplitudes 1 and `depth` the +/// envelope is exactly `sqrt(1 + depth² + 2·depth·cos(2π f t))`, and running the +/// published RC detector on *that* — instant attack through the diode, 200 µs decay +/// through R4 — reproduces the full 80 kHz heterodyne-plus-diode-plus-RC simulation +/// to **within 0.10 dB on every harmonic** at every pitch tried, with no carrier to +/// alias and no 768 kHz to pay for (measured in notebooks/ondes.ipynb §2). The one +/// systematic difference is a level offset: the closed form sits a uniform 3.0–3.2 % +/// high, because a follower chasing real carrier half-cycles never quite reaches the +/// peak between them. A constant scale on a synthesizer with a level control. +/// +/// The detector's own pitch dependence comes with it, because the RC cannot follow a +/// fast envelope back down: the second harmonic runs from −14.0 dB at A2 to −19.3 dB +/// at A6, and the level falls 2.0 dB across those five octaves. +/// +/// ## The ribbon +/// +/// The circuit paper's Eq. 7 gives the variable oscillator's capacitance in terms of +/// ribbon displacement, and the frequency that falls out of it is +/// `f = A1 · 2^(d / (12 d0))` with A1 = 55 Hz the lowest note and d0 the displacement +/// of one semitone. So the ribbon is **linear in semitones**, which is why an ondes +/// glide sounds the way it does, and `set_ribbon()` takes semitones above A1 for +/// exactly that reason. (The ribbon runs up to about 1.2 m at the highest note.) +/// +/// ## Oversampling, and a data point for an open question +/// +/// The nonlinear chain runs oversampled on `fuzz.h`'s shared Butterworth chain, and +/// here the sequence behaves. Worst non-harmonic energy relative to the fundamental, +/// at 1× / 2× / 4× / 8× (notebooks/ondes.ipynb §5): +/// +/// 587 Hz −79.3 −91.2 −104.5 −103.8 +/// 1175 Hz −65.8 −77.2 −90.6 −92.5 +/// 1760 Hz −57.6 −70.9 −81.1 −82.2 +/// 2637 Hz −51.1 −61.4 −71.8 −83.8 +/// 3520 Hz −45.4 −56.8 −67.0 −74.2 +/// +/// Every doubling is worth about 12 dB up to 4×; past that it is worth 7–12 dB at the +/// top of the range and nothing at the bottom, where the measurement has already +/// bottomed out. **Never worse.** 4× is the default because it is where the cost +/// stops buying uniformly; 8× is there for anyone playing the top octave hard. +/// +/// That matters beyond this file, because `fuzz.h` measured the opposite — 4× came +/// out *worse* than 2× there — and left an untested hypothesis behind: that the +/// culprit is *imaging*, since zero-stuffing by N leaves N−1 images for one filter to +/// suppress and their residuals intermodulate in the clipper into products that are +/// not harmonics of the input. This object is a **source**. Nothing is zero-stuffed +/// on the way up; the detector simply runs fast, so there are no images at all — and +/// the sequence never reverses. Evidence for that hypothesis rather than proof of it +/// (the nonlinearity differs too), but it is the first evidence either way, and it +/// points the same direction. +/// +/// Honest limits: +/// - **This is not a circuit solve.** It is the published *reductions* of one: the +/// oscillators replaced by their closed-form envelope (the paper's own +/// simplification, and here an exact one), the stages reduced to static load-line +/// curves with their reactive coupling replaced by first-order conditioning and +/// equalization filters. The paper's full model is passive by construction; this +/// one is not, and does not claim to be. +/// - **The power amplifier is off by default**, following the paper: it measures +/// almost 5 % second harmonic in their simulation, but the authors report its +/// contribution to the final sound is much less important than the demodulator's +/// and preamplifier's, and drop it for real-time. Measured here, switching it on +/// moves total harmonic content from 0.248 to 0.251 and the second harmonic by +/// 0.1 dB — an independent confirmation of their reason, and the reason it is a +/// switch rather than a deletion. +/// - **Where the intensity key sits in the chain is not published.** The paper's five +/// stages do not include it. Placing it after the triodes (the default) makes it a +/// clean output law; placing it before makes the dirt come up with the pressure. +/// Both are offered, and the choice is labelled a choice. +/// - **No waveform registers.** The real instrument has switchable timbres whose +/// filter shapes are not in any source obtained; adding them from imagination would +/// be the one thing this file is careful not to do. +/// - **No diffuseur.** That is `tap.palme~` / `tap.metallique~` — patch one after +/// this object, which is how the instrument works anyway. +/// - The tube parameters are a fit to *one* instrument's tubes, and tube-to-tube +/// spread in 1930s valves is wide. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#pragma once + +#include +#include +#include +#include + +#include "fuzz.h" // tap::tools::fuzz — ramp, biquad, butterworth8 (the shared oversampling chain) +#include "touche.h" // tap::tools::touche::key — the published intensity-key gain law + +namespace tap::tools { + namespace ondes { + + constexpr double k_pi = 3.14159265358979323846; + + using fuzz::butterworth8; + using fuzz::ramp; + + // ---- the tube ------------------------------------------------------------------------ + + /// One triode's enhanced-Koren parameter set. Every field is a fitted constant, not a + /// design choice. + struct tube_params { + double mu; ///< amplification factor + double ex; ///< plate-current exponent + double kg; ///< plate-current scale + double kp; ///< knee sharpness + double kvb; ///< knee voltage + double vct; ///< contact-potential offset + double va; ///< grid-conduction threshold + double rgk; ///< grid-conduction resistance + }; + + // Najnudel, Hélie, Roze & Boutin, IEEE/ACM TASLP 28 (2020), Table II — fitted to the + // datasheets of the tubes actually in ondes Martenot No. 169. Reproduced verbatim. + constexpr tube_params k_6f5{98.0, 1.6, 2614.0, 905.0, 1.87, 0.5, 0.33, 1300.0}; + constexpr tube_params k_6c5{20.0, 1.5, 2837.0, 138.0, 89.0, 0.8, 0.33, 1300.0}; + constexpr tube_params k_2a3{4.3, 1.5, 1685.0, 43.0, 102.0, -1.2, 0.33, 1300.0}; + + /// Which tube. The names are the instrument's: 6F5 oscillates, 6C5 demodulates and + /// preamplifies, 2A3 drives the diffuseur. + enum tube_index : int { tube_6f5 = 0, tube_6c5, tube_2a3, k_num_tubes }; + + inline const tube_params& tube_at(int index) { + switch (index) { + case tube_6f5: + return k_6f5; + case tube_2a3: + return k_2a3; + default: + return k_6c5; + } + } + + /// One stage's published operating point (TASLP Table II). `rp` is the plate load — the + /// transformer core-loss resistance for the demodulator and preamplifier, the diffuseur's + /// input impedance for the power amplifier. + struct operating_point { + double vbias; + double rk; + double rp; + }; + + constexpr operating_point k_op_demod{100.0, 1000.0, 4000.0}; + constexpr operating_point k_op_preamp{180.0, 1000.0, 4000.0}; + constexpr operating_point k_op_power{230.0, 750.0, 1500.0}; + + /// Plate current in amps — the enhanced Koren law, verbatim from TASLP Eq. 8. + inline double plate_current(const tube_params& t, double vpc, double vgc) { + if (vpc <= 0.0) { + return 0.0; + } + const double z = t.kp * (1.0 / t.mu + (vgc + t.vct) / std::sqrt(t.kvb + vpc * vpc)); + // log1p(exp(z)) with the standard overflow guard: for large z it is z itself. + const double s = (z > 60.0) ? z : std::log1p(std::exp(std::max(z, -60.0))); + const double e1 = (vpc / t.kp) * s; + return (e1 > 0.0) ? 2.0 * std::pow(e1, t.ex) / t.kg : 0.0; + } + + /// Grid current in amps — TASLP Eq. 9. Zero below the conduction threshold, ohmic above. + /// It is small next to the plate current, and the circuit paper keeps it because without + /// it the modelled tube is not passive. + inline double grid_current(const tube_params& t, double vgc) { + return (vgc < t.va) ? 0.0 : (vgc - t.va) / t.rgk; + } + + // ---- one triode stage ------------------------------------------------------------------ + + constexpr int k_curve_points = 1025; // odd, so the quiescent point lands on a sample + constexpr double k_curve_span_v = 30.0; // grid swing the table covers, either way + constexpr int k_solve_steps = 48; // bisection steps per table point + constexpr double k_stage_hp_hz = 20.0; // coupling capacitor / grid leak + constexpr double k_stage_lp_hz = 12000.0; // Miller capacitance and the plate load's pole + + constexpr double k_default_drive_v = 1.0; // grid volts for a unit input + constexpr double k_min_drive_v = 0.001; + constexpr double k_max_drive_v = 40.0; + constexpr double k_default_smooth_ms = 20.0; + + /// One common-cathode triode stage: conditioning highpass → drive → the tube's own load-line + /// curve → equalization lowpass. The curve is the static solution of + /// + /// ipc(vpc, vgc) = (Vbias − Vk − vpc) / Rp, Vk = Rk · Ipc(quiescent) + /// + /// which is a memoryless nonlinearity in the DAFx-07 sense (Yeh, Abel & Smith 2007), so + /// tabulating it is not an approximation of the model — it *is* the model, evaluated once. + /// + /// Output is normalized by the stage's own small-signal gain, so `drive` changes the + /// distortion without changing the level. That is the gain-staging lesson `fuzz.h` + /// learned the hard way, applied here from the start. + class triode { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + set_corners(k_stage_hp_hz, k_stage_lp_hz); + build(); + clear(); + } + + void clear() { m_hp = m_lp = 0.0; } + + /// Which tube (tube_index). **A mode, not a fader**: it rebuilds the curve table + /// (about a thousand load-line solves — sub-millisecond, but not something to automate + /// at audio rate). + void set_tube(int index) { + m_tube = std::clamp(index, 0, k_num_tubes - 1); + build(); + } + + /// The stage's supply, cathode resistor and plate load. Also a mode — same reason. + void set_operating_point(const operating_point& op) { + m_op = op; + build(); + } + + /// Peak grid volts for a unit input. This is the harmonics control — the circuit + /// paper's own plugin exposes demodulator input gain the same way, a knob the real + /// instrument does not have. + void set_drive(double volts) { m_drive = std::clamp(volts, k_min_drive_v, k_max_drive_v); } + + /// Conditioning highpass and equalization lowpass corners, in Hz. + void set_corners(double hp_hz, double lp_hz) { + m_a_hp = 1.0 - std::exp(-2.0 * k_pi * std::max(hp_hz, 0.0) / m_sr); + m_a_lp = 1.0 - std::exp(-2.0 * k_pi * std::max(lp_hz, 1.0) / m_sr); + } + + int tube() const { return m_tube; } + double drive() const { return m_drive; } + double samplerate() const { return m_sr; } + + /// The quiescent point the curve was built around: cathode bias, plate voltage and + /// plate current (volts, volts, amps). Worth exposing — it is the check that the + /// published operating point produces a sane bias rather than a cut-off tube. + double bias_v() const { return m_vk; } + double quiescent_plate_v() const { return m_vp0; } + double quiescent_current_a() const { return m_ip0; } + + /// Small-signal voltage gain magnitude at the quiescent point. The stage itself + /// inverts; `process` preserves that, so this is reported unsigned. + double small_signal_gain() const { return m_gain; } + + /// The stage's static curve: a normalized input in, the normalized plate swing out, + /// exactly as `process` would map it with its filters bypassed. No state touched, so + /// a notebook can plot the transfer without running audio. + double curve_at(double x) const { return lookup(x * m_drive) / (m_gain * m_drive); } + + /// The same curve in the tube's own units: grid volts in, plate volts of swing out. + double plate_swing_at(double grid_volts) const { return lookup(grid_volts); } + + /// One sample. `x` is normalized (±1 is a full-scale signal into `drive` volts). + /// The output is INVERTED, because the stage is. + double process(double x) { + m_hp += m_a_hp * (x - m_hp); + const double y = lookup((x - m_hp) * m_drive) / (m_gain * m_drive); + m_lp += m_a_lp * (y - m_lp); + return m_lp; + } + + private: + /// Solve the load line for the plate voltage at a given grid-to-cathode voltage. + /// `plate_current` rises with vpc and the load line falls, so the difference is + /// monotone and bisection cannot miss. + double solve_plate(double vgc, double vk) const { + const tube_params& t = tube_at(m_tube); + double lo = 0.0; + double hi = m_op.vbias; + for (int i = 0; i < k_solve_steps; ++i) { + const double mid = 0.5 * (lo + hi); + if (plate_current(t, mid, vgc) < (m_op.vbias - vk - mid) / m_op.rp) { + lo = mid; + } + else { + hi = mid; + } + } + return 0.5 * (lo + hi); + } + + /// Find the self-bias point (Vk = Rk·Ip with the tube sitting at −Vk on its grid) and + /// tabulate the transfer curve around it. + void build() { + const tube_params& t = tube_at(m_tube); + + // Cathode self-bias: a damped fixed-point iteration, which converges because + // raising Vk lowers the current that sets it. + m_vk = 1.0; + for (int i = 0; i < 200; ++i) { + const double vp = solve_plate(-m_vk, m_vk); + m_vk = 0.8 * m_vk + 0.2 * (plate_current(t, vp, -m_vk) * m_op.rk); + } + m_vp0 = solve_plate(-m_vk, m_vk); + m_ip0 = plate_current(t, m_vp0, -m_vk); + + // The curve is the plate's true swing from quiescent, sign included: a + // common-cathode stage INVERTS, and that matters here rather than being a + // cosmetic detail — the tube's asymmetry is polarity-sensitive, so a stage that + // quietly un-inverted itself would apply its curve to the wrong side of the + // waveform and generate the wrong harmonics. + for (int i = 0; i < k_curve_points; ++i) { + const double v = span_of(i); + m_curve[static_cast(i)] = + solve_plate(v - m_vk, m_vk) - m_vp0; // grid volts v around the bias point + } + + // Small-signal gain from a central difference across two table steps, as a + // magnitude — the inversion lives in the curve, not in the normalization. + const int c = k_curve_points / 2; + const double dv = span_of(c + 1) - span_of(c - 1); + m_gain = std::abs((m_curve[static_cast(c + 1)] - m_curve[static_cast(c - 1)]) / dv); + if (!(m_gain > 1e-9)) { + m_gain = 1.0; // a cut-off operating point has no gain to normalize by + } + } + + static double span_of(int i) { + return (2.0 * static_cast(i) / static_cast(k_curve_points - 1) - 1.0) * k_curve_span_v; + } + + /// Linear interpolation into the curve, clamped at both ends (cut-off below, grid + /// conduction above — the tube does not do anything interesting past either). + double lookup(double grid_volts) const { + const double p = (grid_volts / k_curve_span_v + 1.0) * 0.5 * (k_curve_points - 1); + if (p <= 0.0) { + return m_curve[0]; + } + if (p >= static_cast(k_curve_points - 1)) { + return m_curve[k_curve_points - 1]; + } + const double f = std::floor(p); + const size_t i = static_cast(f); + const double u = p - f; + return m_curve[i] + u * (m_curve[i + 1] - m_curve[i]); + } + + double m_sr{48000.0}; + int m_tube{tube_6c5}; + operating_point m_op{k_op_demod}; + double m_drive{k_default_drive_v}; + double m_vk{0.0}, m_vp0{0.0}, m_ip0{0.0}, m_gain{1.0}; + double m_a_hp{1.0}, m_a_lp{1.0}; + double m_hp{0.0}, m_lp{0.0}; + + std::array m_curve{}; + }; + + // ---- the heterodyne detector ------------------------------------------------------------- + + constexpr double k_a1_hz = 55.0; // the ribbon's lowest note, per TASLP Eq. 7 + constexpr double k_detect_ms = 0.2; // R4 * C21 = 1 MOhm * 200 pF, TASLP Table II + constexpr double k_min_detect_ms = 0.005; + constexpr double k_max_detect_ms = 20.0; + constexpr double k_min_note_hz = 20.0; + constexpr double k_max_note_hz = 4000.0; + constexpr double k_default_depth = 1.0; // equal oscillator amplitudes: the published case + constexpr double k_max_semitones = 72.0; // six octaves of ribbon, comfortably past 1.2 m + + /// The two oscillators, their sum, and the diode-plus-RC that detects its envelope — + /// without simulating either oscillator. + /// + /// For amplitudes 1 and `depth` the envelope of `cos(Φ) + depth·cos(Φ − φ)` is exactly + /// `sqrt(1 + depth² + 2 depth cos(φ))`, so the carrier drops out of the arithmetic + /// entirely. At depth 1 that is `2|cos(φ/2)|`, the published case, whose harmonics sit at + /// −14.0 / −21.3 / −26.4 dB before anything nonlinear happens. + /// + /// The detector itself is the paper's: the triode's grid sits near zero bias, so the + /// grid-cathode junction conducts only on positive half-cycles and charges instantly, + /// while R4·C21 discharges it with a 200 µs time constant. That asymmetry is why the + /// object gets quieter and purer as it goes up — the RC cannot follow a fast envelope + /// back down. + class detector { + public: + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + set_detect_ms(m_detect_ms); + clear(); + } + + void clear() { + m_phase = 0.0; + m_env = 0.0; + } + + /// The note, in Hz. + void set_frequency(double hz) { m_hz = std::clamp(hz, k_min_note_hz, k_max_note_hz); } + + /// The note, as the ribbon gives it: semitones above A1 (55 Hz). The circuit paper's + /// Eq. 7 makes the ribbon linear in semitones, which is the whole feel of an ondes + /// glide, so this is the primary way in. + void set_ribbon(double semitones) { + set_frequency(k_a1_hz * std::exp2(std::clamp(semitones, 0.0, k_max_semitones) / 12.0)); + } + + /// Relative amplitude of the second oscillator, 0..1. 1 is the published case (equal + /// amplitudes, 100 % modulation, the envelope reaching zero); below that the envelope + /// never closes and the harmonic series thins out. A real mismatch between two + /// oscillators, and the cheapest timbre control this object has. + void set_depth(double d) { m_depth = std::clamp(d, 0.0, 1.0); } + + /// The detector time constant in ms. Defaults to the published 200 µs (R4·C21). + void set_detect_ms(double ms) { + m_detect_ms = std::clamp(ms, k_min_detect_ms, k_max_detect_ms); + m_decay = std::exp(-1.0 / (m_detect_ms * 0.001 * m_sr)); + } + + double frequency() const { return m_hz; } + double semitones() const { return 12.0 * std::log2(m_hz / k_a1_hz); } + double depth() const { return m_depth; } + double detect_ms() const { return m_detect_ms; } + double samplerate() const { return m_sr; } + + /// The ideal envelope at a phase in [0, 1) — the closed form, with no detector on it. + /// Exposed so a test can compare the detector against what it is detecting. + double envelope_at(double phase) const { + return std::sqrt(std::max(0.0, 1.0 + m_depth * m_depth + 2.0 * m_depth * std::cos(2.0 * k_pi * phase))); + } + + /// Advance one sample and return the detected envelope. The DC it carries is real — + /// the circuit's coupling capacitor removes it downstream, and so does the triode + /// stage's conditioning highpass. + double process() { + m_phase += m_hz / m_sr; + m_phase -= std::floor(m_phase); + m_env = std::max(envelope_at(m_phase), m_env * m_decay); + return m_env; + } + + private: + double m_sr{48000.0}; + double m_hz{k_a1_hz * 4.0}; + double m_depth{k_default_depth}; + double m_detect_ms{k_detect_ms}; + double m_decay{0.0}; + double m_phase{0.0}; + double m_env{0.0}; + }; + + // ---- the voice ----------------------------------------------------------------------- + + constexpr int k_max_oversample = 8; + constexpr int k_default_os = 4; + constexpr double k_default_level = 0.25; // two triode stages add up; this is a sane start + constexpr double k_dc_r = 0.999; + + /// Where the intensity key sits. The circuit paper's five stages do not include it, so + /// this is a modelling choice rather than a reconstruction — and both readings are + /// musical, which is why both are offered. + enum key_placement : int { + key_after = 0, ///< a clean output law: pressure changes level, not dirt + key_before, ///< pressure drives the tubes: soft is clean, hard is loud and dirty + k_num_key_placements + }; + + /// The instrument, minus the diffuseur: the heterodyne detector into the demodulator + /// triode into the preamplifier triode into the intensity key. The power amplifier is a + /// switch, off by default, following the circuit paper's own reduction. + /// + /// The nonlinear part runs oversampled on the shared `fuzz.h` chain. Patch a + /// `tap.palme~` or `tap.metallique~` after this object for the rest of the instrument. + class voice { + public: + voice() { + m_drive.snap(1.0); + m_level.snap(k_default_level); + } + + // -- lifecycle ----------------------------------------------------------------------- + + void prepare(double sr) { + m_sr = (sr > 0.0) ? sr : 48000.0; + m_key.prepare(m_sr); + configure(); + m_drive.snap(m_drive.target()); + m_level.snap(m_level.target()); + m_prepared = true; + clear(); + } + + /// Silence the detector and every filter. Parameters are untouched. + void clear() { + m_detector.clear(); + m_demod.clear(); + m_preamp.clear(); + m_power.clear(); + m_down.reset(); + m_dc_x1 = m_dc_y1 = 0.0; + } + + bool prepared() const { return m_prepared; } + + // -- the performance surface ---------------------------------------------------------- + + /// The note, as the ribbon gives it: semitones above A1. + void set_ribbon(double semitones) { m_detector.set_ribbon(semitones); } + void set_frequency(double hz) { m_detector.set_frequency(hz); } + + /// Oscillator balance, 0..1 — see detector::set_depth. + void set_depth(double d) { m_detector.set_depth(d); } + + /// Detector time constant in ms; the published value is 0.2. + void set_detect_ms(double ms) { m_detector.set_detect_ms(ms); } + + /// Grid drive into the two triode stages, as a multiple of the published nominal. + /// This is the harmonics control the paper's own plugin exposes. + void set_drive(double x) { m_drive.to(std::clamp(x, 0.0, 8.0), smooth_samples()); } + + /// The intensity key, 0..1 over the physical travel (touche.h's contract: the bottom + /// 45 % is silent, because that is the key bending before it reaches the powder bag). + void set_key(double position) { m_key.set_position(position); } + void set_key_mm(double mm) { m_key.set_position_mm(mm); } + + /// Where the key sits in the chain (key_placement) — a choice, see the header. + void set_key_placement(int where) { m_key_where = std::clamp(where, 0, k_num_key_placements - 1); } + + /// Run the 2A3 power stage. Off by default: the paper measures almost 5 % second + /// harmonic there but reports its contribution as much less important than the two + /// stages before it, and drops it for real-time. + void set_power_stage(bool on) { m_power_on = on; } + + /// Sign of the coupling between the two triode stages, +1 or -1. The circuit couples + /// them through a transformer whose winding sense is not in the source, and the sign + /// decides which side of the waveform the preamplifier's asymmetry acts on — so it is + /// audible, and it is offered as a switch rather than guessed at silently. + void set_polarity(int sign) { m_polarity = (sign < 0) ? -1.0 : 1.0; } + + void set_level(double lin) { m_level.to(lin, smooth_samples()); } + + /// Oversampling for the nonlinear chain: 1, 2, 4 or 8. + void set_oversample(int os) { + const int v = std::clamp(os, 1, k_max_oversample); + m_os = (v >= 8) ? 8 : (v >= 4) ? 4 : (v >= 2) ? 2 : 1; + if (m_prepared) { + configure(); + clear(); + } + } + + void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + + // -- introspection --------------------------------------------------------------------- + + double semitones() const { return m_detector.semitones(); } + double frequency() const { return m_detector.frequency(); } + double depth() const { return m_detector.depth(); } + double detect_ms() const { return m_detector.detect_ms(); } + double drive() const { return m_drive.target(); } + double key() const { return m_key.position(); } + int key_placement() const { return m_key_where; } + bool power_stage() const { return m_power_on; } + int polarity() const { return (m_polarity < 0.0) ? -1 : 1; } + double level() const { return m_level.target(); } + int oversample() const { return m_os; } + double smooth_ms() const { return m_smooth_ms; } + double samplerate() const { return m_sr; } + + detector& heterodyne() { return m_detector; } + const detector& heterodyne() const { return m_detector; } + triode& demodulator() { return m_demod; } + const triode& demodulator() const { return m_demod; } + triode& preamplifier() { return m_preamp; } + const triode& preamplifier() const { return m_preamp; } + touche::key& intensity_key() { return m_key; } + const touche::key& intensity_key() const { return m_key; } + + // -- audio --------------------------------------------------------------------------- + + /// A source: no input. One sample of the instrument, minus its loudspeaker. + double process() { + if (!m_prepared) { + return 0.0; + } + const double drive = m_drive.tick(); + const double level = m_level.tick(); + m_demod.set_drive(std::max(k_min_drive_v, k_nominal_demod_v * drive)); + m_preamp.set_drive(std::max(k_min_drive_v, k_nominal_preamp_v * drive)); + m_power.set_drive(std::max(k_min_drive_v, k_nominal_power_v * drive)); + + // The key's ramp is ticked ONCE per output sample whichever side of the chain it + // is on, so its slew time means the same thing at every oversampling factor. + const double key_gain = m_key.process(1.0); + + double y = 0.0; + for (int j = 0; j < m_os; ++j) { + // The detector runs at the oversampled rate too — its cusp is a nonlinearity + // like any other, and it is the loudest source of aliasing in the chain. + const double raw = m_detector.process(); + const double s = core((m_key_where == key_before) ? raw * key_gain : raw); + y = (m_os == 1) ? s : m_down.tick(s); + } + + // The envelope carries a large DC term; the coupling that removes it in the + // circuit is the stages' own highpass, and this catches whatever is left. + const double d = y - m_dc_x1 + k_dc_r * m_dc_y1; + m_dc_x1 = y; + m_dc_y1 = (std::abs(d) < 1e-15) ? 0.0 : d; + + const double keyed = (m_key_where == key_after) ? m_dc_y1 * key_gain : m_dc_y1; + return keyed * level; + } + + /// Block form: the trivial loop over the scalar path. + void process(double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(); + } + } + + private: + // The grid swing each stage sees at `drive` 1, chosen so the published operating + // points are worked but not slammed — the fuzz.h lesson, applied before it bit. + static constexpr double k_nominal_demod_v = 0.9; + static constexpr double k_nominal_preamp_v = 0.6; + static constexpr double k_nominal_power_v = 0.5; + + /// The nonlinear chain at whatever rate the caller is running. + /// + /// The demodulator's grid signal is the NEGATED envelope. That is grid-leak + /// detection: the grid conducts on positive carrier half-cycles and charges the + /// coupling capacitor negative, so a growing envelope drives the grid toward cutoff. + /// The stage then inverts on the way out, which is why the demodulator as a whole is + /// in phase with the envelope — but the tube's asymmetry has meanwhile been applied + /// to the envelope's *underside*, and that is a different set of harmonics from + /// applying it the other way up. + double core(double x) { + double y = m_preamp.process(m_polarity * m_demod.process(-x)); + if (m_power_on) { + y = m_power.process(y); + } + return y; + } + + void configure() { + const double osr = m_sr * m_os; + m_detector.prepare(osr); + m_demod.prepare(osr); + m_demod.set_tube(tube_6c5); + m_demod.set_operating_point(k_op_demod); + m_preamp.prepare(osr); + m_preamp.set_tube(tube_6c5); + m_preamp.set_operating_point(k_op_preamp); + m_power.prepare(osr); + m_power.set_tube(tube_2a3); + m_power.set_operating_point(k_op_power); + if (m_os > 1) { + // Cut just below the original Nyquist, normalized to the oversampled rate. + // There is no anti-image filter to go with it: this object is a SOURCE, so + // nothing is zero-stuffed on the way up — the detector simply runs fast. + m_down.design(0.45 / static_cast(m_os)); + } + } + + long smooth_samples() const { return static_cast(m_smooth_ms * 0.001 * m_sr); } + + double m_sr{48000.0}; + bool m_prepared{false}; + double m_smooth_ms{k_default_smooth_ms}; + int m_os{k_default_os}; + int m_key_where{key_after}; + bool m_power_on{false}; + double m_polarity{1.0}; + + detector m_detector; + triode m_demod, m_preamp, m_power; + touche::key m_key; + butterworth8 m_down; + double m_dc_x1{0.0}, m_dc_y1{0.0}; + ramp m_drive, m_level; + }; + + } // namespace ondes +} // namespace tap::tools diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index 241619c..c8a925a 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -22,6 +22,7 @@ #include "ladder.h" #include "metal_bank.h" #include "nr.h" +#include "ondes.h" #include "overdrive.h" #include "scrub.h" #include "spectra.h" diff --git a/notebooks/ondes.ipynb b/notebooks/ondes.ipynb new file mode 100644 index 0000000..8f3f3e6 --- /dev/null +++ b/notebooks/ondes.ipynb @@ -0,0 +1,943 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fdeb42d4", + "metadata": {}, + "source": [ + "# tap.ondes~ / tap.triode~ — the heterodyne voice, and the valves after it\n", + "\n", + "The two last pieces of the Ondes Martenot, and the two the family plan got wrong before the\n", + "sources were read.\n", + "\n", + "The plan assumed a `vco.h` descendant with waveform registers. The instrument is nothing of the\n", + "kind. It is **heterodyne**: two oscillators near 80 kHz, one fixed and one moved by the ribbon,\n", + "summed into an amplitude-modulated signal whose envelope is the note. Najnudel, Hélie, Roze &\n", + "Boutin (*\"Simulation of an ondes Martenot circuit\"*, IEEE/ACM TASLP **28**, 2651–2660, 2020)\n", + "model instrument No. 169 as five port-Hamiltonian stages and measure those oscillators at about\n", + "**0.03 % second-harmonic distortion** even coupled to the rest of the circuit. So the character is\n", + "not in the oscillators at all — it is in the demodulator, the two triode stages, the intensity\n", + "key and the diffuseur.\n", + "\n", + "This notebook measures three things, in order of how much they changed the design:\n", + "\n", + "1. **What the demodulator actually makes.** Not a sinusoid — the plan's biggest error.\n", + "2. **Whether the closed-form detector really replaces the 80 kHz simulation.** It does, to 0.10 dB.\n", + "3. **What the valves add**, from a published tube model with parameters fitted to the actual\n", + " valves in No. 169.\n", + "\n", + "Every number comes out of the shipping C++ through `tools/capi`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "59605a4d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:04.682620Z", + "iopub.status.busy": "2026-08-17T12:27:04.682433Z", + "iopub.status.idle": "2026-08-17T12:27:05.083911Z", + "shell.execute_reply": "2026-08-17T12:27:05.082512Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tube parameter sets, from TASLP 28 (2020) Table II — fitted to ondes No. 169's own valves:\n", + " 6F5: mu=98 ex=1.6 kg=2614 kp=905 kvb=1.87 vct=0.5 va=0.33 rgk=1300\n", + " 6C5: mu=20 ex=1.5 kg=2837 kp=138 kvb=89 vct=0.8 va=0.33 rgk=1300\n", + " 2A3: mu=4.3 ex=1.5 kg=1685 kp=43 kvb=102 vct=-1.2 va=0.33 rgk=1300\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import taptools_py as tap\n", + "\n", + "plt.rcParams.update({\n", + " \"figure.dpi\": 96, \"figure.figsize\": (9, 3.4),\n", + " \"axes.grid\": True, \"grid.alpha\": 0.3,\n", + "})\n", + "C = tap.PALETTE\n", + "sr = 48000.0\n", + "\n", + "def goertzel(y, f, fs, frm=None):\n", + " # single-bin magnitude, so a measurement never depends on FFT bin alignment\n", + " if frm is None:\n", + " frm = len(y) // 2\n", + " seg = np.asarray(y[frm:], dtype=float)\n", + " w = 2 * np.pi * f / fs\n", + " c = 2 * np.cos(w)\n", + " s1 = s2 = 0.0\n", + " for v in seg:\n", + " s1, s2 = v + c * s1 - s2, s1\n", + " return np.sqrt(max(0.0, s1 * s1 + s2 * s2 - c * s1 * s2)) * 2 / len(seg)\n", + "\n", + "def harmonics(y, f0, fs, n=5):\n", + " h = np.array([goertzel(y, f0 * k, fs) for k in range(1, n + 1)])\n", + " return h[0], 20 * np.log10(h[1:] / h[0])\n", + "\n", + "print(\"tube parameter sets, from TASLP 28 (2020) Table II — fitted to ondes No. 169's own valves:\")\n", + "for i, name in enumerate(tap.TUBE_NAMES):\n", + " p = tap.tube_params(i)\n", + " print(f\" {name}: \" + \" \".join(f\"{k}={v:g}\" for k, v in p.items()))" + ] + }, + { + "cell_type": "markdown", + "id": "cb9382d4", + "metadata": {}, + "source": [ + "## 1 · The demodulator is the instrument's biggest source of harmonics\n", + "\n", + "The circuit paper writes the oscillator sum as an amplitude-modulated sinewave:\n", + "\n", + "$$\\cos\\Phi + \\cos(\\Phi - \\varphi) = 2\\cos(\\Phi - \\varphi/2)\\,\\cos(\\varphi/2)$$\n", + "\n", + "so the envelope is $2|\\cos(\\varphi/2)|$ — and $|\\cos|$ is emphatically **not** a sinusoid. Its\n", + "Fourier coefficients are $(4/\\pi)/(4n^2-1)$, which puts the second harmonic 14.0 dB below the\n", + "fundamental, the third 21.3 dB down and the fourth 26.4 dB down.\n", + "\n", + "That series exists **before any valve touches the signal**. The family plan said to synthesize the\n", + "difference tone directly as a sinusoid, citing the paper's own simplification — but what the paper\n", + "replaces with a sinewave generator is the *oscillators*, not the demodulator. Synthesizing the\n", + "difference tone would have thrown away the largest single contributor to the instrument's timbre." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d958b3cc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:05.087274Z", + "iopub.status.busy": "2026-08-17T12:27:05.086879Z", + "iopub.status.idle": "2026-08-17T12:27:05.408170Z", + "shell.execute_reply": "2026-08-17T12:27:05.406919Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ideal |cos| series: H2=-14.0 dB H3=-21.3 dB H4=-26.4 dB H5=-30.4 dB H6=-33.6 dB\n" + ] + } + ], + "source": [ + "# The envelope itself, out of the kernel, against the closed form's Fourier series.\n", + "det = tap.Detector(sr, frequency=220.0)\n", + "phase = np.linspace(0, 2, 801)\n", + "env = det.envelope(phase % 1.0)\n", + "\n", + "ideal = np.array([(4 / np.pi) / (4 * n * n - 1) for n in range(1, 7)])\n", + "ideal_db = 20 * np.log10(ideal[1:] / ideal[0])\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.2))\n", + "axes[0].plot(phase, env, color=C[0], lw=1.8)\n", + "axes[0].plot(phase, np.abs(np.cos(np.pi * phase)) * 2, color=C[3], lw=3.0, alpha=0.35,\n", + " label=\"2|cos| — the closed form\")\n", + "axes[0].set_xlabel(\"cycles of the note\"); axes[0].set_ylabel(\"envelope\")\n", + "axes[0].set_title(\"the envelope of two equal oscillators\", fontsize=10)\n", + "axes[0].legend(fontsize=8)\n", + "\n", + "axes[1].bar(np.arange(2, 7), ideal_db, color=C[0])\n", + "for n, v in zip(range(2, 7), ideal_db):\n", + " axes[1].annotate(f\"{v:.1f}\", (n, v), textcoords=\"offset points\", xytext=(0, -14),\n", + " ha=\"center\", fontsize=8, color=\"white\")\n", + "axes[1].set_xlabel(\"harmonic\"); axes[1].set_ylabel(\"dB below the fundamental\")\n", + "axes[1].set_title(\"its Fourier series, before any valve\", fontsize=10)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"ideal |cos| series: \" + \" \".join(f\"H{n}={v:+.1f} dB\" for n, v in zip(range(2, 7), ideal_db)))" + ] + }, + { + "cell_type": "markdown", + "id": "48d55cdb", + "metadata": {}, + "source": [ + "## 2 · The closed form really does replace the 80 kHz simulation\n", + "\n", + "The kernel never generates a carrier. For amplitudes 1 and `depth` the envelope of\n", + "$\\cos\\Phi + d\\cos(\\Phi-\\varphi)$ is exactly $\\sqrt{1 + d^2 + 2d\\cos\\varphi}$, and the published\n", + "detector — a triode grid at near-zero bias conducting only on positive half-cycles, loaded by\n", + "$R_4C_{21} = 200\\,\\mu s$ — is run on *that*.\n", + "\n", + "The claim needs checking against the thing it replaces, so this cell builds the expensive version:\n", + "two oscillators at 80 kHz and 80 kHz − f, summed, half-wave rectified, RC-loaded, at 3 MHz." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8fe65982", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:05.410457Z", + "iopub.status.busy": "2026-08-17T12:27:05.410236Z", + "iopub.status.idle": "2026-08-17T12:27:06.873545Z", + "shell.execute_reply": "2026-08-17T12:27:06.872134Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " f H2 full H2 form H3 full H3 form H4 full H4 form worst dB level\n", + " 110 -14.03 -14.02 -21.46 -21.46 -26.67 -26.67 0.006 1.030\n", + " 440 -14.69 -14.69 -23.23 -23.22 -29.90 -29.92 0.014 1.031\n", + " 1760 -19.32 -19.28 -23.10 -23.00 -28.38 -28.33 0.098 1.032\n", + "\n", + "The harmonic ratios agree to within a tenth of a dB at every pitch. The one systematic\n", + "difference is level: the closed form sits a few percent high, because a follower chasing\n", + "real carrier half-cycles never quite reaches the peak between them.\n" + ] + } + ], + "source": [ + "TAU = 0.2e-3 # R4 * C21 = 1 MOhm * 200 pF, TASLP Table II\n", + "\n", + "def full_heterodyne(f, fs=3.0e6, carrier=80_000.0, cycles=60):\n", + " n = int(fs * cycles / f)\n", + " t = np.arange(n) / fs\n", + " am = np.cos(2 * np.pi * carrier * t) + np.cos(2 * np.pi * (carrier - f) * t)\n", + " a = np.exp(-1.0 / (TAU * fs))\n", + " y = np.zeros(n)\n", + " s = 0.0\n", + " for i in range(n):\n", + " v = am[i]\n", + " s = v if v > s * a else s * a\n", + " y[i] = s\n", + " return y, fs\n", + "\n", + "def closed_form(f, fs=384_000.0, cycles=60):\n", + " d = tap.Detector(fs, frequency=f)\n", + " return d.process(int(fs * cycles / f)), fs\n", + "\n", + "rows = []\n", + "for f in (110.0, 440.0, 1760.0):\n", + " yf, fsf = full_heterodyne(f)\n", + " yc, fsc = closed_form(f)\n", + " a1, adb = harmonics(yf, f, fsf, 4)\n", + " b1, bdb = harmonics(yc, f, fsc, 4)\n", + " rows.append((f, a1, b1, adb, bdb))\n", + "\n", + "print(f\"{'f':>7} {'H2 full':>9} {'H2 form':>9} {'H3 full':>9} {'H3 form':>9} \"\n", + " f\"{'H4 full':>9} {'H4 form':>9} {'worst dB':>9} {'level':>8}\")\n", + "for f, a1, b1, adb, bdb in rows:\n", + " worst = np.max(np.abs(adb - bdb))\n", + " print(f\"{f:7.0f} \" + \" \".join(f\"{adb[k]:9.2f} {bdb[k]:9.2f}\" for k in range(3))\n", + " + f\" {worst:9.3f} {b1/a1:8.3f}\")\n", + "print()\n", + "print(\"The harmonic ratios agree to within a tenth of a dB at every pitch. The one systematic\")\n", + "print(\"difference is level: the closed form sits a few percent high, because a follower chasing\")\n", + "print(\"real carrier half-cycles never quite reaches the peak between them.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d6c74bdf", + "metadata": {}, + "source": [ + "### The detector is pitch-dependent, and that is the instrument, not a defect\n", + "\n", + "The RC cannot follow a fast envelope back down, so as the note rises the notch between cycles gets\n", + "filled in: the tone gets purer *and* quieter with pitch. Both fall out of the same 200 µs." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4c7a2fa5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:06.876389Z", + "iopub.status.busy": "2026-08-17T12:27:06.876067Z", + "iopub.status.idle": "2026-08-17T12:27:07.456377Z", + "shell.execute_reply": "2026-08-17T12:27:07.454948Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H2 at A2: -14.0 dB at A6: -19.3 dB\n", + "level A2 -> A6: -2.0 dB\n" + ] + } + ], + "source": [ + "notes = np.array([55., 110., 220., 440., 880., 1760., 3520.])\n", + "h1, h2, h3 = [], [], []\n", + "for f in notes:\n", + " y, fs = closed_form(f, cycles=60)\n", + " a, db = harmonics(y, f, fs, 3)\n", + " h1.append(a); h2.append(db[0]); h3.append(db[1])\n", + "h1 = np.array(h1)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.2))\n", + "axes[0].semilogx(notes, h2, \"o-\", color=C[0], lw=1.8, label=\"2nd harmonic\")\n", + "axes[0].semilogx(notes, h3, \"o-\", color=C[2], lw=1.8, label=\"3rd harmonic\")\n", + "axes[0].axhline(-14.0, color=C[3], ls=\"--\", lw=1.0)\n", + "axes[0].axhline(-21.3, color=C[3], ls=\"--\", lw=1.0)\n", + "axes[0].set_xlabel(\"note (Hz)\"); axes[0].set_ylabel(\"dB below the fundamental\")\n", + "axes[0].set_title(\"dashed: the ideal |cos| series\", fontsize=10); axes[0].legend(fontsize=8)\n", + "\n", + "axes[1].semilogx(notes, 20 * np.log10(h1 / h1[0]), \"o-\", color=C[0], lw=1.8)\n", + "axes[1].set_xlabel(\"note (Hz)\"); axes[1].set_ylabel(\"level (dB, referenced to A1)\")\n", + "axes[1].set_title(\"and it gets quieter on the way up\", fontsize=10)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"H2 at A2: {h2[1]:.1f} dB at A6: {h2[5]:.1f} dB\")\n", + "print(f\"level A2 -> A6: {20*np.log10(h1[5]/h1[1]):.1f} dB\")" + ] + }, + { + "cell_type": "markdown", + "id": "28e03c36", + "metadata": {}, + "source": [ + "### Oscillator balance is a real knob\n", + "\n", + "Nothing says the two oscillators must have equal amplitude. Unequal, the envelope never closes,\n", + "and the harmonic series thins out. It is the cheapest timbre control the object has, and it is\n", + "physical rather than invented — a mismatch between two real oscillators does exactly this." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "21c25c29", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:07.458566Z", + "iopub.status.busy": "2026-08-17T12:27:07.458370Z", + "iopub.status.idle": "2026-08-17T12:27:07.956764Z", + "shell.execute_reply": "2026-08-17T12:27:07.955573Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.2))\n", + "depths = [0.25, 0.5, 0.75, 1.0]\n", + "ph = np.linspace(0, 2, 801)\n", + "for d, colour in zip(depths, (C[3], C[2], C[4], C[0])):\n", + " det = tap.Detector(sr, frequency=220.0, depth=d)\n", + " axes[0].plot(ph, det.envelope(ph % 1.0), color=colour, lw=1.5, label=f\"depth {d}\")\n", + " y = tap.Detector(384_000.0, frequency=220.0, depth=d).process(int(384_000.0 * 60 / 220.0))\n", + " _, db = harmonics(y, 220.0, 384_000.0, 5)\n", + " axes[1].plot(range(2, 6), db, \"o-\", color=colour, lw=1.5, label=f\"depth {d}\")\n", + "axes[0].set_xlabel(\"cycles\"); axes[0].set_ylabel(\"envelope\"); axes[0].legend(fontsize=8, ncol=2)\n", + "axes[0].set_title(\"the envelope never closes below depth 1\", fontsize=10)\n", + "axes[1].set_xlabel(\"harmonic\"); axes[1].set_ylabel(\"dB below the fundamental\")\n", + "axes[1].set_xticks(range(2, 6)); axes[1].legend(fontsize=8)\n", + "axes[1].set_title(\"so the series thins out\", fontsize=10)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cb942663", + "metadata": {}, + "source": [ + "## 3 · The valves\n", + "\n", + "The circuit paper models the triodes with the **enhanced Norman Koren** law (Koren, *Glass Audio*\n", + "8(5), 1996; grid-current branch from Cohen & Hélie, AES 129, 2010):\n", + "\n", + "$$E_1 = \\frac{v_{pc}}{K_p}\\ln\\!\\left(1 + \\exp\\!\\left(K_p\\left(\\tfrac{1}{\\mu} +\n", + "\\tfrac{v_{gc}+V_{ct}}{\\sqrt{K_{vb}+v_{pc}^2}}\\right)\\right)\\right), \\qquad\n", + "i_{pc} = \\frac{2E_1^{E_x}}{K_g}$$\n", + "\n", + "and gives parameter sets **fitted to the valves actually in ondes No. 169** — 6F5 in the\n", + "oscillators, 6C5 in the demodulator and preamplifier, 2A3 in the power amplifier. Those, and the\n", + "stage supply voltages and cathode resistors, are the whole specification. Nothing in this kernel's\n", + "valve is voiced by ear.\n", + "\n", + "First check: does the fitted 6C5 land on its datasheet's typical operating point? Tung-Sol's sheet\n", + "says 8 mA at 250 V on the plate and −8 V on the grid." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1ef98f03", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:07.958748Z", + "iopub.status.busy": "2026-08-17T12:27:07.958562Z", + "iopub.status.idle": "2026-08-17T12:27:08.243002Z", + "shell.execute_reply": "2026-08-17T12:27:08.241787Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6C5 at Vp = 250 V, Vg = -8 V: 8.85 mA (datasheet typical: 8 mA)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(f\"6C5 at Vp = 250 V, Vg = -8 V: {float(tap.tube_plate_current(tap.TUBE_6C5, 250., -8.))*1000:.2f} mA\"\n", + " f\" (datasheet typical: 8 mA)\")\n", + "\n", + "vp = np.linspace(1, 400, 400)\n", + "fig, axes = plt.subplots(1, 3, figsize=(10, 3.0))\n", + "for ax, ti in zip(axes, (tap.TUBE_6F5, tap.TUBE_6C5, tap.TUBE_2A3)):\n", + " for vg, colour in zip((0, -2, -4, -8, -16), (C[0], C[1], C[2], C[3], C[4])):\n", + " ax.plot(vp, tap.tube_plate_current(ti, vp, float(vg)) * 1000, color=colour, lw=1.3,\n", + " label=f\"Vg = {vg}\")\n", + " ax.set_title(tap.TUBE_NAMES[ti], fontsize=10)\n", + " ax.set_xlabel(\"plate volts\")\n", + "axes[0].set_ylabel(\"plate current (mA)\")\n", + "axes[0].legend(fontsize=7)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3b6eb2bf", + "metadata": {}, + "source": [ + "### A stage is a load line, and the load line is asymmetric\n", + "\n", + "Given the published supply, cathode resistor and plate load, the stage's operating point and its\n", + "transfer curve are just the solution of\n", + "\n", + "$$i_{pc}(v_{pc}, v_{gc}) = \\frac{V_{bias} - V_k - v_{pc}}{R_p}, \\qquad V_k = R_k I_{pc}$$\n", + "\n", + "which is a **memoryless nonlinearity** in the DAFx-07 sense (Yeh, Abel & Smith 2007) — the same\n", + "architecture `fuzz.h` uses, but with the curve coming from a fitted tube model instead of a tanh.\n", + "Tabulating it is not an approximation of the model; it *is* the model.\n", + "\n", + "Two things to notice: the stage **inverts**, and it is **strongly asymmetric**. The asymmetry is\n", + "where a triode's even harmonics come from, and the inversion matters because it decides which side\n", + "of the waveform the asymmetry acts on." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e116e675", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:08.245518Z", + "iopub.status.busy": "2026-08-17T12:27:08.245319Z", + "iopub.status.idle": "2026-08-17T12:27:08.565571Z", + "shell.execute_reply": "2026-08-17T12:27:08.564423Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " stage Vbias Vk Vp0 Ip0 mA gain\n", + " 6C5, demodulator 100 2.70 86.50 2.70 4.86\n", + " 6C5, preamplifier 180 4.95 155.26 4.95 5.56\n", + " 2A3, power amp 230 25.48 153.56 33.97 2.69\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "asymmetry at +-4 units of input: 4.754 one way, 2.191 the other — a ratio of 2.17\n" + ] + } + ], + "source": [ + "stages = [(\"6C5, demodulator\", tap.TUBE_6C5, tap.OP_DEMOD),\n", + " (\"6C5, preamplifier\", tap.TUBE_6C5, tap.OP_PREAMP),\n", + " (\"2A3, power amp\", tap.TUBE_2A3, tap.OP_POWER)]\n", + "\n", + "print(f\"{'stage':>20} {'Vbias':>7} {'Vk':>7} {'Vp0':>8} {'Ip0 mA':>8} {'gain':>7}\")\n", + "tri = {}\n", + "for name, ti, op in stages:\n", + " t = tap.Triode(sr, ti, op, drive=1.0)\n", + " tri[name] = t\n", + " vk, vp0, ip0, g = t.bias\n", + " print(f\"{name:>20} {op[0]:7.0f} {vk:7.2f} {vp0:8.2f} {ip0*1000:8.2f} {g:7.2f}\")\n", + "\n", + "gv = np.linspace(-12, 12, 601)\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.3))\n", + "for (name, _, _), colour in zip(stages, (C[0], C[2], C[4])):\n", + " axes[0].plot(gv, tri[name].plate_swing(gv), color=colour, lw=1.6, label=name)\n", + "axes[0].set_xlabel(\"grid volts around the bias point\"); axes[0].set_ylabel(\"plate swing (V)\")\n", + "axes[0].set_title(\"the load-line solution — note the slope is negative\", fontsize=10)\n", + "axes[0].legend(fontsize=8)\n", + "\n", + "x = np.linspace(-6, 6, 601)\n", + "t = tri[\"6C5, demodulator\"]\n", + "axes[1].plot(x, t.curve(x), color=C[0], lw=1.8, label=\"the stage, normalized\")\n", + "axes[1].plot(x, -x, color=C[3], ls=\"--\", lw=1.0, label=\"a perfectly linear inverter\")\n", + "axes[1].set_xlabel(\"normalized input\"); axes[1].set_ylabel(\"normalized output\")\n", + "axes[1].set_title(\"6C5 demodulator, drive 1 V/unit\", fontsize=10); axes[1].legend(fontsize=8)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "up, down = abs(float(t.curve(4.0))), abs(float(t.curve(-4.0)))\n", + "print(f\"asymmetry at +-4 units of input: {up:.3f} one way, {down:.3f} the other — a ratio of {up/down:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "ae871132", + "metadata": {}, + "source": [ + "## 4 · The whole voice\n", + "\n", + "Detector → demodulator triode → preamplifier triode → intensity key. The `drive` control is the\n", + "harmonics knob (the circuit paper's own plugin exposes demodulator input gain the same way, a knob\n", + "the real instrument does not have), and it is normalized so it changes the distortion rather than\n", + "the level — the gain-staging lesson `fuzz.h` learned the hard way, applied here from the start.\n", + "\n", + "The measurement that matters: **at drive 0 the harmonics are already there**, because the\n", + "demodulator made them." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "89bd1cb7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:08.568318Z", + "iopub.status.busy": "2026-08-17T12:27:08.568135Z", + "iopub.status.idle": "2026-08-17T12:27:09.605442Z", + "shell.execute_reply": "2026-08-17T12:27:09.604118Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " drive 0.0: THD 0.221 H2 -14.1 dB\n", + " drive 0.5: THD 0.228 H2 -13.8 dB\n", + " drive 1.0: THD 0.236 H2 -13.5 dB\n", + " drive 2.0: THD 0.248 H2 -12.9 dB\n", + " drive 4.0: THD 0.274 H2 -11.6 dB\n", + " drive 6.0: THD 0.311 H2 -10.3 dB\n", + " drive 8.0: THD 0.344 H2 -9.3 dB\n" + ] + } + ], + "source": [ + "def voice_run(seconds=1.0, **kw):\n", + " kw.setdefault(\"key\", 1.0)\n", + " v = tap.Ondes(sr, smooth_ms=0, level=1.0, **kw)\n", + " return v.process(int(sr * seconds)), v.frequency\n", + "\n", + "drives = [0.0, 0.5, 1.0, 2.0, 4.0, 6.0, 8.0]\n", + "thd, h1s, h2s = [], [], []\n", + "for d in drives:\n", + " y, f0 = voice_run(ribbon=24.0, drive=d)\n", + " h = np.array([goertzel(y, f0 * k, sr) for k in range(1, 11)])\n", + " thd.append(np.sqrt((h[1:] ** 2).sum()) / h[0])\n", + " h1s.append(h[0]); h2s.append(20 * np.log10(h[1] / h[0]))\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(drives, thd, \"o-\", color=C[0], lw=1.8, label=\"total harmonic content\")\n", + "ax.plot(drives, np.array(h1s), \"o-\", color=C[2], lw=1.5, label=\"fundamental level\")\n", + "ax.axhline(thd[0], color=C[3], ls=\"--\", lw=1.0)\n", + "ax.annotate(\"what the demodulator alone already makes\", (0.15, thd[0]),\n", + " textcoords=\"offset points\", xytext=(6, 8), fontsize=8, color=C[3])\n", + "ax.set_xlabel(\"drive\"); ax.set_ylabel(\"ratio to the fundamental / level\")\n", + "ax.set_title(\"drive adds harmonics without running away in level\")\n", + "ax.legend(fontsize=8)\n", + "plt.show()\n", + "\n", + "for d, t_, h in zip(drives, thd, h2s):\n", + " print(f\" drive {d:4.1f}: THD {t_:.3f} H2 {h:+6.1f} dB\")" + ] + }, + { + "cell_type": "markdown", + "id": "3d6c5946", + "metadata": {}, + "source": [ + "### The two choices the sources do not settle\n", + "\n", + "The circuit paper's five stages **do not include the intensity key**, so where it sits in the chain\n", + "is a modelling decision; and the two triodes are coupled through a transformer whose winding sense\n", + "is not given, so the sign between them is another. Both are audible, so both are switches rather\n", + "than silent guesses." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "028fe5df", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:09.607567Z", + "iopub.status.busy": "2026-08-17T12:27:09.607379Z", + "iopub.status.idle": "2026-08-17T12:27:10.371063Z", + "shell.execute_reply": "2026-08-17T12:27:10.369998Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "coupling polarity (drive 4, key full):\n", + " +1: THD 0.274 fundamental 0.7810\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " -1: THD 0.394 fundamental 0.8366\n", + "\n", + "intensity key placement (drive 6, key 0.62 — a half-press):\n", + " after the valves : THD 0.311 fundamental 0.0149\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " before the valves: THD 0.222 fundamental 0.0176\n", + " Placed before, a half-pressed key drives the valves less hard — pressure becomes dirt,\n", + " which is a very different instrument to play even though neither reading is provably\n", + " the historical one.\n", + "\n", + "the 2A3 power stage (drive 2), which the paper drops for real-time:\n", + " off: THD 0.248 fundamental 0.8274\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " on : THD 0.251 fundamental 0.8245\n", + " Their reason was that its contribution is much less important than the two stages\n", + " before it. Measured here, that is right: it barely moves.\n" + ] + } + ], + "source": [ + "def measure(**kw):\n", + " y, f0 = voice_run(ribbon=24.0, **kw)\n", + " h = np.array([goertzel(y, f0 * k, sr) for k in range(1, 11)])\n", + " return np.sqrt((h[1:] ** 2).sum()) / h[0], h[0]\n", + "\n", + "print(\"coupling polarity (drive 4, key full):\")\n", + "for p in (1, -1):\n", + " t_, h = measure(drive=4.0, polarity=p)\n", + " print(f\" {p:+d}: THD {t_:.3f} fundamental {h:.4f}\")\n", + "\n", + "print()\n", + "print(\"intensity key placement (drive 6, key 0.62 — a half-press):\")\n", + "for name, kp in ((\"after the valves \", 0), (\"before the valves\", 1)):\n", + " t_, h = measure(drive=6.0, key=0.62, key_placement=kp)\n", + " print(f\" {name}: THD {t_:.3f} fundamental {h:.4f}\")\n", + "print(\" Placed before, a half-pressed key drives the valves less hard — pressure becomes dirt,\")\n", + "print(\" which is a very different instrument to play even though neither reading is provably\")\n", + "print(\" the historical one.\")\n", + "\n", + "print()\n", + "print(\"the 2A3 power stage (drive 2), which the paper drops for real-time:\")\n", + "for name, on in ((\"off\", False), (\"on \", True)):\n", + " t_, h = measure(drive=2.0, power_stage=on)\n", + " print(f\" {name}: THD {t_:.3f} fundamental {h:.4f}\")\n", + "print(\" Their reason was that its contribution is much less important than the two stages\")\n", + "print(\" before it. Measured here, that is right: it barely moves.\")" + ] + }, + { + "cell_type": "markdown", + "id": "815c8d25", + "metadata": {}, + "source": [ + "## 5 · Oversampling, and a data point for an open question\n", + "\n", + "`fuzz.h` measured something awkward: alias energy at 4× came out *worse* than at 2×, and the\n", + "untested hypothesis it left behind was **imaging** — zero-stuffing by N leaves N−1 images for one\n", + "filter to suppress, and their residuals intermodulate in the clipper into products that are not\n", + "harmonics of the input.\n", + "\n", + "`tap.ondes~` is a **source**. Nothing is zero-stuffed on the way up; the detector simply runs fast,\n", + "so there are no images at all. If the imaging hypothesis is right, the sequence here should behave —\n", + "and the test is whether it ever *reverses*, which is the thing that needed explaining." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a75f26a2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:10.373561Z", + "iopub.status.busy": "2026-08-17T12:27:10.373286Z", + "iopub.status.idle": "2026-08-17T12:27:15.034542Z", + "shell.execute_reply": "2026-08-17T12:27:15.033275Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 587.3 Hz: -79.3 -91.2 -104.5 -103.8\n", + " 1174.7 Hz: -65.8 -77.2 -90.6 -92.5\n", + " 1760.0 Hz: -57.6 -70.9 -81.1 -82.2\n", + " 2637.0 Hz: -51.1 -61.4 -71.8 -83.8\n", + " 3520.0 Hz: -45.4 -56.8 -67.0 -74.2\n", + "\n", + "About 12 dB per doubling up to 4x; past that, 7-12 dB at the top of the range and nothing\n", + "at the bottom, where the measurement has already bottomed out. Never worse — which is what\n", + "fuzz.h could not manage, and the difference is that this object has no upsampler to leave\n", + "images behind. Evidence for the imaging hypothesis rather than proof of it (the\n", + "nonlinearity differs too), but it is the first evidence either way.\n", + "\n", + "4x is the default: it is where the cost stops buying uniformly. 8x is there for anyone\n", + "playing the top octave hard.\n" + ] + } + ], + "source": [ + "def alias_floor(f0, drive, os):\n", + " v = tap.Ondes(sr, smooth_ms=0, oversample=os, frequency=f0, drive=drive, key=1.0, level=1.0)\n", + " v.process(40000) # settle: the filters have long tails at high factors\n", + " y = v.process(1 << 17)\n", + " mag = np.abs(np.fft.rfft(y * np.hanning(len(y))))\n", + " fr = np.fft.rfftfreq(len(y), 1 / sr)\n", + " h1 = mag[np.abs(fr - f0) < 30].max()\n", + " keep = (fr > 40) & (fr < 0.45 * sr)\n", + " for q in range(1, int(0.5 * sr / f0) + 1):\n", + " keep &= np.abs(fr - q * f0) > 50\n", + " return 20 * np.log10(mag[keep].max() / h1)\n", + "\n", + "probes = [587.3, 1174.7, 1760.0, 2637.0, 3520.0]\n", + "grid = np.array([[alias_floor(f, 4.0, os) for os in (1, 2, 4, 8)] for f in probes])\n", + "\n", + "fig, ax = plt.subplots()\n", + "for row, f, colour in zip(grid, probes, (C[0], C[2], C[4])):\n", + " ax.plot([1, 2, 4, 8], row, \"o-\", color=colour, lw=1.8, label=f\"{f:.0f} Hz\")\n", + "ax.set_xscale(\"log\", base=2); ax.set_xticks([1, 2, 4, 8], [\"1x\", \"2x\", \"4x\", \"8x\"])\n", + "ax.set_xlabel(\"oversampling\"); ax.set_ylabel(\"worst non-harmonic energy (dB rel. fundamental)\")\n", + "ax.set_title(\"every doubling helps or holds — it never reverses\")\n", + "ax.legend(fontsize=8)\n", + "plt.show()\n", + "\n", + "for f, row in zip(probes, grid):\n", + " print(f\" {f:7.1f} Hz: \" + \" \".join(f\"{v:+6.1f}\" for v in row))\n", + "print()\n", + "print(\"About 12 dB per doubling up to 4x; past that, 7-12 dB at the top of the range and nothing\")\n", + "print(\"at the bottom, where the measurement has already bottomed out. Never worse — which is what\")\n", + "print(\"fuzz.h could not manage, and the difference is that this object has no upsampler to leave\")\n", + "print(\"images behind. Evidence for the imaging hypothesis rather than proof of it (the\")\n", + "print(\"nonlinearity differs too), but it is the first evidence either way.\")\n", + "print()\n", + "print(\"4x is the default: it is where the cost stops buying uniformly. 8x is there for anyone\")\n", + "print(\"playing the top octave hard.\")" + ] + }, + { + "cell_type": "markdown", + "id": "1bb6f320", + "metadata": {}, + "source": [ + "## 6 · Played\n", + "\n", + "The ribbon is **linear in semitones**: the circuit paper's Eq. 7 gives the variable oscillator's\n", + "capacitance against ribbon displacement, and the frequency that falls out is\n", + "$f = A_1 \\cdot 2^{d/12d_0}$ with $A_1 = 55$ Hz. So a hand moving at constant speed produces a\n", + "constant-rate glissando, which is why an ondes glide sounds the way it does and why `ribbon` takes\n", + "semitones rather than Hz." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "de043a54", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-17T12:27:15.036833Z", + "iopub.status.busy": "2026-08-17T12:27:15.036625Z", + "iopub.status.idle": "2026-08-17T12:27:15.976877Z", + "shell.execute_reply": "2026-08-17T12:27:15.975677Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "peak 0.586, rms 0.2127\n" + ] + } + ], + "source": [ + "n = int(sr * 4.0)\n", + "t = np.arange(n) / sr\n", + "# a hand: up a fifth, back down a third, with the key swelling under it\n", + "ribbon = 19.0 + 7.0 * (0.5 - 0.5 * np.cos(2 * np.pi * 0.25 * t)) - 4.0 * (t > 2.5)\n", + "key = 0.45 + 0.55 * np.clip(np.sin(np.pi * t / 4.0), 0, 1)\n", + "\n", + "v = tap.Ondes(sr, smooth_ms=2.0, drive=2.5, level=0.5)\n", + "y = v.process(ribbon=ribbon, key=key)\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(9, 4.4), sharex=True,\n", + " gridspec_kw={\"height_ratios\": [1, 2]})\n", + "axes[0].plot(t, ribbon, color=C[0], lw=1.5, label=\"ribbon (semitones above A1)\")\n", + "axes[0].plot(t, key * 10 + 15, color=C[2], lw=1.5, label=\"key (scaled, for shape)\")\n", + "axes[0].legend(fontsize=8, ncol=2); axes[0].set_ylabel(\"gesture\")\n", + "dither = 1e-9 * np.sin(2 * np.pi * 7000.0 * t) # so the silent lead-in is not log(0)\n", + "axes[1].specgram(y + dither, NFFT=2048, Fs=sr, noverlap=1536, cmap=\"magma\", vmin=-120, vmax=-20)\n", + "axes[1].set_ylim(0, 4000); axes[1].set_xlabel(\"time (s)\"); axes[1].set_ylabel(\"Hz\")\n", + "axes[1].grid(False)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"peak {np.abs(y).max():.3f}, rms {np.sqrt((y**2).mean()):.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "14bef5d2", + "metadata": {}, + "source": [ + "## What this is, and what it is not\n", + "\n", + "**Not a circuit solve.** The paper's full port-Hamiltonian model runs at 768 kHz and their plugin\n", + "costs 85 % of a laptop core; it is passive by construction. This kernel is that model's *own*\n", + "published reductions plus its published component values: the oscillators replaced by their\n", + "closed-form envelope (exactly, as §2 shows), the stages reduced to static load-line curves with\n", + "first-order conditioning and equalization filters standing in for their reactive coupling.\n", + "\n", + "**No waveform registers.** The real instrument has switchable timbres whose filter shapes are not\n", + "in any source obtained here. Leipp (*Bulletin du GAM* n°60, 1972) and Laurendeau's monograph are\n", + "where to look next. Inventing them would be the one thing this file is careful not to do.\n", + "\n", + "**No diffuseur.** That is `tap.palme~` and `tap.metallique~` — patch one after this object, which\n", + "is how the instrument works anyway. `radiohead_render`'s `ondes_diffuseurs` scenario is the whole\n", + "thing wired together.\n", + "\n", + "**One instrument's valves.** The parameter sets are a fit to No. 169's tubes, and tube-to-tube\n", + "spread in 1930s valves is wide." + ] + } + ], + "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 811288e..5c184bb 100644 --- a/notebooks/taptools_py.py +++ b/notebooks/taptools_py.py @@ -306,6 +306,60 @@ def load() -> ctypes.CDLL: "taptools_tapecho_clear": ([vp], ctypes.c_int), "taptools_tapecho_process": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_tube_plate_current": ([ctypes.c_int, ctypes.c_double, ctypes.c_double], + ctypes.c_double), + "taptools_tube_grid_current": ([ctypes.c_int, ctypes.c_double], ctypes.c_double), + "taptools_tube_params": ([ctypes.c_int, f64p], ctypes.c_int), + + "taptools_triode_create": ([], vp), + "taptools_triode_destroy": ([vp], None), + "taptools_triode_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_triode_set_tube": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_triode_set_operating_point": ([vp, ctypes.c_double, ctypes.c_double, + ctypes.c_double], ctypes.c_int), + "taptools_triode_set_drive": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_triode_set_corners": ([vp, ctypes.c_double, ctypes.c_double], ctypes.c_int), + "taptools_triode_clear": ([vp], ctypes.c_int), + "taptools_triode_process": ([vp, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_triode_curve_at": ([vp, ctypes.c_double], ctypes.c_double), + "taptools_triode_plate_swing_at": ([vp, ctypes.c_double], ctypes.c_double), + "taptools_triode_bias_v": ([vp], ctypes.c_double), + "taptools_triode_quiescent_plate_v": ([vp], ctypes.c_double), + "taptools_triode_quiescent_current_a": ([vp], ctypes.c_double), + "taptools_triode_gain": ([vp], ctypes.c_double), + + "taptools_detector_create": ([], vp), + "taptools_detector_destroy": ([vp], None), + "taptools_detector_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_detector_set_frequency": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_detector_set_ribbon": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_detector_set_depth": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_detector_set_detect_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_detector_clear": ([vp], ctypes.c_int), + "taptools_detector_process": ([vp, f64p, ctypes.c_int], ctypes.c_int), + "taptools_detector_envelope_at": ([vp, ctypes.c_double], ctypes.c_double), + + "taptools_ondes_create": ([], vp), + "taptools_ondes_destroy": ([vp], None), + "taptools_ondes_prepare": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_ribbon": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_frequency": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_depth": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_detect_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_drive": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_key": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_key_mm": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_key_placement": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_ondes_set_power_stage": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_ondes_set_polarity": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_ondes_set_level": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_set_oversample": ([vp, ctypes.c_int], ctypes.c_int), + "taptools_ondes_set_smooth_ms": ([vp, ctypes.c_double], ctypes.c_int), + "taptools_ondes_clear": ([vp], ctypes.c_int), + "taptools_ondes_process": ([vp, f64p, ctypes.c_int], ctypes.c_int), + "taptools_ondes_process_mod": ([vp, f64p, f64p, f64p, ctypes.c_int], ctypes.c_int), + "taptools_ondes_frequency": ([vp], ctypes.c_double), + "taptools_plate_create": ([], vp), "taptools_plate_destroy": ([vp], None), "taptools_plate_prepare": ([vp, ctypes.c_double], ctypes.c_int), @@ -1465,6 +1519,243 @@ def __del__(self): self._h = None +# The circuit paper's fitted tube parameter sets, addressed by index. +TUBE_6F5, TUBE_6C5, TUBE_2A3 = 0, 1, 2 +TUBE_NAMES = ("6F5", "6C5", "2A3") + +# Published stage operating points (vbias, rk, rp) — TASLP 28 (2020), Table II. +OP_DEMOD = (100.0, 1000.0, 4000.0) +OP_PREAMP = (180.0, 1000.0, 4000.0) +OP_POWER = (230.0, 750.0, 1500.0) + + +def tube_plate_current(tube, vpc, vgc): + """The enhanced Norman Koren plate current, in amps — the shipping C++, not a copy of + the equations. `tube` is TUBE_6F5 / TUBE_6C5 / TUBE_2A3.""" + f = np.vectorize(lambda p, g: _LIB.taptools_tube_plate_current(int(tube), float(p), float(g))) + return f(vpc, vgc) + + +def tube_grid_current(tube, vgc): + """The grid-conduction branch, in amps (TASLP Eq. 9).""" + f = np.vectorize(lambda g: _LIB.taptools_tube_grid_current(int(tube), float(g))) + return f(vgc) + + +def tube_params(tube): + """The fitted parameters as a dict: mu, ex, kg, kp, kvb, vct, va, rgk.""" + buf = np.zeros(8) + n = _LIB.taptools_tube_params(int(tube), _p64(buf)) + if n != 8: + raise ValueError(f"no such tube: {tube}") + return dict(zip(("mu", "ex", "kg", "kp", "kvb", "vct", "va", "rgk"), buf)) + + +class Triode: + """tap.triode~'s kernel (tap::tools::ondes::triode): one common-cathode triode + stage, solved on its load line from the enhanced Norman Koren tube model at a + published operating point. + + The tube parameters are fitted to the actual valves in ondes Martenot No. 169 + (Najnudel, Hélie, Roze & Boutin, IEEE/ACM TASLP 28, 2020, Table II) — 6F5 in the + oscillators, 6C5 in the demodulator and preamplifier, 2A3 in the power amplifier. + Nothing here is voiced by ear. + + The static load-line solution is a memoryless nonlinearity in the DAFx-07 sense, + so tabulating it is not an approximation of the model, it IS the model. Output is + normalized by the stage's own small-signal gain, so `drive` changes the distortion + without changing the level — and the stage inverts, because a real one does.""" + + def __init__(self, sr: float = 48000.0, tube=TUBE_6C5, operating_point=OP_DEMOD, **params): + self._h = _LIB.taptools_triode_create() + _check(_LIB.taptools_triode_prepare(self._h, float(sr)), "prepare") + _check(_LIB.taptools_triode_set_tube(self._h, int(tube)), "tube") + self.set_operating_point(*operating_point) + self.set(**params) + + def set_operating_point(self, vbias, rk, rp) -> "Triode": + """Supply volts, cathode resistor, plate load. A mode, not a fader: it rebuilds + the curve table.""" + _check(_LIB.taptools_triode_set_operating_point(self._h, float(vbias), float(rk), + float(rp)), "operating_point") + return self + + def set(self, *, tube=None, drive=None, corners=None) -> "Triode": + if tube is not None: + _check(_LIB.taptools_triode_set_tube(self._h, int(tube)), "tube") + if drive is not None: + _check(_LIB.taptools_triode_set_drive(self._h, float(drive)), "drive") + if corners is not None: + _check(_LIB.taptools_triode_set_corners(self._h, float(corners[0]), + float(corners[1])), "corners") + return self + + @property + def bias(self): + """The quiescent point: (cathode volts, plate volts, plate amps, gain magnitude).""" + return (_LIB.taptools_triode_bias_v(self._h), + _LIB.taptools_triode_quiescent_plate_v(self._h), + _LIB.taptools_triode_quiescent_current_a(self._h), + _LIB.taptools_triode_gain(self._h)) + + def curve(self, x): + """The static transfer, normalized in and out. No state touched.""" + f = np.vectorize(lambda v: _LIB.taptools_triode_curve_at(self._h, float(v))) + return f(x) + + def plate_swing(self, grid_volts): + """The same curve in the tube's units: grid volts in, plate volts of swing out.""" + f = np.vectorize(lambda v: _LIB.taptools_triode_plate_swing_at(self._h, float(v))) + return f(grid_volts) + + def process(self, x) -> np.ndarray: + x = _f64(x) + out = np.zeros_like(x) + _check(_LIB.taptools_triode_process(self._h, _p64(x), _p64(out), x.size), "process") + return out + + def clear(self) -> None: + _check(_LIB.taptools_triode_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_triode_destroy(h) + self._h = None + + +class Detector: + """The Ondes Martenot's heterodyne pair and its envelope detector + (tap::tools::ondes::detector), with no carrier simulated at all. + + The envelope of `cos(P) + depth*cos(P - p)` is exactly + `sqrt(1 + depth^2 + 2 depth cos(p))`, so the 80 kHz carrier drops out of the + arithmetic. At depth 1 that is `2|cos(p/2)|`, whose harmonics sit at -14.0 / -21.3 / + -26.4 dB **before anything nonlinear happens** — which is the instrument's single + largest source of harmonics, and the thing you lose if you synthesize the difference + tone as a sinusoid. + + The detector is the published one: a triode grid at near-zero bias conducts on + positive half-cycles and charges instantly, and R4*C21 discharges it with a 200 us + time constant. `set_ribbon` takes semitones above A1 because the circuit paper's + Eq. 7 makes the ribbon linear in semitones.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_detector_create() + _check(_LIB.taptools_detector_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, frequency=None, ribbon=None, depth=None, detect_ms=None) -> "Detector": + for value, fn, name in ( + (frequency, _LIB.taptools_detector_set_frequency, "frequency"), + (ribbon, _LIB.taptools_detector_set_ribbon, "ribbon"), + (depth, _LIB.taptools_detector_set_depth, "depth"), + (detect_ms, _LIB.taptools_detector_set_detect_ms, "detect_ms"), + ): + if value is not None: + _check(fn(self._h, float(value)), name) + return self + + def envelope(self, phase): + """The ideal envelope at a phase in [0, 1), with no detector on it.""" + f = np.vectorize(lambda p: _LIB.taptools_detector_envelope_at(self._h, float(p))) + return f(phase) + + def process(self, n: int) -> np.ndarray: + out = np.zeros(int(n)) + _check(_LIB.taptools_detector_process(self._h, _p64(out), out.size), "process") + return out + + def clear(self) -> None: + _check(_LIB.taptools_detector_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_detector_destroy(h) + self._h = None + + +class Ondes: + """tap.ondes~'s kernel (tap::tools::ondes::voice): the Ondes Martenot minus its + loudspeaker — the heterodyne detector into the demodulator triode into the + preamplifier triode into the intensity key. + + A source, not an effect: `process(n)` renders n samples. Patch a Palme or a + Metallique after it for the rest of the instrument. + + `ribbon` is semitones above A1 (55 Hz), because the published ribbon law is linear + in semitones. `drive` is the harmonics control — the circuit paper's own plugin + exposes demodulator input gain the same way, a knob the real instrument does not + have. `power_stage` runs the 2A3 and is off by default, following the paper. + `polarity` and `key_placement` are choices the sources do not settle, offered as + switches rather than guessed at silently.""" + + def __init__(self, sr: float = 48000.0, **params): + self._h = _LIB.taptools_ondes_create() + _check(_LIB.taptools_ondes_prepare(self._h, float(sr)), "prepare") + self.set(**params) + + def set(self, *, ribbon=None, frequency=None, depth=None, detect_ms=None, drive=None, + key=None, key_mm=None, key_placement=None, power_stage=None, polarity=None, + level=None, oversample=None, smooth_ms=None) -> "Ondes": + # configuration first, so ramped targets in the same call honor the new slew + if oversample is not None: + _check(_LIB.taptools_ondes_set_oversample(self._h, int(oversample)), "oversample") + if key_placement is not None: + _check(_LIB.taptools_ondes_set_key_placement(self._h, int(key_placement)), "key_placement") + if power_stage is not None: + _check(_LIB.taptools_ondes_set_power_stage(self._h, 1 if power_stage else 0), "power_stage") + if polarity is not None: + _check(_LIB.taptools_ondes_set_polarity(self._h, int(polarity)), "polarity") + if smooth_ms is not None: + _check(_LIB.taptools_ondes_set_smooth_ms(self._h, float(smooth_ms)), "smooth_ms") + for value, fn, name in ( + (ribbon, _LIB.taptools_ondes_set_ribbon, "ribbon"), + (frequency, _LIB.taptools_ondes_set_frequency, "frequency"), + (depth, _LIB.taptools_ondes_set_depth, "depth"), + (detect_ms, _LIB.taptools_ondes_set_detect_ms, "detect_ms"), + (drive, _LIB.taptools_ondes_set_drive, "drive"), + (key, _LIB.taptools_ondes_set_key, "key"), + (key_mm, _LIB.taptools_ondes_set_key_mm, "key_mm"), + (level, _LIB.taptools_ondes_set_level, "level"), + ): + if value is not None: + _check(fn(self._h, float(value)), name) + return self + + @property + def frequency(self) -> float: + return float(_LIB.taptools_ondes_frequency(self._h)) + + def process(self, n=None, ribbon=None, key=None) -> np.ndarray: + """Render samples. Pass arrays for `ribbon` (semitones) and `key` (0..1) to play + the performance surface sample by sample; both must be given together.""" + if ribbon is None and key is None: + out = np.zeros(int(n)) + _check(_LIB.taptools_ondes_process(self._h, _p64(out), out.size), "process") + return out + rib = _f64(np.atleast_1d(ribbon if ribbon is not None else 24.0)) + k = _f64(np.atleast_1d(key if key is not None else 1.0)) + size = int(n) if n is not None else max(rib.size, k.size) + rib = _f64(np.broadcast_to(rib, (size,)) if rib.size != size else rib) + k = _f64(np.broadcast_to(k, (size,)) if k.size != size else k) + out = np.zeros(size) + _check(_LIB.taptools_ondes_process_mod(self._h, _p64(rib), _p64(k), _p64(out), size), + "process_mod") + return out + + def clear(self) -> None: + """Silence the detector and every filter. Parameters are kept.""" + _check(_LIB.taptools_ondes_clear(self._h), "clear") + + def __del__(self): + h = getattr(self, "_h", None) + if h: + _LIB.taptools_ondes_destroy(h) + self._h = None + + class Plate: """The metallique's body on its own (tap::tools::diffuseur::plate) — eight driven modes at the free circular plate's transverse ratios, each split diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 4988fc0..87b89e8 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -24,6 +24,7 @@ add_executable(taptools_kernel_tests grm_comb_test.cpp harmonizer_test.cpp nr_test.cpp + ondes_test.cpp overdrive_test.cpp scrub_test.cpp spectra_test.cpp diff --git a/tests/ondes_test.cpp b/tests/ondes_test.cpp new file mode 100644 index 0000000..c2060b7 --- /dev/null +++ b/tests/ondes_test.cpp @@ -0,0 +1,493 @@ +/// @file +/// @brief Catch2 scenarios pinning the Ondes Martenot voice kernels (ondes.h). +/// @details This file's contract is mostly *reproduction*, like tests/touche_test.cpp and +/// unlike most of the library: the tube model, its fitted parameters and the stage +/// operating points are all published, so the load-bearing scenarios check that the +/// published numbers come back out — the tube against its datasheet operating point, +/// the demodulator's harmonic series against its closed form, and the closed-form +/// detector against the full heterodyne simulation it replaces. +/// +/// The last of those is the one to keep: the whole reason this kernel is affordable +/// is that the envelope of two summed oscillators has a closed form, so the 80 kHz +/// carrier never has to exist. If that equivalence ever stops holding, the object is +/// no longer a reduction of the published model, it is just a synthesizer. +/// @author Timothy Place +// SPDX-License-Identifier: MIT +// Copyright 2026 Timothy Place. + +#include +#include +#include +#include + +#include +#include + +namespace { + + constexpr double k_sr = 48000.0; + constexpr double k_pi = 3.14159265358979323846; + + namespace O = tap::tools::ondes; + + /// Magnitude at `hz` over `x[from..)` — the house Goertzel probe. + double bin(const std::vector& x, double hz, size_t from, double sr = k_sr) { + const double w = 2.0 * k_pi * hz / sr; + const double c = 2.0 * std::cos(w); + double s1 = 0.0, s2 = 0.0; + for (size_t i = from; i < x.size(); ++i) { + const double s = x[i] + c * s1 - s2; + s2 = s1; + s1 = s; + } + return std::sqrt(std::max(0.0, s1 * s1 + s2 * s2 - c * s1 * s2)) * 2.0 / static_cast(x.size() - from); + } + + /// The full published demodulator, simulated the expensive way: two oscillators at F and + /// F - f, summed, half-wave rectified by the near-zero-bias grid, loaded by R4*C21. This is + /// the thing the kernel's closed form is claimed to replace, so the test builds it rather + /// than trusting the claim. + std::vector full_heterodyne(double f, double sr, double carrier_hz, double tau_s, int cycles) { + const size_t n = static_cast(sr * static_cast(cycles) / f); + std::vector y(n); + const double decay = std::exp(-1.0 / (tau_s * sr)); + double env = 0.0; + for (size_t i = 0; i < n; ++i) { + const double t = static_cast(i) / sr; + const double am = std::cos(2.0 * k_pi * carrier_hz * t) + std::cos(2.0 * k_pi * (carrier_hz - f) * t); + env = std::max(am, env * decay); + y[i] = env; + } + return y; + } + + std::vector run_detector(double f, double sr, int cycles) { + O::detector d; + d.prepare(sr); + d.set_frequency(f); + const size_t n = static_cast(sr * static_cast(cycles) / f); + std::vector y(n); + for (size_t i = 0; i < n; ++i) { + y[i] = d.process(); + } + return y; + } + + std::vector run_voice(double semitones, double drive, int os, double seconds = 1.0) { + O::voice v; + v.prepare(k_sr); + v.set_oversample(os); + v.set_smooth_ms(0.0); + v.set_ribbon(semitones); + v.set_drive(drive); + v.set_key(1.0); + v.set_level(1.0); + const size_t n = static_cast(k_sr * seconds); + std::vector y(n); + for (size_t i = 0; i < n; ++i) { + y[i] = v.process(); + } + return y; + } + + /// Total harmonic content relative to the fundamental, harmonics 2..10. + double thd(const std::vector& y, double f0) { + const size_t from = y.size() / 2; + const double h1 = bin(y, f0, from); + double s = 0.0; + for (int k = 2; k <= 10; ++k) { + const double h = bin(y, f0 * k, from); + s += h * h; + } + return std::sqrt(s) / h1; + } + +} // namespace + +// The tube model against a datasheet operating point. Tung-Sol's 6C5 sheet gives 8 mA of plate +// current at 250 V on the plate and -8 V on the grid; the parameter set the circuit paper fitted +// to that sheet has to land near it, or the fit was mis-transcribed. +SCENARIO("the published tube parameters reproduce their datasheet operating point") { + const double ip = O::plate_current(O::k_6c5, 250.0, -8.0); + INFO("6C5 at Vp = 250 V, Vg = -8 V: " << ip * 1000.0 << " mA (datasheet typical is 8 mA)"); + CHECK(ip * 1000.0 > 7.0); + CHECK(ip * 1000.0 < 10.0); + + // And the model's basic physics: current rises with plate voltage and with grid voltage, and + // there is none at all below the plate. + CHECK(O::plate_current(O::k_6c5, 250.0, -4.0) > O::plate_current(O::k_6c5, 250.0, -8.0)); + CHECK(O::plate_current(O::k_6c5, 300.0, -8.0) > O::plate_current(O::k_6c5, 250.0, -8.0)); + CHECK(O::plate_current(O::k_6c5, 0.0, 0.0) == 0.0); + + // The grid-current branch: nothing below the threshold, ohmic above it (TASLP Eq. 9). + CHECK(O::grid_current(O::k_6c5, 0.0) == 0.0); + CHECK(O::grid_current(O::k_6c5, O::k_6c5.va - 0.01) == 0.0); + CHECK(std::abs(O::grid_current(O::k_6c5, O::k_6c5.va + 1.3) - 1.3 / O::k_6c5.rgk) < 1e-15); +} + +SCENARIO("the published operating points bias their tubes into class A") { + struct expect { + int tube; + O::operating_point op; + const char* name; + }; + const expect cases[] = {{O::tube_6c5, O::k_op_demod, "6C5 demodulator"}, + {O::tube_6c5, O::k_op_preamp, "6C5 preamplifier"}, + {O::tube_2a3, O::k_op_power, "2A3 power amplifier"}}; + + for (const expect& e : cases) { + O::triode t; + t.prepare(k_sr); + t.set_tube(e.tube); + t.set_operating_point(e.op); + INFO(e.name << ": Vk = " << t.bias_v() << " V, Vp = " << t.quiescent_plate_v() + << " V, Ip = " << t.quiescent_current_a() * 1000.0 << " mA, gain " << t.small_signal_gain()); + CHECK(t.bias_v() > 0.5); // the cathode really is biased + CHECK(t.quiescent_plate_v() > 0.25 * e.op.vbias); // and not slammed against either rail + CHECK(t.quiescent_plate_v() < 0.95 * e.op.vbias); + CHECK(t.quiescent_current_a() > 1e-4); + CHECK(t.small_signal_gain() > 2.0); // a working stage, not a cut-off one + CHECK(t.small_signal_gain() < e.op.vbias); + } +} + +// The reason the stage is worth solving from the tube model rather than reaching for a tanh: a +// triode is strongly asymmetric, and the asymmetry is where its even harmonics come from. +SCENARIO("a triode stage is asymmetric, and inverts") { + O::triode t; + t.prepare(k_sr); + t.set_tube(O::tube_6c5); + t.set_operating_point(O::k_op_demod); + t.set_drive(1.0); + + // Inverting: a common-cathode stage is, and the sign is load-bearing here because the tube's + // asymmetry acts on whichever side of the waveform actually reaches its grid. + CHECK(t.curve_at(1.0) < 0.0); + CHECK(t.curve_at(-1.0) > 0.0); + + // Asymmetric: equal grid swings either way do NOT give equal plate swings. + const double up = std::abs(t.curve_at(4.0)); + const double down = std::abs(t.curve_at(-4.0)); + INFO("plate swing at +-4 V of grid: " << up << " vs " << down); + CHECK(up / down > 1.5); + + // Unity small-signal gain after normalization, so `drive` changes the distortion and not the + // level — the gain-staging lesson fuzz.h learned the hard way. + CHECK(std::abs(t.curve_at(0.001) / -0.001 - 1.0) < 0.02); + CHECK(t.curve_at(0.0) == 0.0); +} + +SCENARIO("the drive knob changes the distortion and not the level") { + O::triode t; + t.prepare(k_sr); + t.set_tube(O::tube_6c5); + t.set_operating_point(O::k_op_demod); + + double last_slope = 0.0; + for (double d : {0.1, 1.0, 4.0}) { + t.set_drive(d); + const double slope = t.curve_at(0.0005) / -0.0005; + INFO("drive " << d << ": small-signal slope " << slope); + CHECK(std::abs(slope - 1.0) < 0.02); // the level is normalized out at every setting + last_slope = slope; + } + CHECK(last_slope > 0.0); +} + +// The load-bearing scenario. The whole affordability of this kernel rests on the envelope of the +// published oscillator sum having a closed form, so the carrier never needs to exist. If this +// equivalence stops holding, the object stops being a reduction of the published model. +SCENARIO("the closed-form detector reproduces the full heterodyne simulation") { + for (double f : {110.0, 440.0, 1760.0}) { + // The expensive version, at a rate that resolves an 80 kHz carrier properly. + const double full_sr = 3.0e6; + const std::vector full = full_heterodyne(f, full_sr, 80000.0, O::k_detect_ms * 0.001, 60); + const std::vector cheap = run_detector(f, 384000.0, 60); + + const size_t ff = full.size() / 2; + const size_t cf = cheap.size() / 2; + const double f1 = bin(full, f, ff, full_sr); + const double c1 = bin(cheap, f, cf, 384000.0); + + for (int k = 2; k <= 4; ++k) { + const double a = 20.0 * std::log10(bin(full, f * k, ff, full_sr) / f1); + const double b = 20.0 * std::log10(bin(cheap, f * k, cf, 384000.0) / c1); + INFO(f << " Hz, harmonic " << k << ": full " << a << " dB, closed form " << b << " dB"); + CHECK(std::abs(a - b) < 0.15); + } + // The one systematic difference: the closed form is a few percent louder, because a + // follower chasing real carrier half-cycles never quite reaches the peak between them. + INFO(f << " Hz: level ratio " << c1 / f1); + CHECK(c1 / f1 > 1.0); + CHECK(c1 / f1 < 1.05); + } +} + +// And what that envelope is: not a sinusoid. This is the correction the family plan needed — the +// demodulator generates a substantial harmonic series before any tube touches the signal. +SCENARIO("the demodulated envelope carries the published harmonic series before any tube") { + const std::vector y = run_detector(440.0, 384000.0, 60); + const size_t from = y.size() / 2; + const double h1 = bin(y, 440.0, from, 384000.0); + + // |cos| has Fourier coefficients (4/pi)/(4n^2 - 1), so relative to the fundamental the second + // harmonic sits at 3/15 and the third at 3/35 — -14.0 dB and -21.3 dB. The RC detector moves + // them a little (it cannot follow the envelope down), which is why the bound is generous. + const double h2 = 20.0 * std::log10(bin(y, 880.0, from, 384000.0) / h1); + const double h3 = 20.0 * std::log10(bin(y, 1320.0, from, 384000.0) / h1); + INFO("H2 " << h2 << " dB (ideal -14.0), H3 " << h3 << " dB (ideal -21.3)"); + CHECK(h2 > -17.0); + CHECK(h2 < -12.0); + CHECK(h3 > -25.0); + CHECK(h3 < -19.0); +} + +SCENARIO("the detector loses harmonics and level as it goes up, because the RC cannot keep up") { + std::vector h2, level; + for (double f : {110.0, 1760.0}) { + const std::vector y = run_detector(f, 384000.0, 60); + const size_t from = y.size() / 2; + const double a = bin(y, f, from, 384000.0); + level.push_back(a); + h2.push_back(20.0 * std::log10(bin(y, 2.0 * f, from, 384000.0) / a)); + } + INFO("second harmonic: " << h2[0] << " dB at A2, " << h2[1] << " dB at A6"); + CHECK(h2[1] < h2[0] - 3.0); + INFO("level: " << 20.0 * std::log10(level[1] / level[0]) << " dB across five octaves"); + CHECK(level[1] < level[0]); + CHECK(20.0 * std::log10(level[1] / level[0]) > -6.0); // a tilt, not a collapse +} + +SCENARIO("oscillator balance is the cheapest timbre control the object has") { + std::vector h2; + for (double depth : {0.25, 0.5, 1.0}) { + O::detector d; + d.prepare(384000.0); + d.set_frequency(220.0); + d.set_depth(depth); + std::vector y(static_cast(384000.0 * 60.0 / 220.0)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = d.process(); + } + const size_t from = y.size() / 2; + const double h1 = bin(y, 220.0, from, 384000.0); + h2.push_back(20.0 * std::log10(bin(y, 440.0, from, 384000.0) / h1)); + INFO("depth " << depth << ": H2 " << h2.back() << " dB"); + } + REQUIRE(h2.size() == 3); + CHECK(h2[0] < h2[1]); // unequal oscillators never close the envelope, so the series thins + CHECK(h2[1] < h2[2]); + + // At depth 0 the envelope is a constant: two oscillators that are not beating make no note. + O::detector flat; + flat.prepare(k_sr); + flat.set_depth(0.0); + bool constant = true; + for (int i = 0; i < 4800; ++i) { + constant = constant && (std::abs(flat.process() - 1.0) < 1e-12); + } + REQUIRE(constant); +} + +SCENARIO("the ribbon is linear in semitones, which is the published law") { + O::detector d; + d.prepare(k_sr); + for (double st : {0.0, 12.0, 24.0, 36.0, 60.0}) { + d.set_ribbon(st); + INFO(st << " semitones -> " << d.frequency() << " Hz"); + CHECK(std::abs(d.frequency() - O::k_a1_hz * std::exp2(st / 12.0)) < 1e-9); + CHECK(std::abs(d.semitones() - st) < 1e-9); + } + d.set_ribbon(0.0); + CHECK(std::abs(d.frequency() - 55.0) < 1e-12); // A1, the ribbon's lowest note +} + +SCENARIO("the voice plays the note the ribbon asks for") { + for (double st : {0.0, 24.0, 48.0}) { + const std::vector y = run_voice(st, 1.0, 4); + const double want = O::k_a1_hz * std::exp2(st / 12.0); + const size_t from = y.size() / 2; + // The fundamental has to be the strongest thing in the signal, not merely present. + const double h1 = bin(y, want, from); + INFO(st << " st (" << want << " Hz): H1 " << h1); + CHECK(h1 > 0.3); + for (int k = 2; k <= 5; ++k) { + CHECK(bin(y, want * k, from) < h1); + } + } +} + +// The gain-staging promise, at the level of the whole instrument this time. +SCENARIO("drive adds harmonics monotonically without running away in level") { + double last_thd = 0.0; + double first_h1 = 0.0; + for (double d : {0.0, 1.0, 2.0, 4.0, 8.0}) { + const std::vector y = run_voice(24.0, d, 4); + const double t = thd(y, 220.0); + const double h = bin(y, 220.0, y.size() / 2); + INFO("drive " << d << ": THD " << t << ", H1 " << h); + CHECK(t > last_thd); // more drive, more harmonics — every step + last_thd = t; + if (first_h1 == 0.0) { + first_h1 = h; + } + CHECK(h > 0.5 * first_h1); // and the level does not collapse on the way + } + // At drive 0 the tubes are as linear as they get and the harmonics are still there, because + // the DEMODULATOR made them. That is the object's whole thesis in one assertion. + const double clean = thd(run_voice(24.0, 0.0, 4), 220.0); + INFO("harmonic content with the tubes barely driven: " << clean); + CHECK(clean > 0.15); +} + +SCENARIO("the coupling polarity is audible, which is why it is a switch") { + O::voice a, b; + for (O::voice* v : {&a, &b}) { + v->prepare(k_sr); + v->set_smooth_ms(0.0); + v->set_ribbon(24.0); + v->set_drive(4.0); + v->set_key(1.0); + v->set_level(1.0); + } + b.set_polarity(-1); + + std::vector ya(static_cast(k_sr)), yb(ya.size()); + for (size_t i = 0; i < ya.size(); ++i) { + ya[i] = a.process(); + yb[i] = b.process(); + } + INFO("THD: +1 " << thd(ya, 220.0) << ", -1 " << thd(yb, 220.0)); + CHECK(std::abs(thd(ya, 220.0) - thd(yb, 220.0)) > 0.05); +} + +// The paper drops the power amplifier for real-time and says why. This checks their reason +// rather than their conclusion. +SCENARIO("the power stage really is the least important of the three") { + O::voice off, on; + for (O::voice* v : {&off, &on}) { + v->prepare(k_sr); + v->set_smooth_ms(0.0); + v->set_ribbon(24.0); + v->set_drive(2.0); + v->set_key(1.0); + v->set_level(1.0); + } + on.set_power_stage(true); + + std::vector a(static_cast(k_sr)), b(a.size()); + for (size_t i = 0; i < a.size(); ++i) { + a[i] = off.process(); + b[i] = on.process(); + } + INFO("THD without the 2A3 " << thd(a, 220.0) << ", with it " << thd(b, 220.0)); + CHECK(std::abs(thd(a, 220.0) - thd(b, 220.0)) < 0.02); + CHECK(thd(b, 220.0) > thd(a, 220.0)); // it does something, just not much +} + +SCENARIO("the intensity key silences the voice at rest and opens it at full press") { + O::voice v; + v.prepare(k_sr); + v.set_smooth_ms(0.0); + v.set_ribbon(24.0); + v.set_level(1.0); + v.set_key(0.0); + + bool silent = true; + for (int i = 0; i < 24000; ++i) { + silent = silent && (v.process() == 0.0); + } + REQUIRE(silent); // the bottom of the key's travel is exact silence — touche.h's contract + + v.set_key(1.0); + double peak = 0.0; + for (int i = 0; i < 24000; ++i) { + peak = std::max(peak, std::abs(v.process())); + } + CHECK(peak > 0.1); +} + +SCENARIO("where the key sits in the chain changes what it does") { + O::voice after, before; + for (O::voice* v : {&after, &before}) { + v->prepare(k_sr); + v->set_smooth_ms(0.0); + v->set_ribbon(24.0); + v->set_drive(6.0); + v->set_key(0.62); + v->set_level(1.0); + } + before.set_key_placement(O::key_before); + + std::vector a(static_cast(k_sr)), b(a.size()); + for (size_t i = 0; i < a.size(); ++i) { + a[i] = after.process(); + b[i] = before.process(); + } + // Placed after, the key is a clean output law and the harmonic content is whatever full + // press would give. Placed before, a half-pressed key drives the tubes less hard, so the + // sound is cleaner — pressure becomes dirt, which is the whole reason to offer the choice. + INFO("THD with the key after " << thd(a, 220.0) << ", before " << thd(b, 220.0)); + CHECK(thd(b, 220.0) < thd(a, 220.0)); +} + +SCENARIO("oversampling improves the aliasing, and never makes it worse") { + // Two traps this probe is built to avoid, both of which caught earlier drafts in this repo. + // A tone that divides the sample rate folds every alias onto a harmonic, where it is + // invisible; and probing halfway between harmonics finds nothing at all, because a perfectly + // periodic signal has exactly zero energy there. So: a fundamental that divides nothing, and + // probes at the COMPUTED fold frequencies, skipping any that land near a real harmonic. + const double f0 = 2637.0; // roughly E7, and coprime with anything that matters + + std::vector floors; + for (int os : {1, 2, 4}) { + O::voice v; + v.prepare(k_sr); + v.set_oversample(os); + v.set_smooth_ms(0.0); + v.set_frequency(f0); + v.set_drive(4.0); + v.set_key(1.0); + v.set_level(1.0); + std::vector y(static_cast(k_sr)); + for (size_t i = 0; i < y.size(); ++i) { + y[i] = v.process(); + } + + const size_t from = y.size() / 2; + const double h1 = bin(y, f0, from); + double worst = 0.0; + for (int k = 2; k <= 40; ++k) { + double fold = std::fmod(f0 * k, k_sr); + if (fold > 0.5 * k_sr) { + fold = k_sr - fold; + } + if (fold < 60.0 || fold > 0.45 * k_sr) { + continue; + } + bool on_harmonic = false; + for (int q = 1; q * f0 < 0.5 * k_sr; ++q) { + on_harmonic = on_harmonic || (std::abs(fold - q * f0) < 200.0); + } + if (!on_harmonic) { + worst = std::max(worst, bin(y, fold, from)); + } + } + floors.push_back(20.0 * std::log10(worst / h1)); + INFO("oversample " << os << ": worst fold " << floors.back() << " dB"); + } + REQUIRE(floors.size() == 3); + CHECK(floors[1] < floors[0] - 5.0); + CHECK(floors[2] < floors[1] - 5.0); + // Unlike fuzz.h, where 4x came out worse than 2x, the sequence here never reverses — see + // the header on why that is a data point rather than a coincidence. +} + +SCENARIO("unprepared, the voice is silent rather than undefined") { + O::voice v; + bool silent = true; + for (int i = 0; i < 1000; ++i) { + silent = silent && (v.process() == 0.0); + } + REQUIRE(silent); +} diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index 71fc287..dc42458 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include @@ -1275,6 +1276,259 @@ int taptools_transducer_process(taptools_transducer h, const double* in, double* }); } +// ---- the Ondes Martenot tube model ----------------------------------------------------------------- + +double taptools_tube_plate_current(int tube, double vpc, double vgc) { + return tap::tools::ondes::plate_current(tap::tools::ondes::tube_at(tube), vpc, vgc); +} + +double taptools_tube_grid_current(int tube, double vgc) { + return tap::tools::ondes::grid_current(tap::tools::ondes::tube_at(tube), vgc); +} + +int taptools_tube_params(int tube, double* out8) { + if (!out8 || tube < 0 || tube >= tap::tools::ondes::k_num_tubes) { + return 0; + } + const tap::tools::ondes::tube_params& t = tap::tools::ondes::tube_at(tube); + out8[0] = t.mu; + out8[1] = t.ex; + out8[2] = t.kg; + out8[3] = t.kp; + out8[4] = t.kvb; + out8[5] = t.vct; + out8[6] = t.va; + out8[7] = t.rgk; + return 8; +} + +// ---- tap.triode~ ------------------------------------------------------------------------------------ + +using ondes_triode = tap::tools::ondes::triode; + +taptools_triode taptools_triode_create(void) { + return static_cast(new ondes_triode()); +} + +void taptools_triode_destroy(taptools_triode h) { + delete static_cast(h); +} + +int taptools_triode_prepare(taptools_triode h, double sr) { + return with(h, [&](ondes_triode& t) { t.prepare(sr); }); +} + +int taptools_triode_set_tube(taptools_triode h, int tube) { + return with(h, [&](ondes_triode& t) { t.set_tube(tube); }); +} + +int taptools_triode_set_operating_point(taptools_triode h, double vbias, double rk, double rp) { + return with( + h, [&](ondes_triode& t) { t.set_operating_point(tap::tools::ondes::operating_point{vbias, rk, rp}); }); +} + +int taptools_triode_set_drive(taptools_triode h, double grid_volts) { + return with(h, [&](ondes_triode& t) { t.set_drive(grid_volts); }); +} + +int taptools_triode_set_corners(taptools_triode h, double hp_hz, double lp_hz) { + return with(h, [&](ondes_triode& t) { t.set_corners(hp_hz, lp_hz); }); +} + +int taptools_triode_clear(taptools_triode h) { + return with(h, [&](ondes_triode& t) { t.clear(); }); +} + +int taptools_triode_process(taptools_triode h, const double* in, double* out, int n) { + if (!in || !out || n < 0) { + return -1; + } + return with(h, [&](ondes_triode& t) { + for (int i = 0; i < n; ++i) { + out[i] = t.process(in[i]); + } + }); +} + +double taptools_triode_curve_at(taptools_triode h, double x) { + const ondes_triode* t = static_cast(h); + return t ? t->curve_at(x) : std::nan(""); +} + +double taptools_triode_plate_swing_at(taptools_triode h, double grid_volts) { + const ondes_triode* t = static_cast(h); + return t ? t->plate_swing_at(grid_volts) : std::nan(""); +} + +double taptools_triode_bias_v(taptools_triode h) { + const ondes_triode* t = static_cast(h); + return t ? t->bias_v() : std::nan(""); +} + +double taptools_triode_quiescent_plate_v(taptools_triode h) { + const ondes_triode* t = static_cast(h); + return t ? t->quiescent_plate_v() : std::nan(""); +} + +double taptools_triode_quiescent_current_a(taptools_triode h) { + const ondes_triode* t = static_cast(h); + return t ? t->quiescent_current_a() : std::nan(""); +} + +double taptools_triode_gain(taptools_triode h) { + const ondes_triode* t = static_cast(h); + return t ? t->small_signal_gain() : std::nan(""); +} + +// ---- the heterodyne detector -------------------------------------------------------------------- + +using ondes_detector = tap::tools::ondes::detector; + +taptools_detector taptools_detector_create(void) { + return static_cast(new ondes_detector()); +} + +void taptools_detector_destroy(taptools_detector h) { + delete static_cast(h); +} + +int taptools_detector_prepare(taptools_detector h, double sr) { + return with(h, [&](ondes_detector& d) { d.prepare(sr); }); +} + +int taptools_detector_set_frequency(taptools_detector h, double hz) { + return with(h, [&](ondes_detector& d) { d.set_frequency(hz); }); +} + +int taptools_detector_set_ribbon(taptools_detector h, double semitones) { + return with(h, [&](ondes_detector& d) { d.set_ribbon(semitones); }); +} + +int taptools_detector_set_depth(taptools_detector h, double depth) { + return with(h, [&](ondes_detector& d) { d.set_depth(depth); }); +} + +int taptools_detector_set_detect_ms(taptools_detector h, double ms) { + return with(h, [&](ondes_detector& d) { d.set_detect_ms(ms); }); +} + +int taptools_detector_clear(taptools_detector h) { + return with(h, [&](ondes_detector& d) { d.clear(); }); +} + +int taptools_detector_process(taptools_detector h, double* out, int n) { + if (!out || n < 0) { + return -1; + } + return with(h, [&](ondes_detector& d) { + for (int i = 0; i < n; ++i) { + out[i] = d.process(); + } + }); +} + +double taptools_detector_envelope_at(taptools_detector h, double phase) { + const ondes_detector* d = static_cast(h); + return d ? d->envelope_at(phase) : std::nan(""); +} + +// ---- tap.ondes~ ------------------------------------------------------------------------------------- + +using ondes_voice = tap::tools::ondes::voice; + +taptools_ondes taptools_ondes_create(void) { + return static_cast(new ondes_voice()); +} + +void taptools_ondes_destroy(taptools_ondes h) { + delete static_cast(h); +} + +int taptools_ondes_prepare(taptools_ondes h, double sr) { + return with(h, [&](ondes_voice& v) { v.prepare(sr); }); +} + +int taptools_ondes_set_ribbon(taptools_ondes h, double semitones) { + return with(h, [&](ondes_voice& v) { v.set_ribbon(semitones); }); +} + +int taptools_ondes_set_frequency(taptools_ondes h, double hz) { + return with(h, [&](ondes_voice& v) { v.set_frequency(hz); }); +} + +int taptools_ondes_set_depth(taptools_ondes h, double d) { + return with(h, [&](ondes_voice& v) { v.set_depth(d); }); +} + +int taptools_ondes_set_detect_ms(taptools_ondes h, double ms) { + return with(h, [&](ondes_voice& v) { v.set_detect_ms(ms); }); +} + +int taptools_ondes_set_drive(taptools_ondes h, double x) { + return with(h, [&](ondes_voice& v) { v.set_drive(x); }); +} + +int taptools_ondes_set_key(taptools_ondes h, double position) { + return with(h, [&](ondes_voice& v) { v.set_key(position); }); +} + +int taptools_ondes_set_key_mm(taptools_ondes h, double mm) { + return with(h, [&](ondes_voice& v) { v.set_key_mm(mm); }); +} + +int taptools_ondes_set_key_placement(taptools_ondes h, int where) { + return with(h, [&](ondes_voice& v) { v.set_key_placement(where); }); +} + +int taptools_ondes_set_power_stage(taptools_ondes h, int on) { + return with(h, [&](ondes_voice& v) { v.set_power_stage(on != 0); }); +} + +int taptools_ondes_set_polarity(taptools_ondes h, int sign) { + return with(h, [&](ondes_voice& v) { v.set_polarity(sign); }); +} + +int taptools_ondes_set_level(taptools_ondes h, double lin) { + return with(h, [&](ondes_voice& v) { v.set_level(lin); }); +} + +int taptools_ondes_set_oversample(taptools_ondes h, int os) { + return with(h, [&](ondes_voice& v) { v.set_oversample(os); }); +} + +int taptools_ondes_set_smooth_ms(taptools_ondes h, double ms) { + return with(h, [&](ondes_voice& v) { v.set_smooth_ms(ms); }); +} + +int taptools_ondes_clear(taptools_ondes h) { + return with(h, [&](ondes_voice& v) { v.clear(); }); +} + +int taptools_ondes_process(taptools_ondes h, double* out, int n) { + if (!out || n < 0) { + return -1; + } + return with(h, [&](ondes_voice& v) { v.process(out, static_cast(n)); }); +} + +int taptools_ondes_process_mod(taptools_ondes h, const double* semitones, const double* key, double* out, int n) { + if (!semitones || !key || !out || n < 0) { + return -1; + } + return with(h, [&](ondes_voice& v) { + for (int i = 0; i < n; ++i) { + v.set_ribbon(semitones[i]); + v.set_key(key[i]); + out[i] = v.process(); + } + }); +} + +double taptools_ondes_frequency(taptools_ondes h) { + const ondes_voice* v = static_cast(h); + return v ? v->frequency() : std::nan(""); +} + // ---- tap.plate ------------------------------------------------------------------------------------- using diffuseur_plate = tap::tools::diffuseur::plate; diff --git a/tools/capi/taptools_capi.h b/tools/capi/taptools_capi.h index 77d10a6..ddd8165 100644 --- a/tools/capi/taptools_capi.h +++ b/tools/capi/taptools_capi.h @@ -409,6 +409,89 @@ TAPTOOLS_API int taptools_transducer_set_saturation(taptools_tra TAPTOOLS_API int taptools_transducer_clear(taptools_transducer h); TAPTOOLS_API int taptools_transducer_process(taptools_transducer h, const double* in, double* out, int n); +// ---- the Ondes Martenot tube model (tap::tools::ondes) ------------------------------------------- + +/// The enhanced Norman Koren law itself, with the circuit paper's fitted parameter sets selected +/// by index (0 = 6F5, 1 = 6C5, 2 = 2A3). Stateless, so no handle: a notebook plotting the +/// published tube curves should be plotting the shipping code, not a copy of the equations. +TAPTOOLS_API double taptools_tube_plate_current(int tube, double vpc, double vgc); +TAPTOOLS_API double taptools_tube_grid_current(int tube, double vgc); +/// The fitted parameters, so a plot can be labelled with the numbers it was drawn from. Fields in +/// Table II order: mu, Ex, Kg, Kp, Kvb, Vct, Va, Rgk. Returns 0 on a bad index, 8 on success. +TAPTOOLS_API int taptools_tube_params(int tube, double* out8); + +// ---- tap.triode~ (tap::tools::ondes::triode) ----------------------------------------------------- + +typedef void* taptools_triode; + +TAPTOOLS_API taptools_triode taptools_triode_create(void); +TAPTOOLS_API void taptools_triode_destroy(taptools_triode h); +TAPTOOLS_API int taptools_triode_prepare(taptools_triode h, double sr); +TAPTOOLS_API int taptools_triode_set_tube(taptools_triode h, int tube); +/// Supply volts, cathode resistor and plate load — the published stage operating points are +/// (100, 1000, 4000) demodulator, (180, 1000, 4000) preamplifier, (230, 750, 1500) power. +TAPTOOLS_API int taptools_triode_set_operating_point(taptools_triode h, double vbias, double rk, double rp); +TAPTOOLS_API int taptools_triode_set_drive(taptools_triode h, double grid_volts); +TAPTOOLS_API int taptools_triode_set_corners(taptools_triode h, double hp_hz, double lp_hz); +TAPTOOLS_API int taptools_triode_clear(taptools_triode h); +TAPTOOLS_API int taptools_triode_process(taptools_triode h, const double* in, double* out, int n); +/// The stage's static curve without running audio: normalized in, normalized out. +TAPTOOLS_API double taptools_triode_curve_at(taptools_triode h, double x); +/// And in the tube's own units: grid volts in, plate volts of swing out. +TAPTOOLS_API double taptools_triode_plate_swing_at(taptools_triode h, double grid_volts); +/// The quiescent point the curve was built around: cathode bias V, plate V, plate current A, and +/// the small-signal gain magnitude. +TAPTOOLS_API double taptools_triode_bias_v(taptools_triode h); +TAPTOOLS_API double taptools_triode_quiescent_plate_v(taptools_triode h); +TAPTOOLS_API double taptools_triode_quiescent_current_a(taptools_triode h); +TAPTOOLS_API double taptools_triode_gain(taptools_triode h); + +// ---- the heterodyne detector (tap::tools::ondes::detector) --------------------------------------- + +typedef void* taptools_detector; + +TAPTOOLS_API taptools_detector taptools_detector_create(void); +TAPTOOLS_API void taptools_detector_destroy(taptools_detector h); +TAPTOOLS_API int taptools_detector_prepare(taptools_detector h, double sr); +TAPTOOLS_API int taptools_detector_set_frequency(taptools_detector h, double hz); +TAPTOOLS_API int taptools_detector_set_ribbon(taptools_detector h, double semitones); +TAPTOOLS_API int taptools_detector_set_depth(taptools_detector h, double d); +TAPTOOLS_API int taptools_detector_set_detect_ms(taptools_detector h, double ms); +TAPTOOLS_API int taptools_detector_clear(taptools_detector h); +/// A source: render n samples of the detected envelope (DC included — the circuit's coupling +/// removes it downstream, and so does the triode stage's conditioning highpass). +TAPTOOLS_API int taptools_detector_process(taptools_detector h, double* out, int n); +/// The ideal envelope at a phase in [0, 1), with no detector on it — the closed form itself. +TAPTOOLS_API double taptools_detector_envelope_at(taptools_detector h, double phase); + +// ---- tap.ondes~ (tap::tools::ondes::voice) ------------------------------------------------------- + +typedef void* taptools_ondes; + +TAPTOOLS_API taptools_ondes taptools_ondes_create(void); +TAPTOOLS_API void taptools_ondes_destroy(taptools_ondes h); +TAPTOOLS_API int taptools_ondes_prepare(taptools_ondes h, double sr); +TAPTOOLS_API int taptools_ondes_set_ribbon(taptools_ondes h, double semitones); // above A1 +TAPTOOLS_API int taptools_ondes_set_frequency(taptools_ondes h, double hz); +TAPTOOLS_API int taptools_ondes_set_depth(taptools_ondes h, double d); // 0..1 +TAPTOOLS_API int taptools_ondes_set_detect_ms(taptools_ondes h, double ms); // published 0.2 +TAPTOOLS_API int taptools_ondes_set_drive(taptools_ondes h, double x); // 0..8 +TAPTOOLS_API int taptools_ondes_set_key(taptools_ondes h, double position); // 0..1 of the travel +TAPTOOLS_API int taptools_ondes_set_key_mm(taptools_ondes h, double mm); +TAPTOOLS_API int taptools_ondes_set_key_placement(taptools_ondes h, int where); // 0 after, 1 before +TAPTOOLS_API int taptools_ondes_set_power_stage(taptools_ondes h, int on); +TAPTOOLS_API int taptools_ondes_set_polarity(taptools_ondes h, int sign); +TAPTOOLS_API int taptools_ondes_set_level(taptools_ondes h, double lin); +TAPTOOLS_API int taptools_ondes_set_oversample(taptools_ondes h, int os); +TAPTOOLS_API int taptools_ondes_set_smooth_ms(taptools_ondes h, double ms); +TAPTOOLS_API int taptools_ondes_clear(taptools_ondes h); +/// A source: render n samples of the instrument, minus its diffuseur. +TAPTOOLS_API int taptools_ondes_process(taptools_ondes h, double* out, int n); +/// Signal-rate performance: the ribbon in semitones and the key position, per sample. +TAPTOOLS_API int taptools_ondes_process_mod(taptools_ondes h, const double* semitones, const double* key, double* out, + int n); +TAPTOOLS_API double taptools_ondes_frequency(taptools_ondes h); + // ---- tap.plate (tap::tools::diffuseur::plate) ---------------------------------------------------- /// The metallique's body on its own — the mode bank without the driver in front of it. Same diff --git a/tools/render/radiohead_render.cpp b/tools/render/radiohead_render.cpp index 24e9b91..50a9e05 100644 --- a/tools/render/radiohead_render.cpp +++ b/tools/render/radiohead_render.cpp @@ -33,7 +33,14 @@ /// same rake with the pitch riding its own independent gesture — the two hands are /// the object) and `scrub_freeze` (two seconds recorded, the recorder stopped, and /// nine seconds built out of that fixed tape: held, crawled through with drift, then -/// scattered with spray). +/// scattered with spray); and finally the Ondes Martenot itself — `triode_tubes` +/// (a sine driven progressively harder through each of the three published valves at +/// its own operating point), `ondes_stages` (the detected envelope alone, then through +/// the demodulator, the preamplifier and the power stage in turn — the first pass is +/// already harmonically rich, which is the object's whole thesis), `ondes_ribbon` (the +/// ribbon and the intensity key played, with continuous glissandi because the ribbon +/// is linear in semitones), and `ondes_diffuseurs` (the same phrase through the +/// principal, the palme and the métallique — the choice an ondes player makes). /// /// Usage: radiohead_render [output-directory] (default: current directory) /// @author Timothy Place @@ -49,6 +56,7 @@ #include #include +#include #include #include #include @@ -622,6 +630,175 @@ namespace { write_scenario(dir + "/scrub_freeze.wav", mono, 0.8, 1); } + // ---- the Ondes Martenot ------------------------------------------------------------------- + + /// The chain, one stage at a time. The same held note four times: the detected envelope on + /// its own, then through the demodulator triode, then the preamplifier as well, then with the + /// 2A3 power stage switched in. The point of hearing it this way is that the first pass is + /// already harmonically rich — the demodulator makes those harmonics, not the tubes. + void ondes_stages(const std::string& dir) { + const double pass = 4.0; + const size_t frames = static_cast(pass * k_r_sr); + std::vector mono; + mono.reserve(4 * frames); + + for (int stage = 0; stage < 4; ++stage) { + if (stage == 0) { + // The detector alone: no tube in the path at all. + tap::tools::ondes::detector d; + d.prepare(k_r_sr); + d.set_ribbon(24.0); + double dc = 0.0; + for (size_t i = 0; i < frames; ++i) { + const double e = d.process(); + dc += 0.001 * (e - dc); // the coupling capacitor the tubes would have provided + mono.push_back(0.35 * (e - dc)); + } + continue; + } + tap::tools::ondes::voice v; + v.prepare(k_r_sr); + v.set_ribbon(24.0); + v.set_key(1.0); + v.set_level(0.35); + v.set_drive(stage >= 2 ? 4.0 : 1.0); + v.set_power_stage(stage == 3); + for (size_t i = 0; i < frames; ++i) { + mono.push_back(v.process()); + } + } + write_scenario(dir + "/ondes_stages.wav", mono, 0.8, 1); + } + + /// The ribbon and the key, played. A slow phrase whose pitch glides continuously — the ribbon + /// is linear in semitones, so a linear hand movement is a linear glissando — with the + /// intensity key shaping every note. Nothing here is quantized, because the instrument does + /// not quantize. + void ondes_ribbon(const std::string& dir) { + tap::tools::ondes::voice v; + v.prepare(k_r_sr); + v.set_smooth_ms(4.0); + v.set_drive(2.5); + v.set_level(0.5); + + // (arrival time, semitones above A1) — the hand slides between them. + const std::vector stops = {{0.0, 19.0}, {2.2, 26.0}, {4.0, 24.0}, {6.0, 31.0}, + {8.4, 29.0}, {10.5, 22.0}, {13.0, 19.0}}; + const size_t frames = static_cast(16.0 * k_r_sr); + std::vector mono(frames); + + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + // Where the hand is: interpolation between stops, which on this instrument really is + // a glissando rather than a portamento between fixed pitches. + double st = stops.back().pitch; + for (size_t k = 0; k + 1 < stops.size(); ++k) { + if (t >= stops[k].onset && t < stops[k + 1].onset) { + const double u = (t - stops[k].onset) / (stops[k + 1].onset - stops[k].onset); + const double e = u * u * (3.0 - 2.0 * u); // eased, so it reads as a hand + st = stops[k].pitch + e * (stops[k + 1].pitch - stops[k].pitch); + break; + } + } + v.set_ribbon(st); + // The left hand on the key: a swell per note. + double press = 0.0; + for (size_t k = 0; k < stops.size(); ++k) { + const double dt = t - stops[k].onset; + if (dt >= -0.35 && dt < 1.9) { + const double a = std::clamp((dt + 0.35) / 0.5, 0.0, 1.0); + const double r = std::clamp(1.0 - (dt - 0.9) / 1.0, 0.0, 1.0); + press = std::max(press, std::min(a, r)); + } + } + v.set_key(0.45 + 0.55 * press); // never quite off: the key's dead zone does the rest + mono[i] = v.process(); + } + write_scenario(dir + "/ondes_ribbon.wav", mono, 0.8, 1); + } + + /// The whole instrument, finally: the voice into each of its loudspeakers in turn. The same + /// phrase through the principal (dry), the palme, and the métallique — which is the choice an + /// ondes player actually makes. + void ondes_diffuseurs(const std::string& dir) { + const size_t frames = static_cast(11.0 * k_r_sr); + std::vector mono; + mono.reserve(3 * frames); + + for (int cabinet = 0; cabinet < 3; ++cabinet) { + tap::tools::ondes::voice v; + v.prepare(k_r_sr); + v.set_smooth_ms(4.0); + v.set_drive(3.0); + v.set_level(0.5); + + tap::tools::diffuseur::palme palme; + palme.prepare(k_r_sr); + palme.set_root_hz(110.0); + palme.set_decay(4.0); + palme.set_damping(3000.0); + palme.set_drive(1.0); + palme.set_asymmetry(0.2); + palme.set_saturation(0.3); + palme.set_mix(60.0); + palme.set_level(0.5); + + tap::tools::diffuseur::metallique gong; + gong.prepare(k_r_sr); + gong.set_pitch_hz(165.0); + gong.set_decay(6.0); + gong.set_brightness(0.8); + gong.set_drive(1.4); + gong.set_asymmetry(0.35); + gong.set_saturation(0.5); + gong.set_mix(60.0); + gong.set_level(1.6); + + for (size_t i = 0; i < frames; ++i) { + const double t = static_cast(i) / k_r_sr; + const double st = 24.0 + 5.0 * std::sin(2.0 * k_r_pi * 0.09 * t) + ((t > 5.5) ? 7.0 : 0.0); + v.set_ribbon(st); + v.set_key(0.55 + 0.45 * (0.5 - 0.5 * std::cos(2.0 * k_r_pi * 0.22 * t))); + const double dry = v.process(); + mono.push_back(cabinet == 0 ? dry : ((cabinet == 1) ? palme.process(dry) : gong.process(dry))); + } + } + write_scenario(dir + "/ondes_diffuseurs.wav", mono, 0.45, 1); // the gong pass is much the loudest + } + + /// The three tubes, on the same signal. A 220 Hz sine driven progressively harder through the + /// 6C5 at the demodulator's operating point, then the preamplifier's, then the 2A3 — same + /// sweep each time, so what changes is only what each valve does with it. + void triode_tubes(const std::string& dir) { + struct setup { + int tube; + tap::tools::ondes::operating_point op; + }; + const setup setups[3] = {{tap::tools::ondes::tube_6c5, tap::tools::ondes::k_op_demod}, + {tap::tools::ondes::tube_6c5, tap::tools::ondes::k_op_preamp}, + {tap::tools::ondes::tube_2a3, tap::tools::ondes::k_op_power}}; + + const size_t frames = static_cast(6.0 * k_r_sr); + std::vector mono; + mono.reserve(3 * frames); + + for (const setup& s : setups) { + tap::tools::ondes::triode t; + t.prepare(k_r_sr); + t.set_tube(s.tube); + t.set_operating_point(s.op); + double phase = 0.0; + for (size_t i = 0; i < frames; ++i) { + const double u = static_cast(i) / static_cast(frames); + t.set_drive(0.2 + 12.0 * u * u); // the grid swing rising through the whole pass + phase += 220.0 / k_r_sr; + phase -= std::floor(phase); + mono.push_back(0.5 * t.process(std::sin(2.0 * k_r_pi * phase))); + } + } + write_scenario(dir + "/triode_tubes.wav", mono, 0.7, 1); + } + } // namespace int main(int argc, char** argv) { @@ -641,5 +818,9 @@ int main(int argc, char** argv) { palme_halo(dir); scrub_gesture(dir); scrub_freeze(dir); + triode_tubes(dir); + ondes_stages(dir); + ondes_ribbon(dir); + ondes_diffuseurs(dir); return 0; } From 8601f9a8c0adbf0575b8a8d074cb752fcc6dbb05 Mon Sep 17 00:00:00 2001 From: Timothy Place Date: Mon, 17 Aug 2026 12:35:49 +0000 Subject: [PATCH 16/22] Give the ondes voice a signal-rate performance path MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `voice::process()` drove the ribbon and the key through their setters, which means the key's 20 ms anti-zipper ramp gets re-targeted on every sample when a signal is driving it — so the key lags the hand by the full slew time instead of tracking it. That is exactly wrong for the one control the instrument is played with. `process(semitones, key_position)` takes both straight from the caller with the ramps bypassed, the way scrub.h and touche.h already do it; the ramps still tick so switching back to the attribute path is continuous rather than a jump. The C ABI's process_mod now routes through it. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- include/taptools/ondes.h | 51 ++++++++++++++++++++++++------------ tools/capi/taptools_capi.cpp | 4 +-- 2 files changed, 35 insertions(+), 20 deletions(-) diff --git a/include/taptools/ondes.h b/include/taptools/ondes.h index aad399c..4f8c2f2 100644 --- a/include/taptools/ondes.h +++ b/include/taptools/ondes.h @@ -629,10 +629,39 @@ namespace tap::tools { // -- audio --------------------------------------------------------------------------- /// A source: no input. One sample of the instrument, minus its loudspeaker. - double process() { + double process() { return core_sample(-1.0, -1.0, false); } + + /// The signal-rate performance path: the ribbon in semitones above A1 and the key + /// over its travel, taken straight from the caller with the ramps bypassed — a + /// control signal is already smooth, and re-targeting a 20 ms ramp every sample would + /// just make the key lag the hand. The ramps are still ticked so a later switch back + /// to the attribute path is continuous rather than a jump. + double process(double semitones, double key_position) { + return core_sample(std::clamp(semitones, 0.0, k_max_semitones), std::clamp(key_position, 0.0, 1.0), + true); + } + + /// Block form: the trivial loop over the scalar path. + void process(double* out, size_t n) { + for (size_t i = 0; i < n; ++i) { + out[i] = process(); + } + } + + private: + // The grid swing each stage sees at `drive` 1, chosen so the published operating + // points are worked but not slammed — the fuzz.h lesson, applied before it bit. + static constexpr double k_nominal_demod_v = 0.9; + static constexpr double k_nominal_preamp_v = 0.6; + static constexpr double k_nominal_power_v = 0.5; + + double core_sample(double semitones, double key_position, bool driven) { if (!m_prepared) { return 0.0; } + if (driven) { + m_detector.set_ribbon(semitones); + } const double drive = m_drive.tick(); const double level = m_level.tick(); m_demod.set_drive(std::max(k_min_drive_v, k_nominal_demod_v * drive)); @@ -640,8 +669,10 @@ namespace tap::tools { m_power.set_drive(std::max(k_min_drive_v, k_nominal_power_v * drive)); // The key's ramp is ticked ONCE per output sample whichever side of the chain it - // is on, so its slew time means the same thing at every oversampling factor. - const double key_gain = m_key.process(1.0); + // is on, so its slew time means the same thing at every oversampling factor. On + // the driven path the ramp still ticks, but the gain comes from the caller. + const double ramped = m_key.process(1.0); + const double key_gain = driven ? m_key.gain_at(key_position) : ramped; double y = 0.0; for (int j = 0; j < m_os; ++j) { @@ -662,20 +693,6 @@ namespace tap::tools { return keyed * level; } - /// Block form: the trivial loop over the scalar path. - void process(double* out, size_t n) { - for (size_t i = 0; i < n; ++i) { - out[i] = process(); - } - } - - private: - // The grid swing each stage sees at `drive` 1, chosen so the published operating - // points are worked but not slammed — the fuzz.h lesson, applied before it bit. - static constexpr double k_nominal_demod_v = 0.9; - static constexpr double k_nominal_preamp_v = 0.6; - static constexpr double k_nominal_power_v = 0.5; - /// The nonlinear chain at whatever rate the caller is running. /// /// The demodulator's grid signal is the NEGATED envelope. That is grid-leak diff --git a/tools/capi/taptools_capi.cpp b/tools/capi/taptools_capi.cpp index dc42458..ba65a39 100644 --- a/tools/capi/taptools_capi.cpp +++ b/tools/capi/taptools_capi.cpp @@ -1517,9 +1517,7 @@ int taptools_ondes_process_mod(taptools_ondes h, const double* semitones, const } return with(h, [&](ondes_voice& v) { for (int i = 0; i < n; ++i) { - v.set_ribbon(semitones[i]); - v.set_key(key[i]); - out[i] = v.process(); + out[i] = v.process(semitones[i], key[i]); } }); } From d5a4adea98a72ff9b1d52acff3d83a4afde06d33 Mon Sep 17 00:00:00 2001 From: Timothy Place Date: Mon, 17 Aug 2026 12:38:28 +0000 Subject: [PATCH 17/22] Propagate the ondes voice's smoothing to its intensity key MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit touche::key keeps its own anti-zipper slew, and voice::set_smooth_ms was not reaching it — so the one control the instrument is actually played with slewed at 20 ms whatever the caller asked for, and a key set to rest kept sounding for that long. Found by a wrapper test in TapTools-Max asking for silence at a rest position and getting 20 ms of sound; pinned here now so the kernel carries it. prepare() re-applies it too, since touche::key::prepare resets its own. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- include/taptools/ondes.h | 11 ++++++++++- tests/ondes_test.cpp | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+), 1 deletion(-) diff --git a/include/taptools/ondes.h b/include/taptools/ondes.h index 4f8c2f2..f7010cb 100644 --- a/include/taptools/ondes.h +++ b/include/taptools/ondes.h @@ -533,6 +533,7 @@ namespace tap::tools { void prepare(double sr) { m_sr = (sr > 0.0) ? sr : 48000.0; m_key.prepare(m_sr); + m_key.set_smooth_ms(m_smooth_ms); // prepare() resets it; the voice's setting wins configure(); m_drive.snap(m_drive.target()); m_level.snap(m_level.target()); @@ -599,7 +600,15 @@ namespace tap::tools { } } - void set_smooth_ms(double ms) { m_smooth_ms = std::max(0.0, ms); } + /// Anti-zipper ramp time for the attribute-driven drive, level and key, in ms. + /// It reaches the intensity key too: `touche::key` keeps its own slew, and a `voice` + /// whose smoothing did not propagate to it would slew the one control the instrument + /// is actually played with at a time nobody set. (Found by a wrapper test asking for + /// silence at a rest position and getting 20 ms of sound.) + void set_smooth_ms(double ms) { + m_smooth_ms = std::max(0.0, ms); + m_key.set_smooth_ms(m_smooth_ms); + } // -- introspection --------------------------------------------------------------------- diff --git a/tests/ondes_test.cpp b/tests/ondes_test.cpp index c2060b7..792b372 100644 --- a/tests/ondes_test.cpp +++ b/tests/ondes_test.cpp @@ -385,6 +385,42 @@ SCENARIO("the power stage really is the least important of the three") { CHECK(thd(b, 220.0) > thd(a, 220.0)); // it does something, just not much } +// A wrapper test asked for silence at a rest position and got 20 ms of sound: the voice's +// smoothing was not reaching the intensity key, which keeps its own slew, so the one control the +// instrument is played with was slewing at a time nobody had set. +SCENARIO("the voice's smoothing reaches the intensity key") { + O::voice v; + v.prepare(k_sr); + v.set_smooth_ms(0.0); + v.set_ribbon(24.0); + v.set_level(1.0); + v.set_key(1.0); + for (int i = 0; i < 4800; ++i) { + v.process(); // get it sounding + } + + v.set_key(0.0); + bool immediate = true; + for (int i = 0; i < 4800; ++i) { + immediate = immediate && (v.process() == 0.0); + } + REQUIRE(immediate); // smooth 0 means smooth 0, everywhere + + // And with smoothing on, the key really does take that long rather than snapping. + v.set_smooth_ms(50.0); + v.set_key(1.0); + for (int i = 0; i < 4800; ++i) { + v.process(); + } + v.set_key(0.0); + int sounded = 0; + for (int i = 0; i < 4800; ++i) { + sounded += (v.process() != 0.0) ? 1 : 0; + } + INFO("samples still sounding after a slewed release: " << sounded); + CHECK(sounded > 100); +} + SCENARIO("the intensity key silences the voice at rest and opens it at full press") { O::voice v; v.prepare(k_sr); From 6b3e0cb6407ec5e14032a8b45ba227cce1c80b8e Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 17 Aug 2026 15:39:22 +0000 Subject: [PATCH 18/22] book: six chapters for the scrub, the diffuseurs and the Ondes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Nine objects shipped over the last three days without chapters. They become six: chapters follow instruments, not externals. User-facing (Part V — The machines you ride): - src/scrub.md — "Two hands on the same tape". Filed beside stammer.md because the two share a tape literally. Carries the delay identity (4.4e-16), the position/pitch decoupling, and the warble measured rather than apologized for (98.8% of a clean shifter's band energy, 92.0% of its focus), including the open question against tap.pitchaccum~. - src/diffuseurs.md — "Loudspeakers you can play". Both diffuseurs in one chapter: driven not struck, the transducer upstream of the body (bitwise null; the reverse wiring differs by 28% of peak), twelve strings not twenty-four, and the line between the peer-reviewed instruments and the recreated bodies. - src/ondes.md — "The instrument that is not a synthesizer". tap.ondes~, tap.triode~ and tap.touche~ together: heterodyne, the demodulator as the largest harmonic source (-14.0/-21.3/-26.4 dB), the closed-form envelope, the ribbon linear in semitones, 50 dB in 4.5 mm, the valve as a citation, and the two controls that are labelled choices. Machine appendices (Part X), each earning its length from what went wrong: - machine/scrub.md — grains anchored at the position cancel the transposition, and a single-bin probe reads the fix as the bug. - machine/diffuseur.md — unit peak gain removing the limiter, the DC blocker and the decay/level coupling in one choice; the 2/saturation correction; the selectivity test that measured its own on/off step. - machine/ondes.md — the stage that needed no design, the detector that is an identity, the sign error that ran the drive knob backwards, three measurements that lied, and the oversampling evidence for fuzz.h's open question. Eight new measured figures in book/figures/radiohead.py, same contract as the rest: the shipping kernels through the C ABI, never illustrations. SUMMARY, the introduction's part list and the README's chapter count follow; PLAN-radiohead-chapters.md carries the drafting record. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- README.md | 11 +- book/PLAN-ondes.md | 6 +- book/PLAN-radiohead-chapters.md | 142 +++- book/PLAN-radiohead-family.md | 11 +- book/figures/radiohead.py | 319 +++++++- book/src/SUMMARY.md | 6 + book/src/diffuseurs.md | 161 ++++ book/src/images/diffuseur/plate.svg | 693 ++++++++++++++++ book/src/images/diffuseur/selectivity.svg | 428 ++++++++++ book/src/images/ondes/drive.svg | 380 +++++++++ book/src/images/ondes/envelope.svg | 636 +++++++++++++++ book/src/images/ondes/tube.svg | 723 +++++++++++++++++ book/src/images/scrub/null.svg | 922 ++++++++++++++++++++++ book/src/images/scrub/two-hands.svg | 335 ++++++++ book/src/images/touche/curve.svg | 337 ++++++++ book/src/introduction.md | 7 +- book/src/machine/diffuseur.md | 134 ++++ book/src/machine/ondes.md | 202 +++++ book/src/machine/scrub.md | 139 ++++ book/src/ondes.md | 257 ++++++ book/src/scrub.md | 135 ++++ 21 files changed, 5964 insertions(+), 20 deletions(-) create mode 100644 book/src/diffuseurs.md create mode 100644 book/src/images/diffuseur/plate.svg create mode 100644 book/src/images/diffuseur/selectivity.svg create mode 100644 book/src/images/ondes/drive.svg create mode 100644 book/src/images/ondes/envelope.svg create mode 100644 book/src/images/ondes/tube.svg create mode 100644 book/src/images/scrub/null.svg create mode 100644 book/src/images/scrub/two-hands.svg create mode 100644 book/src/images/touche/curve.svg create mode 100644 book/src/machine/diffuseur.md create mode 100644 book/src/machine/ondes.md create mode 100644 book/src/machine/scrub.md create mode 100644 book/src/ondes.md create mode 100644 book/src/scrub.md diff --git a/README.md b/README.md index 8171e14..18a95df 100644 --- a/README.md +++ b/README.md @@ -113,10 +113,13 @@ Plus, all Max-free: - **`bench/`** — CPU benchmarks and the per-machine regression ratchet (see `bench/README.md`). - **`book/`** — *Tools on Tap*, the mdBook field guide (the AmbiTap/SampleRateTap/MuTap book pattern): one chapter per object family, every claim measured by the notebooks/tests. Built - and published to Pages by `.github/workflows/docs.yml`. Fourteen user-facing chapters across seven - parts — sources (`vco`), filters (`svf`, `ladder`, `autowah`), strings/rooms/spirals - (`convolve`, `5comb`, `pitchaccum`), the spectral set (`vocoder`, `nr`, `spectra`), the rhythm - section (`acid`, `drums`), staying in tune (`tune`), the pedalboard (`overdrive`) — plus + and published to Pages by `.github/workflows/docs.yml`. Twenty-four user-facing chapters across + nine parts — sources (`vco`), filters (`svf`, `ladder`, `autowah`), strings/rooms/spirals + (`convolve`, `5comb`, `pitchaccum`), tape and time (`discreet`, `airport`, `garden`, + `components`), the machines you ride (`tapecho`, `stammer`, `fuzz`, `scrub`, `diffuseurs`, + `ondes`), the spectral set (`vocoder`, `nr`, `spectra`), the rhythm + section (`acid`, `drums`), staying in tune (`tune`), the pedalboard (`overdrive`) — plus a + recipes part of whole patches, and **"The machine, file by file"**: one deep-dive appendix per kernel header (SampleRateTap-style) deriving the math, reviewing the code, and recording why each algorithm is built the way it is. diff --git a/book/PLAN-ondes.md b/book/PLAN-ondes.md index 003457e..4e61531 100644 --- a/book/PLAN-ondes.md +++ b/book/PLAN-ondes.md @@ -2,8 +2,10 @@ > **Status: complete as an object — every piece has shipped.** `touche` 2026-08-15 as > `tap.touche~`; both diffuseurs 2026-08-17 as `tap.metallique~` and `tap.palme~`; the `triode` -> and the heterodyne source 2026-08-17 as `tap.triode~` and `tap.ondes~`. What remains is the -> waveform registers, which are still unsourced (see the last section), and the book chapter. +> and the heterodyne source 2026-08-17 as `tap.triode~` and `tap.ondes~`. The book chapters +> followed the same day — `book/src/ondes.md` (voice, triode and intensity key together) and +> `book/src/diffuseurs.md`, plus `machine/ondes.md` and `machine/diffuseur.md`. What remains is +> the waveform registers, which are still unsourced (see the last section). > The source gate is closed — > `PLAN-radiohead-family.md` §3 records what was found and how far each paper was read. This > file is the design pass those findings forced, written before any code, because what the diff --git a/book/PLAN-radiohead-chapters.md b/book/PLAN-radiohead-chapters.md index c19ef04..e030e69 100644 --- a/book/PLAN-radiohead-chapters.md +++ b/book/PLAN-radiohead-chapters.md @@ -1,13 +1,15 @@ # Plan — the Radiohead-family chapters -> **Status: drafted.** Six chapters now — the original four plus `tap.fuzz~`'s pair, added -> the same day (2026-08-15). This file remains as the drafting record, the plans-directory way. The +> **Status: drafted.** Twelve chapters now — the original four, `tap.fuzz~`'s pair +> (2026-08-15), and the six added when the Ondes family and the scrub landed (2026-08-17). +> This file remains as the drafting record, the plans-directory way. The > object-level plan is `PLAN-radiohead-family.md`; this one covers only the book. Planning document for the *Tools on Tap* chapters covering the shipped Radiohead-family -objects (`tap.tapecho~`, `tap.stammer~`, `tap.fuzz~`; `taptools/tapecho.h`, `stammer.h`, -`fuzz.h`). Six chapters: three user-facing, three machine appendices. It is not part of the -built book. +objects (`tap.tapecho~`, `tap.stammer~`, `tap.fuzz~`, `tap.scrub~`, `tap.metallique~`, +`tap.palme~`, `tap.ondes~`, `tap.triode~`, `tap.touche~`; `taptools/tapecho.h`, `stammer.h`, +`fuzz.h`, `scrub.h`, `diffuseur.h`, `ondes.h`, `touche.h`). Twelve chapters: six user-facing, +six machine appendices. It is not part of the built book. Every measured claim below already exists as an executed notebook cell or a pinned test — each section lists its evidence, so the chapters keep the book's "measured, not remembered" @@ -180,3 +182,133 @@ review the first time. a signal chain to describe. `recipes/` is for whole patches, and two objects is not a rig. - **Comparative listening claims** ("sounds like the record"). Not measurable, not the book's business. + + +--- + +# The 2026-08-17 wave — six more chapters + +Nine objects shipped without chapters between 2026-08-15 and 2026-08-17 (`tap.touche~`, the +two diffuseurs, `tap.scrub~`, `tap.triode~`, `tap.ondes~`). They became **six** chapters, not +nine, and the grouping decisions are the interesting part of this record. + +## Grouping + +- **`src/scrub.md` — *Two hands on the same tape*.** Its own chapter, in Part V, filed + immediately after `stammer.md` because the two share a tape *literally* — `scrub.h` + includes `stammer.h` and uses `stammer::capture` itself. The chapter opens on that, since + "same recorder, different read pattern" is the cleanest way to say what the object is. +- **`src/diffuseurs.md` — *Loudspeakers you can play*.** `tap.metallique~` and `tap.palme~` + together. They are one file, one idea and one set of caveats; two chapters would have + duplicated the provenance section twice over. +- **`src/ondes.md` — *The instrument that is not a synthesizer*.** `tap.ondes~`, + `tap.triode~` **and** `tap.touche~`. The triode does not carry a chapter alone — it is one + stage of the instrument, and its interest (the model is a citation, the stage inverts) only + lands next to the thing it is a stage of. The touche shipped two days earlier and could have + had its own chapter then; holding it for this one was the right call, because "50 dB in + 4.5 mm" means more when the reader can see what it is the dynamic range *of*. + +That is the one structural rule this wave establishes: **chapters follow instruments, not +externals.** The diffuseurs get a separate chapter from the voice despite being part of the +same instrument, because they are usable on anything and the audience is different. + +Machine appendices are one per header, as always: `machine/scrub.md`, `machine/diffuseur.md`, +`machine/ondes.md`. No appendix for `touche.h` — it is a published table with a PCHIP +interpolator over it, and the user chapter already carries everything true about it. + +## Placement + +Three entries appended to **Part V — The machines you ride** (after `fuzz.md`) and three to +**Part X — The machine, file by file** (after `machine/fuzz.md`), keeping Part X's +chronological order. No renumbering this time, so `introduction.md` needed only its Part V +sentence extended — but it *did* need that, which is the second time the standing note below +has earned its keep. + +> **Standing note, restated:** `introduction.md`'s part list is a second copy of SUMMARY's +> structure and nothing checks the two against each other. Any part insertion *or* any change +> to what a part contains has to touch both by hand. + +## Figures + +Eight more measured SVGs, appended to `book/figures/radiohead.py` under the same contract — +driving the shipping kernels through the C ABI, never illustrating them: + +- `images/scrub/null.svg` — the delay identity, and the Hann window sum at overlaps 1/2/4. +- `images/scrub/two-hands.svg` — band energy and concentration across ±19 semitones. +- `images/ondes/envelope.svg` — the envelope at two depths, and `|cos|`'s harmonic series. +- `images/ondes/tube.svg` — the 6C5's plate characteristics with the load line and quiescent + point, and the three stages' transfer curves. +- `images/ondes/drive.svg` — THD and level against drive, with the demodulator's floor marked. +- `images/touche/curve.svg` — the published law, the seven measured points, a straight line + for comparison, and the silent dead zone shaded. +- `images/diffuseur/plate.svg` — the eight modes, and the body answering a sweep. +- `images/diffuseur/selectivity.svg` — the palme's ring after a **faded** drive tone. + +Two rendering lessons, recorded so they are not re-learned: + +- **A label outside the axes stretches the layout.** `ondes_tube`'s first draft labelled each + plate-characteristic curve at its rightmost point; the Vg 0 curve is off the top of the box + by an order of magnitude, and `tight_layout` collapsed the axes to zero trying to fit the + text. Labels are now placed where each curve leaves the visible box. +- **Two curves that are the same line need to look like two curves.** Overlaps 2 and 4 both + sum to exactly 1, so `scrub_null`'s right panel drew one line with two labels on top of each + other. The second is dashed and labelled further along. + +## Evidence the new chapters cite + +`tap.scrub~` — `notebooks/scrub.ipynb`, `tests/scrub_test.cpp`: + +- the delay identity at unity pitch, 4.4e-16 (*"held still at unity pitch, the scrub is the + input delayed"*) +- band energy retained 0.988 mean / 0.917 worst over 7 fundamentals × 7 intervals; + concentration 0.920 / 0.750 +- the wander sweep: 0.933 / 0.958 / 0.965 / 0.990 / 0.993 mean at ±0.5 / ±1 / ±2 / ±3 / ±4 + grains, worst 0.716 / 0.820 / 0.874 / 0.918 / 0.940 +- spray 0 ⇒ seed cannot matter, bitwise; mix 0 ⇒ bitwise passthrough + +`tap.metallique~` / `tap.palme~` — `notebooks/diffuseur.ipynb`, `tests/diffuseur_test.cpp`: + +- the cabinet is **bitwise** `transducer → body`; the reverse wiring differs by 28 % of peak +- plate weights sum to exactly 1, unit peak gain per mode +- transducer bound `2/saturation` (measured 1.49, naive bound 1.25) +- every one of the twelve strings ≥ 4.4× selective, with the drive faded 250 ms in and out + +`tap.ondes~` / `tap.triode~` / `tap.touche~` — `notebooks/ondes.ipynb`, `notebooks/touche.ipynb`, +`tests/ondes_test.cpp`, `tests/touche_test.cpp`: + +- `|cos|` harmonics −14.0 / −21.3 / −26.4 dB, before any valve +- closed form vs full 80 kHz simulation: within 0.10 dB on every harmonic, uniform 3.0–3.2 % + level offset +- detector pitch dependence: H2 −14.0 dB at A2 → −19.3 dB at A6, level down 2.0 dB +- 6C5 demodulator bias Vk 2.70 V, Vp 86.5 V, Ip 2.70 mA, gain 4.86; asymmetry 2.17 : 1 +- drive sweeps THD 0.221 → 0.344 monotonically; `keyplacement` worth 0.09, `polarity` 0.12, + `power` 0.248 → 0.251 +- the oversampling table at 587 / 1175 / 1760 / 2637 / 3520 Hz +- the published key table, 50 dB from 4.3 mm to 8.8 mm, silent below + +## What the appendices are *about* + +Same rule as `machine/fuzz.md`: an appendix earns its length from what went wrong, not from +restating the header. + +- **`machine/scrub.md`** — the anchoring defect (grains anchored at the position cancel the + transposition, and no listening test can see it), and the measurement trap that nearly + inverted the conclusion (a single-bin probe reads the *fixed* kernel as broken, 0.02 against + a band figure of 0.43). +- **`machine/diffuseur.md`** — unit peak gain removing the limiter, the DC blocker and the + decay/level coupling in one choice; the bitwise order null and the `cos(π/2)` endpoint that + had to be short-circuited to get it; the `2/saturation` correction; and the selectivity test + that was measuring its own on/off step. +- **`machine/ondes.md`** — the stage that needed no design because the paper published it; the + detector that is an identity rather than an approximation; the sign error that made a + distortion knob run backwards; three measurements that lied in three different ways; the + oversampling evidence for `fuzz.h`'s open question; and the wrapper test that found a kernel + bug. + +## Still deliberately not covered + +- **A recipes entry.** Now genuinely earnable — `tap.ondes~` → `tap.palme~` with the ribbon + and key on signals is a rig, and the scrub into a diffuseur is another. Deferred rather than + declined: `recipes/` entries are whole patches with patcher-level detail, and that is a + separate piece of work from the chapters. +- **The Max-side surface**, and **comparative listening claims**. Unchanged. diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 7a775ff..c6b5c46 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -430,11 +430,12 @@ are the house precedent for schematic-based recreation. **Naming is an open ques and the two taps land a half-window apart. That is a real finding about a shipped object, recorded rather than acted on: fixing it is its own job, with its own tests and its own consumers, and it should not ride along on an unrelated kernel. -- **Chapters for the six newest objects.** `tap.touche~`, the two diffuseurs, `tap.scrub~`, - `tap.triode~` and `tap.ondes~` have kernels, notebooks and Max slices but no book chapters. - The first three of those and the last two now belong together in one Ondes-family chapter, - since the instrument is complete enough to write about as an instrument; the scrub's belongs - beside the stammer in Part V, since they share a tape. +- ~~**Chapters for the six newest objects.**~~ — ✅ shipped 2026-08-17 as six chapters, three + user-facing and three machine appendices: `book/src/scrub.md`, `diffuseurs.md`, `ondes.md` + (which carries `tap.ondes~`, `tap.triode~` and `tap.touche~` together, since the triode and + the key only make sense next to the instrument they are stages of), plus + `machine/scrub.md`, `machine/diffuseur.md` and `machine/ondes.md`. Eight new measured + figures in `book/figures/radiohead.py`. Drafting record in `PLAN-radiohead-chapters.md`. - ~~**The oversampler's non-monotone sequence** (`fuzz.h`'s open question)~~ — not resolved, but no longer without evidence. `ondes.h` runs the same 8th-order chain around a comparably hard nonlinearity as a **source**, with no zero-stuffing and therefore no images, and its sequence diff --git a/book/figures/radiohead.py b/book/figures/radiohead.py index 5a2d360..22eb692 100644 --- a/book/figures/radiohead.py +++ b/book/figures/radiohead.py @@ -1,7 +1,8 @@ #!/usr/bin/env python3 """Generate the measured figures for the Radiohead-family book chapters. -Drives the *shipping* kernels (tapecho.h, stammer.h, fuzz.h) through the C ABI via the +Drives the *shipping* kernels (tapecho.h, stammer.h, fuzz.h, scrub.h, touche.h, diffuseur.h, +ondes.h) through the C ABI via the notebooks' ctypes bridge — the same rule as eno.py and the verification notebooks: figures are measurements of the real DSP, never illustrations of what it should do. The companion notebooks (notebooks/tapecho.ipynb, @@ -10,7 +11,8 @@ Regenerate after a kernel behavior change: - python3 book/figures/radiohead.py # writes book/src/images/{tapecho,stammer,fuzz}/*.svg + python3 book/figures/radiohead.py + # writes book/src/images/{tapecho,stammer,fuzz,scrub,ondes,diffuseur}/*.svg Colors and rcParams are eno.py's, verbatim in intent: the house categorical hues with the amber snapped darker so pairs pass the print/CVD lightness-band @@ -258,6 +260,311 @@ def make(**kw): plt.close(fig) +# ---- tap.scrub~ ------------------------------------------------------------------------------ + + +def scrub_null(): + """scrub: the identity the whole object is built on, and the window sum behind it.""" + lag, size = 480, 96 # samples; size divides by the overlap, which is what makes it exact + m = tap.Scrub(fs, 2000.0, smooth_ms=0, overlap=2, mix=100, level=1.0, + size_ms=size * 1000.0 / fs, position_ms=lag * 1000.0 / fs) + x = pluck_train(0.7) + y = m.process(x) + err = float(np.max(np.abs(y[2000:] - x[2000 - lag:-lag]))) + + fig, (a1, a2) = plt.subplots(1, 2, figsize=(7.2, 2.6)) + sl = slice(9000, 10200) + ms = np.arange(sl.start, sl.stop) / fs * 1000.0 + a1.plot(ms, x[sl.start - lag:sl.stop - lag], color=AMBER, lw=3.0, alpha=0.45) + a1.plot(ms, y[sl], color=BLUE, lw=1.0) + pk = float(np.max(np.abs(y[sl]))) + a1.set_ylim(-1.35 * pk, 1.75 * pk) + a1.text(ms[10], 1.48 * pk, "input, 480 samples late", color=AMBER, fontsize=8.5) + a1.text(ms[10], 1.18 * pk, "the scrub", color=BLUE, fontsize=8.5) + a1.set_xlabel("time (ms)") + a1.set_title(f"held still at unity pitch: worst error {err:.1e}", fontsize=9.5) + + # Overlaps 2 and 4 both sum to exactly 1, so they are the same line: draw the second + # dashed and label them apart, or the figure looks like one of them is missing. + for n_ov, color, style, at in ((1, RED, "-", 1.0), (2, BLUE, "-", 1.0), (4, AMBER, "--", 14.0)): + g = tap.Scrub(fs, 500.0, smooth_ms=0, overlap=n_ov, mix=100, + size_ms=480 * 1000.0 / fs, position_ms=2400 * 1000.0 / fs) + z = g.process(np.ones(int(0.4 * fs)))[-1200:] + a2.plot(np.arange(z.size) / fs * 1000.0, z, color=color, lw=1.4, ls=style) + y_at = float(z[:200].mean()) + a2.text(at, y_at + (0.05 if n_ov != 4 else -0.14), f"overlap {n_ov}", color=color, + fontsize=8.5) + a2.set_ylim(0, 1.25) + a2.set_xlabel("time (ms)") + a2.set_ylabel("gain on a constant") + a2.set_title("Hann overlap-adds flat from 2 up", fontsize=9.5) + plt.tight_layout() + fig.savefig(out_dir("scrub") / "null.svg", bbox_inches="tight") + plt.close(fig) + + +def scrub_two_hands(): + """scrub: the pitch moves while the position does not, and what the wraps cost.""" + def measure(st, f0=311.0, half=15.0): + g = tap.Scrub(fs, 3000.0, smooth_ms=0, overlap=2, size_ms=100.0, + position_ms=900.0, pitch=float(st), mix=100, level=1.0) + n = int(fs * 3.0) + t = np.arange(n) / fs + y = g.process(0.5 * np.sin(2 * np.pi * f0 * t)) + ref = 0.5 * np.sin(2 * np.pi * f0 * 2 ** (st / 12) * t) + + def band(sig): + seg = sig[len(sig) // 2:] + mag = np.abs(np.fft.rfft(seg * np.hanning(len(seg)))) + fr = np.fft.rfftfreq(len(seg), 1 / fs) + sel = np.abs(fr - f0 * 2 ** (st / 12)) <= half + return np.sqrt((mag[sel] ** 2).sum()), mag[sel].max() + + b, pk = band(y) + rb, rpk = band(ref) + return b / rb, (pk / b) / (rpk / rb) + + semis = np.array([-12, -7, -3, 3, 7, 12, 19]) + energy, focus = zip(*[measure(s) for s in semis]) + + fig, ax = plt.subplots(figsize=(7.2, 2.6)) + ax.plot(semis, np.array(energy), "o-", color=BLUE, ms=5) + ax.plot(semis, np.array(focus), "o-", color=RED, ms=5) + ax.axhline(1.0, color=MUTED, lw=0.8, ls=":") + ax.text(-11, 0.70, "energy at the transposed pitch", color=BLUE, fontsize=8.5) + ax.text(-11, 0.64, "how concentrated it is on one line", color=RED, fontsize=8.5) + ax.set_ylim(0.6, 1.06) + ax.set_xlabel("pitch (semitones), position held at 900 ms") + ax.set_ylabel("fraction of a clean shifter") + ax.set_title("the pitch moves; what the wraps cost is focus, not the note") + fig.savefig(out_dir("scrub") / "two-hands.svg", bbox_inches="tight") + plt.close(fig) + + +# ---- the Ondes Martenot ------------------------------------------------------------------------ + + +def ondes_envelope(): + """ondes: the demodulated envelope, and the harmonics it carries before any valve.""" + det = tap.Detector(fs, frequency=220.0) + ph = np.linspace(0, 2, 801) + + fig, (a1, a2) = plt.subplots(1, 2, figsize=(7.2, 2.7)) + for depth, color, label in ((1.0, BLUE, "depth 1 (equal oscillators)"), + (0.5, AMBER, "depth 0.5")): + d = tap.Detector(fs, frequency=220.0, depth=depth) + a1.plot(ph, d.envelope(ph % 1.0), color=color, lw=1.6) + a1.text(0.06, d.envelope(np.array([0.5]))[0] + 0.12, label, color=color, fontsize=8.5) + a1.set_xlabel("cycles of the note") + a1.set_ylabel("envelope") + a1.set_title("the envelope of two summed oscillators", fontsize=9.5) + + ideal = np.array([(4 / np.pi) / (4 * n * n - 1) for n in range(1, 7)]) + db = 20 * np.log10(ideal[1:] / ideal[0]) + a2.bar(np.arange(2, 7), db, color=BLUE, width=0.6) + for n, v in zip(range(2, 7), db): + a2.text(n, v - 1.6, f"{v:.1f}", ha="center", color="white", fontsize=8.5) + a2.set_xlabel("harmonic") + a2.set_ylabel("dB below the fundamental") + a2.set_title("|cos| is not a sinusoid — before any valve", fontsize=9.5) + plt.tight_layout() + fig.savefig(out_dir("ondes") / "envelope.svg", bbox_inches="tight") + plt.close(fig) + + +def ondes_tube(): + """ondes: the published valve, and the load line that makes a stage out of it.""" + vp = np.linspace(1, 260, 400) + vbias, rk, rp = tap.OP_DEMOD + t = tap.Triode(fs, tap.TUBE_6C5, tap.OP_DEMOD) + vk, vp0, ip0, gain = t.bias + + fig, (a1, a2) = plt.subplots(1, 2, figsize=(7.2, 3.1)) + for vg, color in ((0.0, RED), (-2.0, AMBER), (-4.0, BLUE), (-8.0, MUTED)): + ip = tap.tube_plate_current(tap.TUBE_6C5, vp, vg) * 1000.0 + a1.plot(vp, ip, color=color, lw=1.3) + # Label where the curve leaves the visible box, not at its last point: the Vg 0 curve + # is off the top of the plot by 260 V, and a label out there stretches the layout. + inside = np.flatnonzero(ip < 13.0) + j = int(inside[-1]) if inside.size else 0 + a1.text(float(vp[j]) + 4, float(ip[j]), f"Vg {vg:.0f}", color=color, fontsize=8, + va="center") + load = (vbias - vk - vp) / rp * 1000.0 + a1.plot(vp, load, color=INK, lw=1.2, ls="--") + a1.plot([vp0], [ip0 * 1000.0], "o", color=INK, ms=6) + a1.text(vp0 - 8, ip0 * 1000.0 + 1.6, "quiescent", color=INK, fontsize=8.5, ha="right") + a1.set_xlim(0, 285) + a1.set_ylim(0, 14) + a1.set_xlabel("plate volts") + a1.set_ylabel("plate current (mA)") + a1.set_title(f"6C5 at the demodulator's point ({vbias:.0f} V, {rp/1000:.0f}k)", fontsize=9.5) + + gv = np.linspace(-10, 10, 501) + for name, tube, op, color in (("6C5, demodulator", tap.TUBE_6C5, tap.OP_DEMOD, BLUE), + ("6C5, preamplifier", tap.TUBE_6C5, tap.OP_PREAMP, AMBER), + ("2A3, power amp", tap.TUBE_2A3, tap.OP_POWER, RED)): + a2.plot(gv, tap.Triode(fs, tube, op).plate_swing(gv), color=color, lw=1.5) + a2.text(-9.5, -34, "6C5, demodulator", color=BLUE, fontsize=8.5) + a2.text(-9.5, -46, "6C5, preamplifier", color=AMBER, fontsize=8.5) + a2.text(-9.5, -58, "2A3, power amp", color=RED, fontsize=8.5) + a2.set_xlabel("grid volts around the bias point") + a2.set_ylabel("plate swing (V)") + a2.set_title("the stage inverts, and it is not symmetric", fontsize=9.5) + plt.tight_layout() + fig.savefig(out_dir("ondes") / "tube.svg", bbox_inches="tight") + plt.close(fig) + + +def ondes_drive(): + """ondes: the harmonics are there before the drive knob does anything.""" + def run(d): + v = tap.Ondes(fs, smooth_ms=0, ribbon=24.0, key=1.0, level=1.0, drive=float(d)) + return v.process(int(fs * 1.0)), v.frequency + + def goertzel(y, f): + seg = y[len(y) // 2:] + w = 2 * np.pi * f / fs + c = 2 * np.cos(w) + s1 = s2 = 0.0 + for val in seg: + s1, s2 = val + c * s1 - s2, s1 + return np.sqrt(max(0.0, s1 * s1 + s2 * s2 - c * s1 * s2)) * 2 / len(seg) + + drives = np.array([0.0, 0.5, 1.0, 2.0, 4.0, 6.0, 8.0]) + thd, level = [], [] + for d in drives: + y, f0 = run(d) + h = np.array([goertzel(y, f0 * k) for k in range(1, 11)]) + thd.append(np.sqrt((h[1:] ** 2).sum()) / h[0]) + level.append(h[0]) + + fig, ax = plt.subplots(figsize=(7.2, 2.6)) + ax.plot(drives, thd, "o-", color=BLUE, ms=5) + ax.plot(drives, level, "o-", color=AMBER, ms=5) + ax.axhline(thd[0], color=MUTED, lw=0.8, ls=":") + ax.text(0.15, thd[0] - 0.075, "what the demodulator alone already makes", color=MUTED, + fontsize=8.5) + ax.text(4.2, 0.12, "harmonic content", color=BLUE, fontsize=8.5) + ax.text(3.6, 0.90, "fundamental level", color=AMBER, fontsize=8.5) + ax.set_ylim(0, 1.0) + ax.set_xlabel("drive") + ax.set_title("the valves add to a signal that is already rich") + fig.savefig(out_dir("ondes") / "drive.svg", bbox_inches="tight") + plt.close(fig) + + +def touche_curve(): + """ondes: the intensity key's published law, against the line nobody measured.""" + table_db = np.array([45.0, 53.3, 61.6, 70.0, 78.3, 86.6, 95.0]) + table_mm = np.array([4.3, 5.3, 5.9, 6.4, 6.8, 7.3, 8.8]) + travel = 9.5 + + key = tap.Touche(fs, smooth_ms=0) + p = np.linspace(0, 1, 2001) + mm = p * travel + curve = 20 * np.log10(np.where((g := np.array([key.gain_at(v) for v in p])) > 0, g, 1e-300)) + band = (mm >= table_mm[0]) & (mm <= table_mm[-1]) + frac = (mm - table_mm[0]) / (table_mm[-1] - table_mm[0]) + line = -50.0 * (1.0 - frac) + + fig, ax = plt.subplots(figsize=(7.2, 2.7)) + ax.plot(mm[band], curve[band], color=BLUE, lw=2.0) + ax.plot(mm[band], line[band], color=AMBER, lw=1.2, ls="--") + ax.plot(table_mm, table_db - table_db[-1], "o", color=RED, ms=6, zorder=5) + ax.axvspan(0, table_mm[0], color=MUTED, alpha=0.10) + ax.text(2.1, -25, "silent:\nthe key is\nstill bending", color=MUTED, fontsize=8.5, ha="center") + ax.text(4.6, -8, "Quartier et al. 2015", color=RED, fontsize=8.5) + ax.text(6.5, -38, "a straight line, for comparison", color=AMBER, fontsize=8.5) + ax.set_xlim(0, travel) + ax.set_xlabel("key displacement (mm)") + ax.set_ylabel("gain (dB, referenced to full press)") + ax.set_title("50 dB in 4.5 mm — and the shape is the measurement, not a fit") + fig.savefig(out_dir("touche") / "curve.svg", bbox_inches="tight") + plt.close(fig) + + +# ---- the diffuseurs -------------------------------------------------------------------------- + + +def diffuseur_plate(): + """metallique: where the modes are, and what the body does to a sweep.""" + ratios = np.array([1.000, 1.730, 2.328, 3.910, 4.110, 6.300, 6.710, 7.340]) + gong = tap.Metallique(fs, pitch_hz=180.0, decay=6.0, brightness=1.0, + drive=1.0, asymmetry=0.0, saturation=0.0, mix=100.0) + hz, weight = gong.modes() + + probe = np.geomspace(60.0, 2000.0, 160) + resp = [] + for f in probe: + g = tap.Metallique(fs, pitch_hz=180.0, decay=1.2, brightness=1.0, + drive=1.0, asymmetry=0.0, saturation=0.0, mix=100.0) + n = int(fs * 1.0) + y = g.process(np.sin(2 * np.pi * f * np.arange(n) / fs)) + resp.append(float(np.abs(y[int(fs * 0.75):]).max())) + resp = np.array(resp) + + fig, (a1, a2) = plt.subplots(1, 2, figsize=(7.2, 2.7)) + a1.vlines(hz, 0, weight, color=BLUE, lw=2.5) + a1.plot(hz, weight, "o", color=BLUE, ms=5) + for i, (f, w, r) in enumerate(zip(hz, weight, ratios)): + a1.annotate(f"{r:.3f}", (f, w), textcoords="offset points", + xytext=(0, 6 if i % 2 == 0 else 17), ha="center", fontsize=7.5, color=MUTED) + a1.set_ylim(0, 0.40) + a1.set_xlabel("frequency (Hz)") + a1.set_ylabel("weight") + a1.set_title(f"eight plate modes, weights summing to {weight.sum():.0f}", fontsize=9.5) + + a2.semilogx(probe, 20 * np.log10(resp), color=BLUE, lw=1.4) + for f in hz: + a2.axvline(f, color=MUTED, lw=0.7, ls=":") + a2.set_xlabel("drive frequency (Hz)") + a2.set_ylabel("peak out (dB, unit input)") + a2.set_title("driven, not struck: the body answers a sweep", fontsize=9.5) + plt.tight_layout() + fig.savefig(out_dir("diffuseur") / "plate.svg", bbox_inches="tight") + plt.close(fig) + + +def diffuseur_selectivity(): + """palme: twelve strings, and what they answer.""" + kw = dict(root_hz=110.0, tuning=0, decay=6.0, damping=4000.0, detune=0.0, + drive=1.0, asymmetry=0.0, saturation=0.0, mix=100.0, level=1.0, smooth_ms=0.0) + + def ring(hz, drive_s=2.0, tail_s=1.0, fade_s=0.25): + # The drive is faded: switching a tone on and off is a step, and a step excites every + # string on the board, so without the fades this measures its own edges. + p = tap.Palme(fs, **kw) + n_on = int(fs * drive_s) + n = n_on + int(fs * tail_s) + t = np.arange(n) / fs + g = np.zeros(n) + f = int(fs * fade_s) + g[:n_on] = 1.0 + g[:f] = 0.5 - 0.5 * np.cos(np.pi * np.arange(f) / f) + g[n_on - f:n_on] = 0.5 - 0.5 * np.cos(np.pi * np.arange(f, 0, -1) / f) + y = p.process(g * 0.3 * np.sin(2 * np.pi * hz * t)) + tail = y[n_on + int(fs * 0.2):] + return float(np.sqrt(np.mean(tail ** 2))) + + probe = np.geomspace(100.0, 440.0, 150) + tails = np.array([ring(f) for f in probe]) + strings, _ = tap.Palme(fs, **kw).strings() + + fig, ax = plt.subplots(figsize=(7.2, 2.7)) + ax.semilogx(probe, 20 * np.log10(tails / tails.max()), color=BLUE, lw=1.4) + for f in strings: + ax.axvline(f, color=MUTED, lw=0.7, ls=":") + ax.text(103, -68, "dotted: the twelve strings", color=MUTED, fontsize=8.5) + ax.set_xticks([100, 150, 200, 300, 440]) + ax.set_xticklabels(["100", "150", "200", "300", "440"]) + ax.set_xticks([], minor=True) # the log minor labels collide with 440 + ax.set_xlabel("drive frequency (Hz)") + ax.set_ylabel("ring left after the drive stops (dB)") + ax.set_title("the palme answers what it is tuned to, and little else") + fig.savefig(out_dir("diffuseur") / "selectivity.svg", bbox_inches="tight") + plt.close(fig) + + if __name__ == "__main__": head_layout() self_oscillation() @@ -265,4 +572,12 @@ def make(**kw): material() fuzz_curve() fuzz_gain_and_bite() + scrub_null() + scrub_two_hands() + ondes_envelope() + ondes_tube() + ondes_drive() + touche_curve() + diffuseur_plate() + diffuseur_selectivity() print("wrote the Radiohead-family figures") diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index 174de3a..7913576 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -30,6 +30,9 @@ - [Four heads and a motor](tapecho.md) - [The part that comes apart](stammer.md) - [The dirt with two stages](fuzz.md) +- [Two hands on the same tape](scrub.md) +- [Loudspeakers you can play](diffuseurs.md) +- [The instrument that is not a synthesizer](ondes.md) # Part VI — The spectral set @@ -74,6 +77,9 @@ - [Composition, not construction: tapecho.h](machine/tapecho.md) - [Dice you can replay: stammer.h](machine/stammer.md) - [Two stages and a knee: fuzz.h](machine/fuzz.md) +- [One tape, two read patterns: scrub.h](machine/scrub.md) +- [Driven, not struck: diffuseur.h](machine/diffuseur.md) +- [A citation, an identity, and a sign: ondes.h](machine/ondes.md) # Part XI — Recipes diff --git a/book/src/diffuseurs.md b/book/src/diffuseurs.md new file mode 100644 index 0000000..160818a --- /dev/null +++ b/book/src/diffuseurs.md @@ -0,0 +1,161 @@ +# Loudspeakers you can play + +The Ondes Martenot does not have a loudspeaker. It has a rack of them, and +the player chooses. Beyond the plain cabinet — the *principal* — Maurice +Martenot built resonating **diffuseurs** whose entire job is to colour the +signal with a physical body: the **métallique** (1944–45, patented 1947), a +gong driven by a motor transducer, and the **palme** (1949–50), an +electromagnet driving twelve metal strings stretched on a soundboard. + +`tap.metallique~` and `tap.palme~` are those two, and they ship as +standalone effects rather than as something hidden inside `tap.ondes~`, +because the interesting thing about a resonating loudspeaker is that it does +not care what you put through it. A guitar into the palme is not what +Martenot had in mind and it is the best reason to have the object. + +Najnudel, Hélie, Roze and Boutin (IEEE/ACM TASLP 28, 2020) name the +diffuseur as the stage that "converts the electrical waveform into sound and +in turn modifies its spectral content". Wijnand, Boutin, Jossic and Maniguet +(Forum Acusticum 2023) describe the instruments and measure the transducer. +Everything below traces to one of those two, or is labelled as a +recreation. + +Companion material: the executed notebook `diffuseur.ipynb`, +`tests/diffuseur_test.cpp`, and the `radiohead_render` scenes +`metallique_stages` and `palme_halo`. + +## Driven, not struck + +`tap.chime~` and `tap.garden~` already carry this library's modal machinery +— mode ratios, doublet splitting, per-mode decay — and it carries over here +intact. What does *not* carry over is the strike. There is no trigger in +either of these objects and no decay envelope. A diffuseur is excited +continuously by whatever is going through it and rings at its own rates, +which is `tap.5comb~`'s sustained-resonance situation rather than the +chime's. + +Practically, that is the difference between an object you fire and an object +you feed. + +## The order is the argument + +The electrical signal reaches the *transducer* first, and the transducer's +motion is what excites the body. So the nonlinearity sits **upstream** of +the resonator. Drive the transducer hard and you are pushing a distorted +waveform into a gong — which is a different sound from distorting a gong. + +That claim is pinned rather than asserted: a null test in the kernel checks +that a whole cabinet is *bitwise* identical to `transducer → body` wired by +hand, and that the reverse wiring differs by 28 % of peak. It is not a +subtlety you have to take on faith, and it is not a subtlety you can hear +your way past. + +## The métallique + +Eight modes at the free circular plate's transverse ratios — Rayleigh's +classical Chladni set at Poisson 0.3, `1 : 1.730 : 2.328 : 3.910 : 4.110 : +6.300 : 6.710 : 7.340` — each split into a slowly beating doublet. + +![Two panels: eight modes as stems with their ratios labelled, weights summing to 1; and the plate's measured response to a swept drive tone, peaking at each mode](images/diffuseur/plate.svg) + +*Left: where the modes are. Right: the body answering a sweep, which is how you actually meet it.* + +`pitch` places the lowest mode and the rest follow. `decay` is the +fundamental's T60 — long is a drone, short is a plate reverb. `tilt` decides +how much faster the upper modes die than the fundamental, and `brightness` +weights them. The weights sum to exactly 1 and each mode has unit peak gain, +which is why there is no limiter on the output and no DC blocker either: the +body is bounded by its input, by construction. + +## The palme + +Twelve strings, each a damped delay loop, on one board. + +Twelve, not twenty-four. Widely copied build pages say two banks of twelve; +the peer-reviewed source says twelve, and this object follows the +peer-reviewed source. + +Their *tuning* is not published anywhere found, so it is a control: `@tuning +0` lays them out chromatically across an octave from `root` — a string for +every pitch class, so the board answers whatever you play — and `@tuning 1` +puts the harmonic series on the root, which is a drone that answers one key. + +![The palme's ringing after a faded drive tone is removed, swept from 100 to 440 Hz, with twelve peaks lining up on the twelve string frequencies](images/diffuseur/selectivity.svg) + +*Feed it a tone, take the tone away, measure what is left. Every one of the twelve strings rings at least 4.4× harder at its own pitch than between them.* + +`damping` is how fast a string loses its upper partials — low values are +felt cloth on the strings. `detune` scatters the strings against each other +by a fixed, deterministic amount in cents, because no two strings on a real +board are in perfect relation. + +## The transducer + +Wijnand et al.'s point about the early diffuseurs is that they use a +**moving-iron** driver whose operating principle is inherently nonlinear — +Thiele–Small does not describe it — so a diffuseur modelled as a pure +resonator is missing a documented stage. + +What is modelled here is that principle, not a fit to a measurement. In a +moving-iron motor the force follows the square of the gap flux, so with a +bias current `I₀` and signal `i` the force carries a term in `(I₀ + i)²` +whose residual `i²` makes second-harmonic distortion that grows with drive. +That is `asymmetry`: the transducer's own even-harmonic signature, and the +only part of these objects that is nonlinear by citation. + +`saturation` is the honest exception. A squared law is expansive and +something has to bound it, so there is a soft clipper after it — a +**modelling necessity, not a measured stage**, and its coefficient is a knob +rather than a number from a paper. At 0 it is exactly linear. + +## What these are, and are not + +The instruments, their dates, their excitation and their transducer type are +peer-reviewed. **The modal data is not.** No ondes-specific measurement of +either body exists in any source obtained, so the plate comes from Fletcher +& Rossing's free circular plate and the strings from the harmonic series. +Both bodies are therefore **recreations of the general physics, not models +of Martenot's instruments**. Nothing here was fitted to a recording, a +measurement, or a photograph. + +There is also no radiation model — no directivity, no cabinet, no soundboard +resonance of its own. The output is the body's modal response, not a room. +And the strings are ideal: a real steel string is stiff and its partials +stretch sharp, and that dispersion is not modelled. `detune` scatters +strings against each other, which is a different thing and does not stand in +for it. + +## Recipes + +- **A guitar into the palme:** `tap.palme~ @root 110 @tuning 0 @decay 8 + @mix 45`. The halo underneath everything you play. The reason these ship + standalone. +- **The instrument, assembled:** `tap.ondes~` → `tap.palme~ @mix 60`. What + Martenot actually had. +- **Gong reverb:** `tap.metallique~ @pitch 180 @decay 1.5 @tilt 1.2 + @mix 35`. Short decay turns the body into a plate. +- **A drone you drive:** `tap.metallique~ @decay 20 @drive 3 @asymmetry 0.5 + @saturation 0.4 @mix 100`. Hard into the transducer, which is upstream, so + it is a distorted waveform ringing a gong rather than a distorted gong. +- **The one to be careful with:** `tap.palme~ @level` — twelve resonant loops + add up, and a driven board can be much louder than what went into it. + +## When it is not the right tool + +- **A reverb.** These are twelve strings and eight modes. They are pitched, + and they will impose their pitches on anything you send. +- **A model of Martenot's own diffuseurs.** See above: this is the physics + of the general case, and the difference is stated rather than glossed. +- **Clean sustain.** `tap.5comb~` is the sustained-resonance object without + a nonlinear driver in front of it. + +## Checkpoint + +Two loudspeakers with bodies, shipped as effects because a resonating +cabinet does not care what drives it. Driven rather than struck, so no +trigger and no envelope. The transducer is upstream of the body and a +bitwise null test pins that it is — 28 % of peak says the order is audible. +Every mode has unit peak gain and the weights sum to 1, so the body needs no +limiter. And the bodies are recreations of published physics rather than +measurements of Martenot's instruments, which is a limitation stated here +and in the header rather than left to be discovered. diff --git a/book/src/images/diffuseur/plate.svg b/book/src/images/diffuseur/plate.svg new file mode 100644 index 0000000..8bb947d --- /dev/null +++ b/book/src/images/diffuseur/plate.svg @@ -0,0 +1,693 @@ + + + + + + + + 2026-08-17T15:36:01.802570 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 200 + + + + + + + + + + + + + 400 + + + + + + + + + + + + + 600 + + + + + + + + + + + + + 800 + + + + + + + + + + + + + 1000 + + + + + + + + + + + + + 1200 + + + + frequency (Hz) + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.1 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.3 + + + + + + + + + + + + + 0.4 + + + + weight + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1.000 + + + 1.730 + + + 2.328 + + + 3.910 + + + 4.110 + + + 6.300 + + + 6.710 + + + 7.340 + + + eight plate modes, weights summing to 1 + + + + + + + + + + + + + + + + + + + + + 1 + 0 + 2 + + + + + + + + + + + + + + + + + + 1 + 0 + 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + drive frequency (Hz) + + + + + + + + + + + + + + −60 + + + + + + + + + + + + + −40 + + + + + + + + + + + + + −20 + + + + peak out (dB, unit input) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + driven, not struck: the body answers a sweep + + + + + + + + + + + + diff --git a/book/src/images/diffuseur/selectivity.svg b/book/src/images/diffuseur/selectivity.svg new file mode 100644 index 0000000..cbe2aaa --- /dev/null +++ b/book/src/images/diffuseur/selectivity.svg @@ -0,0 +1,428 @@ + + + + + + + + 2026-08-17T15:36:22.871991 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 100 + + + + + + + + + + + + + 150 + + + + + + + + + + + + + 200 + + + + + + + + + + + + + 300 + + + + + + + + + + + + + 440 + + + + drive frequency (Hz) + + + + + + + + + + + + + + + + + −60 + + + + + + + + + + + + + −40 + + + + + + + + + + + + + −20 + + + + + + + + + + + + + 0 + + + + ring left after the drive stops (dB) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + dotted: the twelve strings + + + the palme answers what it is tuned to, and little else + + + + + + + + + diff --git a/book/src/images/ondes/drive.svg b/book/src/images/ondes/drive.svg new file mode 100644 index 0000000..07e3b1e --- /dev/null +++ b/book/src/images/ondes/drive.svg @@ -0,0 +1,380 @@ + + + + + + + + 2026-08-17T15:36:00.007460 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 1 + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 3 + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 5 + + + + + + + + + + + + + 6 + + + + + + + + + + + + + 7 + + + + + + + + + + + + + 8 + + + + drive + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + 0.4 + + + + + + + + + + + + + 0.6 + + + + + + + + + + + + + 0.8 + + + + + + + + + + + + + 1.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + what the demodulator alone already makes + + + harmonic content + + + fundamental level + + + the valves add to a signal that is already rich + + + + + + + + + diff --git a/book/src/images/ondes/envelope.svg b/book/src/images/ondes/envelope.svg new file mode 100644 index 0000000..7578172 --- /dev/null +++ b/book/src/images/ondes/envelope.svg @@ -0,0 +1,636 @@ + + + + + + + + 2026-08-17T15:35:58.972125 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.5 + + + + + + + + + + + + + 1.0 + + + + + + + + + + + + + 1.5 + + + + + + + + + + + + + 2.0 + + + + cycles of the note + + + + + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.5 + + + + + + + + + + + + + 1.0 + + + + + + + + + + + + + 1.5 + + + + + + + + + + + + + 2.0 + + + + envelope + + + + + + + + + + + + + + + + depth 1 (equal oscillators) + + + depth 0.5 + + + the envelope of two summed oscillators + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 3 + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 5 + + + + + + + + + + + + + 6 + + + + harmonic + + + + + + + + + + + + + + −30 + + + + + + + + + + + + + −20 + + + + + + + + + + + + + −10 + + + + + + + + + + + + + 0 + + + + dB below the fundamental + + + + + + + + + + -14.0 + + + -21.3 + + + -26.4 + + + -30.4 + + + -33.6 + + + |cos| is not a sinusoid — before any valve + + + + + + + + + + + + diff --git a/book/src/images/ondes/tube.svg b/book/src/images/ondes/tube.svg new file mode 100644 index 0000000..ab54ef6 --- /dev/null +++ b/book/src/images/ondes/tube.svg @@ -0,0 +1,723 @@ + + + + + + + + 2026-08-17T15:35:59.193439 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 50 + + + + + + + + + + + + + 100 + + + + + + + + + + + + + 150 + + + + + + + + + + + + + 200 + + + + + + + + + + + + + 250 + + + + plate volts + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 6 + + + + + + + + + + + + + 8 + + + + + + + + + + + + + 10 + + + + + + + + + + + + + 12 + + + + + + + + + + + + + 14 + + + + plate current (mA) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Vg 0 + + + Vg -2 + + + Vg -4 + + + Vg -8 + + + quiescent + + + 6C5 at the demodulator's point (100 V, 4k) + + + + + + + + + + + + + + + + + + −10 + + + + + + + + + + + + + −5 + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 5 + + + + + + + + + + + + + 10 + + + + grid volts around the bias point + + + + + + + + + + + + + + −60 + + + + + + + + + + + + + −40 + + + + + + + + + + + + + −20 + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 20 + + + + plate swing (V) + + + + + + + + + + + + + + + + + + + 6C5, demodulator + + + 6C5, preamplifier + + + 2A3, power amp + + + the stage inverts, and it is not symmetric + + + + + + + + + + + + diff --git a/book/src/images/scrub/null.svg b/book/src/images/scrub/null.svg new file mode 100644 index 0000000..c092edb --- /dev/null +++ b/book/src/images/scrub/null.svg @@ -0,0 +1,922 @@ + + + + + + + + 2026-08-17T15:35:58.543744 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 190 + + + + + + + + + + + + + 195 + + + + + + + + + + + + + 200 + + + + + + + + + + + + + 205 + + + + + + + + + + + + + 210 + + + + time (ms) + + + + + + + + + + + + + + + + + −0.2 + + + + + + + + + + + + + −0.1 + + + + + + + + + + + + + 0.0 + + + + + + + + + + + + + 0.1 + + + + + + + + + + + + + 0.2 + + + + + + + + + + + + + + + + + input, 480 samples late + + + the scrub + + + held still at unity pitch: worst error 3.3e-16 + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 5 + + + + + + + + + + + + + 10 + + + + + + + + + + + + + 15 + + + + + + + + + + + + + 20 + + + + + + + + + + + + + 25 + + + + time (ms) + + + + + + + + + + + + + + 0.00 + + + + + + + + + + + + + 0.25 + + + + + + + + + + + + + 0.50 + + + + + + + + + + + + + 0.75 + + + + + + + + + + + + + 1.00 + + + + + + + + + + + + + 1.25 + + + + gain on a constant + + + + + + + + + + + + + + + + + + + overlap 1 + + + overlap 2 + + + overlap 4 + + + Hann overlap-adds flat from 2 up + + + + + + + + + + + + diff --git a/book/src/images/scrub/two-hands.svg b/book/src/images/scrub/two-hands.svg new file mode 100644 index 0000000..429625f --- /dev/null +++ b/book/src/images/scrub/two-hands.svg @@ -0,0 +1,335 @@ + + + + + + + + 2026-08-17T15:35:58.836234 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + −10 + + + + + + + + + + + + + −5 + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 5 + + + + + + + + + + + + + 10 + + + + + + + + + + + + + 15 + + + + + + + + + + + + + 20 + + + + pitch (semitones), position held at 900 ms + + + + + + + + + + + + + + + + + 0.6 + + + + + + + + + + + + + 0.7 + + + + + + + + + + + + + 0.8 + + + + + + + + + + + + + 0.9 + + + + + + + + + + + + + 1.0 + + + + fraction of a clean shifter + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + energy at the transposed pitch + + + how concentrated it is on one line + + + the pitch moves; what the wraps cost is focus, not the note + + + + + + + + + diff --git a/book/src/images/touche/curve.svg b/book/src/images/touche/curve.svg new file mode 100644 index 0000000..32484f1 --- /dev/null +++ b/book/src/images/touche/curve.svg @@ -0,0 +1,337 @@ + + + + + + + + 2026-08-17T15:36:00.078220 + image/svg+xml + + + Matplotlib v3.11.1, https://matplotlib.org/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + 2 + + + + + + + + + + + + + 4 + + + + + + + + + + + + + 6 + + + + + + + + + + + + + 8 + + + + key displacement (mm) + + + + + + + + + + + + + + + + + −50 + + + + + + + + + + + + + −40 + + + + + + + + + + + + + −30 + + + + + + + + + + + + + −20 + + + + + + + + + + + + + −10 + + + + + + + + + + + + + 0 + + + + gain (dB, referenced to full press) + + + + + + + + + + + + + + + + silent: + the key is + still bending + + + Quartier et al. 2015 + + + a straight line, for comparison + + + 50 dB in 4.5 mm — and the shape is the measurement, not a fit + + + + + + + + + + + + + + + + + + + + + + + diff --git a/book/src/introduction.md b/book/src/introduction.md index 4789c6d..caca28f 100644 --- a/book/src/introduction.md +++ b/book/src/introduction.md @@ -35,8 +35,11 @@ The book is organized the way a patch is: (`tap.garden~`), and the components they decompose into. - **Part V — The machines you ride**: the Radiohead family — objects whose point is the performance surface rather than a setting. The multi-head tape - echo (`tap.tapecho~`), the live buffer-stutter rig (`tap.stammer~`), and the - two-stage fuzz (`tap.fuzz~`). + echo (`tap.tapecho~`), the live buffer-stutter rig (`tap.stammer~`), the + two-stage fuzz (`tap.fuzz~`), the granular scrub pad (`tap.scrub~`), the two + Ondes Martenot diffuseurs as standalone driven resonators + (`tap.metallique~`, `tap.palme~`), and the Ondes Martenot voice itself + (`tap.ondes~`, with `tap.triode~` and `tap.touche~`). - **Part VI — The spectral set**: the 24-band vocoder (`tap.vocoder~`), the per-bin spectral gate (`tap.nr~`), and the bin remapper (`tap.spectra~`). - **Part VII — The rhythm section**: the Roland recreations — the TB-303 voice, diff --git a/book/src/machine/diffuseur.md b/book/src/machine/diffuseur.md new file mode 100644 index 0000000..5a43fc9 --- /dev/null +++ b/book/src/machine/diffuseur.md @@ -0,0 +1,134 @@ +# Driven, not struck: `diffuseur.h` + +This file exists because a plan was wrong in a useful way. The Ondes family +plan said the diffuseurs would inherit `garden.h`'s modal machinery, and +they do — mode ratios, doublet splitting, per-mode decay. What it did not +say, and what reshaped the file, is that a diffuseur is **driven**. There is +no trigger here and no `decay_env`. The input excites the body continuously +and the body rings at its own rates, which is `grm_comb.h`'s situation +rather than the chime's. + +Five classes: `mode`, `plate`, `sympathetic`, `harp`, `transducer`, and two +cabinets over a shared `cabinet` base. Nothing else. + +## Unit peak gain, and everything it saves + +`mode` is the constant-peak-gain two-pole resonator (Steiglitz; Smith, +*Introduction to Digital Filters*): poles at radius R, zeros at ±1, and +`b0 = (1 − R²)/2`. + +That choice pays three times, and it is worth spelling out because it is the +reason this file has almost no defensive code in it. + +- **Peak gain is 1 at any Q.** So a bank of weighted modes is bounded by the + sum of its weights. The plate's eight weights sum to exactly 1, which + means the body cannot output more than its input, and there is no limiter + anywhere in the file. +- **Changing `decay` does not change the level.** With a plain two-pole + resonator, moving R moves the peak gain, so a decay knob is also a volume + knob. Here it is not. +- **The zeros at ±1 are exact nulls at DC and Nyquist.** So there is no DC + blocker on the body either. It cannot accumulate one. + +None of that is novel — it is a textbook resonator used for the reason the +textbook gives — but the cumulative effect on a file that runs sixteen of +them plus twelve delay loops is large. + +## The order is the argument, and it is a bitwise test + +The instrument's signal reaches the transducer first, and the transducer's +motion excites the body. So the nonlinearity is **upstream** of the +resonator. + +That is the central design claim of the file, so it is pinned rather than +described: a scenario builds `transducer → plate` by hand and checks that a +whole `metallique` is **bitwise identical** to it, and that the reverse +wiring — resonate, then distort — differs by 28 % of peak. + +Getting that null to be actually bitwise took one fix. `cabinet::blend` is +an equal-power crossfade written with `cos`/`sin`, and `cos(π/2)` in double +precision is 6.1e-17, not 0. A wiring test that reads 6.1e-17 has not +demonstrated identity; it has demonstrated *approximate* identity, which is +the thing the test exists to distinguish from. Both ends of the blend are +now exact short-circuits: mix 0 returns the dry input bit for bit, mix 100 +returns the wet. + +## The transducer's bound is 2/saturation, not 1/saturation + +The moving-iron model squares the drive, and `vca::swing_shape` bounds the +result at `1/saturation`. The obvious test — output stays under +`1/saturation` — failed at 1.49 against a bound of 1.25. + +The test was wrong, not the code. A hard-driven squared law produces a +nearly-constant *positive* waveform: it sits up near the ceiling and dips +toward zero. Removing its DC recentres that, so the excursion below the mean +adds to the excursion above it, and the worst-case swing after the DC +blocker is up to **twice** the saturator's own bound. + +The corrected bound is `2/saturation`, documented in the header, and the +scenario now asserts both sides of it — greater than `1/sat`, less than +`2/sat` — so the test still catches the saturator disappearing entirely. + +The general shape of this mistake is common enough to name: **a DC blocker +after an asymmetric nonlinearity is not free.** It does not just remove an +offset; it converts an offset into headroom you have to have. + +## A measurement that measured its own edges + +The palme's selectivity scenario drives the board with a tone and measures +what is still ringing after the tone stops. First version: switch the tone +on, switch it off, measure the tail. It failed — 3.66× selectivity against +the 4× asserted — and the failure was real but not about the strings. + +Switching a tone on and off is a step, and a step is broadband. It excites +every string on the board, so the tail contained twelve strings ringing +regardless of what frequency had been played. The measurement was reading +its own edges. + +Fading the drive in and out over 250 ms removes the step. Every one of the +twelve strings then passes, with the worst at 4.4×. The same fade is what +the book figure uses, and the figure's caption says so, because a reader +reproducing it without the fade will get the wrong answer. + +## Twelve strings + +Widely copied hobbyist build pages describe the palme as two banks of twelve +strings. The peer-reviewed source (Wijnand, Boutin, Jossic & Maniguet, Forum +Acusticum 2023) says twelve, and `k_strings = 12` with a comment saying +which source won and why. + +Their tuning is not published anywhere found, so it is a parameter rather +than a constant, and the header says that too. Guessing a tuning and +hard-coding it would have been the same category of error as the +twenty-four. + +## Where recreation begins + +The instruments, their dates, their excitation and their transducer type are +peer-reviewed. The modal data is not — no ondes-specific measurement of +either body exists in any of the four sources read — so the plate uses +Fletcher & Rossing's free circular plate (Rayleigh's Chladni ratios at +Poisson 0.3) and the strings use the harmonic series. + +This is stated in the header at the top rather than in a limits section at +the bottom, because it changes what the object *is*: a recreation of the +general physics, not a model of Martenot's instruments. The same applies to +`asymmetry` and `saturation` — the source establishes that the moving-iron +driver is nonlinear and that Thiele–Small does not describe it, and then +does not hand over a curve. Those two coefficients are voiced by ear and +labelled as voiced by ear. + +A diffuseur with both at 0 is a linear resonator and is missing a real +stage. That is a choice the caller may make, and the header says so rather +than forcing a minimum. + +## Checkpoint + +A textbook resonator chosen for three properties that between them remove +the limiter, the DC blocker and the decay/level coupling. A bitwise null +that pins the transducer upstream of the body, which required making an +equal-power blend exact at its endpoints. A saturator bound corrected from +`1/sat` to `2/sat` because a DC blocker after an asymmetric nonlinearity +buys headroom, not just centring. A selectivity test that had to stop +measuring its own on/off step. And a provenance line drawn where the +published sources actually stop. diff --git a/book/src/machine/ondes.md b/book/src/machine/ondes.md new file mode 100644 index 0000000..3dc36fa --- /dev/null +++ b/book/src/machine/ondes.md @@ -0,0 +1,202 @@ +# A citation, an identity, and a sign: `ondes.h` + +Three classes — `triode`, `detector`, `voice` — and three things worth +recording about how they got here. One stage turned out to need no design +decisions at all. One approximation turned out to be an exact identity. And +one sign error made a distortion knob run backwards. + +The circuit is Najnudel, Hélie, Roze & Boutin, "Simulation of an ondes +Martenot circuit", IEEE/ACM TASLP **28**, 2651–2660, 2020, modelling +instrument No. 169 as five port-Hamiltonian stages. This file is **not** +that: their full solve runs at 768 kHz and their plugin costs 85 % of a +laptop core. What it takes from them is their own published reductions plus +their published component values, and the header says which is which. + +## The tube is a citation, not a design + +The plan framed the valve stage as a choice: a published grid-conduction +curve, or the tanh family with an asymmetry bias voiced by ear. It is +neither, and finding that out took nothing more than reading the paper +properly. + +The paper names a tube model — the **enhanced Norman Koren** model (Koren, +*Glass Audio* 8(5), 1996, with Cohen & Hélie's grid-current branch, AES 129, +2010) — writes out its three equations, and publishes parameter sets in +Table II **fitted to the actual valves in ondes No. 169**, together with +each stage's supply voltage, cathode resistor and plate load. + +So there was nothing to voice. `k_6f5`, `k_6c5`, `k_2a3`, `k_op_demod`, +`k_op_preamp` and `k_op_power` are Table II transcribed, and the header says +they are the citation. + +A stage is then the static solution of `ipc(vpc, vgc) = (Vbias − Vk − +vpc)/Rp` on the load line, with cathode bias `Vk = Rk·Ipc` found at the +quiescent point. That is a **memoryless nonlinearity** in exactly the +DAFx-07 sense, which matters for a practical reason: tabulating it is not an +approximation of the model, it *is* the model. The table is rebuilt on a +tube or operating-point change and read with linear interpolation, so the +audio path costs a lookup rather than a root find. + +The published points bias sanely — the 6C5 demodulator lands at Vk 2.70 V, +Vp 86.5 V, Ip 2.70 mA, gain 4.86 — which is its own small confirmation that +the transcription is right. + +## The sign that made the drive knob run backwards + +The stage must **invert**, as a real common-cathode stage does, and this is +load-bearing rather than cosmetic. The valve's asymmetry acts on whichever +side of the waveform reaches its grid. An early cut normalized the output by +the *signed* small-signal gain, which quietly un-inverted the stage, so the +curve's lopsidedness landed on the wrong half of the waveform. + +The symptom was unambiguous once measured: turning `drive` **up** reduced +total harmonic content. A distortion control that gets cleaner as you push +it is not a subtle bug, but it is only visible in a sweep — at any single +setting the object sounded like a valve. + +Two changes fixed it. The curve is now the true (inverting) plate swing, and +normalization is by the gain's *magnitude*. And `voice::core` applies the +demodulator's own grid-leak inversion explicitly — a growing envelope drives +that grid toward cutoff — so the two inversions put the demodulator's plate +in phase with the envelope while the curve has meanwhile acted on the +underside. `drive` now sweeps harmonic content 0.221 → 0.344, monotonically. + +The gain-staging lesson from `fuzz.h` was applied here from the start rather +than learned again: each stage is normalized by its own small-signal gain, +so drive changes the distortion and not the level. + +## The detector is an identity, not a simplification + +The plan's instruction for this stage was "synthesize the difference tone +directly as a sinusoid", and catching that as a mistake is the most valuable +thing this build did. + +The paper's 0.03 % distortion figure and its licence to replace oscillators +with a sinewave generator apply to the **oscillators**. The demodulator is +not a mixer handing you a difference tone; it is an envelope detector, and +the envelope of `cos(Φ) + cos(Φ − φ)` is `2|cos(φ/2)|`, whose Fourier series +puts H2 at −14.0 dB, H3 at −21.3 dB and H4 at −26.4 dB. Synthesizing a +sinusoid would have discarded the instrument's largest single source of +harmonics before any of the modelled stages ran. + +What replaces the carrier is better than a simplification. For amplitudes 1 +and `depth`, the envelope is exactly + +``` +sqrt(1 + depth² + 2·depth·cos(2π f t)) +``` + +so the 80 kHz carrier drops out of the arithmetic rather than being +approximated away. Running the published RC detector on that closed form — +instant attack through the diode, 200 µs decay through R4·C21 — reproduces a +full heterodyne-plus-diode-plus-RC simulation to **within 0.10 dB on every +harmonic** at every pitch tried (`ondes.ipynb` §2). + +There is one systematic difference, and it is worth knowing it is systematic +rather than noise: the closed form sits a uniform **3.0–3.2 % high**, +because a follower chasing real carrier half-cycles never quite reaches the +peak between them. On a synthesizer with a level control, that is a +constant. + +The detector's characteristic pitch dependence comes along free, out of the +same 200 µs: H2 runs −14.0 dB at A2 to −19.3 dB at A6, and the level falls +2.0 dB across those five octaves. + +And a bonus nobody planned: because the closed form is parameterized by the +two oscillator amplitudes, **oscillator balance becomes a physical timbre +control**. `depth` is a real mismatch between two real oscillators, not an +invented knob. + +## Three measurements that lied, and what they were doing + +All three were committed to a notebook or a header before being caught. + +**Too few periods.** The first measurement of the detector's harmonics at +low pitch used a window holding about 2.75 periods of the fundamental. +Spectral leakage at that resolution dominated everything, and it produced a +confident, wrong claim in the header: "−9.8 dB at A2, level falls 9.7 dB". +Redone with 60 cycles, the real answer is −14.0 dB and 2.0 dB. Both numbers +were in a shipped header before the recheck. + +**Probing where the answer is exactly zero.** The aliasing scenario probed +half-integer harmonics of a tone that was exactly periodic in the analysis +window. Those bins are analytically zero, so it measured −281 dB and passed +triumphantly. Fixed by computing the actual fold frequencies for a tone at +2637 Hz — deliberately not a submultiple of 48 kHz — and skipping folds that +land near real harmonics. This is the same family of error `fuzz.h` records +under "choosing a tone that divides the sample rate", committed again in a +different disguise. + +**Stopping the sweep at the first plateau.** The header initially claimed +"4× is the knee, then flat". The notebook's own more careful run — settled +state, 131072-point Hann — showed 8× continuing to improve in the top +octave. Corrected to "never worse", with the full table in the header, the +test comment and the notebook. + +## Evidence for an open question in `fuzz.h` + +`fuzz.h` measured its oversampling sequence going the wrong way — 4× worse +than 2× — and left an untested hypothesis behind: that the culprit is +*imaging*, since zero-stuffing by N leaves N−1 images for one filter to +suppress, and residual images entering a nonlinearity intermodulate into +products that are not harmonics of the input. + +This file runs the **same** 8th-order Butterworth chain around a comparably +hard nonlinearity, and its sequence never reverses: + +| tone | 1× | 2× | 4× | 8× | +|------|----|----|----|----| +| 587 Hz | −79.3 | −91.2 | −104.5 | −103.8 | +| 1175 Hz | −65.8 | −77.2 | −90.6 | −92.5 | +| 1760 Hz | −57.6 | −70.9 | −81.1 | −82.2 | +| 2637 Hz | −51.1 | −61.4 | −71.8 | −83.8 | +| 3520 Hz | −45.4 | −56.8 | −67.0 | −74.2 | + +The difference between the two files is exactly the hypothesis: this object +is a **source**. Nothing is zero-stuffed on the way up — the detector simply +runs fast — so there are no images at all. + +That is evidence, not proof. The nonlinearities differ too, and one +confounded comparison does not settle a question. But it is the first +evidence either way and it points the same direction, and both headers now +record it as such. + +## A wrapper test that found a kernel bug + +`tap.ondes~`'s Min-level test asserts something a patcher would otherwise +file as a bug report: with the key at rest, the object is *exactly* silent. +It failed. + +`voice::set_smooth_ms` set the voice's own ramps but never forwarded to +`touche::key`, which keeps its own slew. So a key sitting at zero with +`@smooth 0` still sounded for 20 ms after every parameter touch. + +This is the two-layer split working the way it is supposed to. The kernel +suite tests DSP promises; the wrapper suite tests what a patcher will +actually observe, and those are not the same set. The fix landed in the +kernel with its own scenario, not in the wrapper. + +## What this file will not do + +The real instrument has switchable **waveform registers**. Their filter +shapes are in none of the sources obtained. Adding them from imagination is +the one thing this file is careful not to do, and the omission is stated in +the header, the object description and the reference page rather than left +as a gap someone might charitably fill later. + +Two controls *are* choices — where the intensity key sits (`keyplacement`) +and the coupling transformer's winding sense (`polarity`) — because the +paper's five stages do not settle either. Both are labelled as choices, and +both were measured to confirm they are audible ones: about 0.09 and 0.12 of +total harmonic content respectively. + +## Checkpoint + +A stage that required no design because the paper published the model and +its fitted parameters. A detector that is exact rather than approximate, and +cheaper than the thing it replaces. One sign error that inverted the meaning +of a distortion knob and was invisible at any single setting. Three +measurements that lied in three different ways, all recorded. Evidence for +`fuzz.h`'s open oversampler question from a file that happens to differ in +exactly the right variable. And a wrapper test that found a kernel bug, +which is the split doing its job. diff --git a/book/src/machine/scrub.md b/book/src/machine/scrub.md new file mode 100644 index 0000000..b2af664 --- /dev/null +++ b/book/src/machine/scrub.md @@ -0,0 +1,139 @@ +# One tape, two read patterns: `scrub.h` + +When `stammer.h` shipped, its header made a promise in its own limits +section: slices play at ±1 rate, a performable pitch-bending playhead over +live capture is a different object, and *sharing this capture is the plan*. +This file is that promise being kept, and it is worth recording that the +sharing turned out to be literal. `scrub.h` includes `stammer.h` and uses +`stammer::capture` itself — one `tape_loop.h` reel under an advancing write +head — rather than keeping a second copy of the same idea. + +The only thing the stutter had to grow was `capture::read_frac`, a +fractional Hermite read. Its ±1-rate slices never needed one. + +The rest of the file is two classes: `head`, the grain scheduler, which owns +the grain pool, the hop clock and the spray dice and reads a capture it does +not own; and `machine`, which is one capture, one head, the freeze gate, the +drift and the balance. Same parts-then-composition habit as `tapecho.h` and +`stammer.h`, for the same reason: `head` is a read pattern, not a machine, +so it is testable and composable without being an external. + +## The defect that measurement caught and nothing else could + +The first cut anchored every grain at the position. That is the obvious +thing to do — the position is where the user is pointing — and it is wrong +in a way that is genuinely hard to hear. + +Here is the mechanism. If every grain's origin is `write_head − lag`, then +origins advance at the *write head's* speed, which is exactly 1. Each grain +then plays from its origin at `rate`. Inside a grain the pitch is correct. +Across grains the average read rate comes back to 1, because the origins +reset it every hop. + +So a steady tone comes out **at its original pitch**, with a comb of +grain-rate sidebands around it. The pitch knob did not transpose. It added +texture, and texture is what you expect from a granulator, which is exactly +why no amount of listening was going to find this. + +The fix is a phase-continuous read head: the origin advances at `rate`, and +is pulled back toward the position only once it has wandered more than +±1.5 grains. Every pull-back is a splice, which is the cost, and the bound +is chosen by sweep rather than taste. Band energy retained around the +transposed pitch, at wanders of ±0.5 / ±1 / ±2 / ±3 / ±4 grains: + +| wander (grains) | mean | worst | +|-----------------|------|-------| +| ±0.5 | 0.933 | 0.716 | +| ±1 | 0.958 | 0.820 | +| ±2 | 0.965 | 0.874 | +| ±3 | 0.990 | 0.918 | +| ±4 | 0.993 | 0.940 | + +Flat past 3, and every extra grain of wander is a grain of position error, +so `k_wander_grains = 3.0`. + +The unity case is special-cased to zero error rather than accumulated, +which is what keeps the null exact: at `rate == 1` there is nothing to +wander from. + +## Measure the band, not the bin + +This is the second thing worth carrying out of this file, and it nearly +inverted the conclusion above. + +A single-bin probe reads the *fixed* kernel as badly broken. The splices +spread the transposed partial into a comb a few hertz wide; a +rectangular-window Goertzel sitting on one line saw **0.02** where the band +figure was **0.43**. Had that been the first measurement taken, the fix +would have looked like the bug. + +Measured properly — energy in a ±15 Hz band around the transposed pitch, +against the same band of a perfect shifter — 98.8 % lands where it should, +worst case 91.7 %. What the splices cost is concentration, not pitch: +92.0 % as focused as a clean shift, 75.0 % at worst. + +The general rule, stated for the next time someone here measures a +pitch-shifter: **if the process can smear a partial, a single-bin probe is +measuring the smear, not the partial.** Integrate a band wide enough to +contain the artifact you already know about. + +Two related mistakes are recorded here because both were committed: + +- **Analysing mostly silence.** The first wander sweep ran 1 second of + material with a 900 ms position lag, so most of the analysed window was + tape that had not been written yet. Extended to 3 seconds, analysing the + last third. +- **Feeding a discontinuity into the test.** A slew test drove the object + with a sine and then, mid-test, called `process(0.5)` with a literal DC + sample to change a parameter. That step was an input transient, and the + 0.48 jump it produced was the test's own fault. Continuous tone index, + and the same bug was then fixed pre-emptively in `diffuseur_test.cpp`. + +## The null, and the arithmetic that makes it exact + +Hann satisfies constant-overlap-add at hop = size/overlap, so the window sum +is exactly 1 at overlap 2 and above, and normalization is `2/overlap` so the +level holds across settings. With pitch at unity, spray at zero and the +position on a whole sample, the object is the input delayed to 4.4e-16. + +It is exact only when `size` divides evenly by `overlap`, because the hop is +an integer number of samples; otherwise a small periodic ripple survives in +the window sum. It is inaudible at musical sizes, and it is why the null +test chooses the numbers it does (480 samples of lag, 96 of size) rather +than round milliseconds. + +The `mix` control needed the same care as the diffuseurs' — an equal-power +blend written as `cos`/`sin` does not return exactly zero at the endpoint, +and a wiring null that reads 6.1e-17 instead of 0 is not a null. Both ends +are short-circuited exactly. + +## The grain pool starves rather than steals + +Shrinking `size` sharply while grains are in flight can leave every slot +busy at the moment the next grain is due. That grain is **dropped**, not +allocated by stealing a slot from a grain mid-window, because a steal cuts a +Hann window in half and clicks. The audible cost is a momentary dip, bounded +by the pool being two slots deeper than the maximum overlap. + +## A limit that is not fixed, on purpose + +A grain born `lag` samples behind the write head and playing at rate `r` +reaches `lag − size·(r−1)` behind it by its end. Transpose up with the +position near the live edge and the grain's tail runs off the front of the +tape into the oldest material. + +Nothing clamps this. Clamping would silently bend the pitch to keep the +grain in bounds, which is a worse failure than the seam — the object would +stop playing the interval you asked for and never say so. The constraint is +documented (`keep the position at least size·(rate−1) back`) and left to the +player. + +## Checkpoint + +One capture, shared literally with the stutter, plus one fractional read +that the stutter did not need. A phase-continuous read head, because +anchoring grains at the position quietly cancels the transposition — the +defect of this file, invisible to listening and obvious to a sweep. A wander +bound measured rather than chosen. And a measurement lesson worth more than +the kernel: a single-bin probe on a smeared partial reads the fix as the +bug. diff --git a/book/src/ondes.md b/book/src/ondes.md new file mode 100644 index 0000000..2d1c612 --- /dev/null +++ b/book/src/ondes.md @@ -0,0 +1,257 @@ +# The instrument that is not a synthesizer + +Three objects in this chapter — `tap.ondes~`, `tap.triode~` and +`tap.touche~` — and one instrument. The Ondes Martenot, 1928, the thing +Messiaen wrote for and Jonny Greenwood plays: a keyboard you can also play +with a ribbon on a ring, and a pressure key in the left hand that is the +whole dynamic range of the instrument. + +The plan for this family assumed it would be an oscillator with waveform +switches. It is nothing of the kind, and finding that out changed every +decision below. + +The Ondes Martenot is **heterodyne**. Two oscillators run near 80 kHz, one +fixed and one moved by the ribbon; they are summed, and the note you hear is +the envelope of their beating. Najnudel, Hélie, Roze and Boutin, who +modelled instrument No. 169 stage by stage (IEEE/ACM TASLP 28, 2651–2660, +2020), measure those oscillators at about **0.03 % second harmonic** even +coupled to the rest of the circuit. They are essentially pure sinewaves. +Every bit of the instrument's character therefore comes from what happens +*after* them: the demodulator, two valve stages, the intensity key, and the +diffuseur. + +Companion material: the executed notebooks `ondes.ipynb` and `touche.ipynb`, +`tests/ondes_test.cpp` and `tests/touche_test.cpp`, and the +`radiohead_render` scenes `ondes_stages`, `ondes_ribbon`, `ondes_diffuseurs` +and `triode_tubes`. + +## The biggest source of harmonics is not a valve + +Two oscillators of equal amplitude sum to an envelope of `2|cos|`. That is +not a sinusoid. Its Fourier series puts the second harmonic **14.0 dB** +below the fundamental, the third **21.3 dB** down and the fourth **26.4 dB** +down — a substantial harmonic series generated before anything nonlinear +touches the signal. + +![Two panels: the envelope of two summed oscillators at depths 1 and 0.5, and the harmonic levels of |cos| — −14, −21, −26, −30, −33 dB](images/ondes/envelope.svg) + +*The demodulator is the instrument's largest single source of harmonics, and it is upstream of every valve.* + +This is why `tap.ondes~` does not synthesize a difference tone. Generating +the note as a sinewave and distorting it afterwards would throw away the +part of the timbre that arrives for free — and it is an easy mistake to +make, because the circuit paper *does* say the oscillators can be replaced +by a sinewave generator. That licence applies to the **oscillators**, not to +the demodulator. + +The carrier is not simulated either, and that is not a compromise. For +amplitudes 1 and `depth` the envelope is exactly `sqrt(1 + depth² + +2·depth·cos φ)`, so the 80 kHz disappears from the arithmetic rather than +being approximated away. Running the published RC detector on that closed +form matches a full heterodyne-plus-diode-plus-RC simulation to within +**0.10 dB on every harmonic** at every pitch tried. + +`depth` is that second amplitude, and it turns out to be the cheapest real +timbre control in the object. At 1 the envelope closes completely and the +series is full; below 1 it never closes and the tone thins toward a +sinusoid. It is a mismatch between two real oscillators, not an invented +knob. + +## `detect` — and why the instrument thins as it climbs + +The detector is the published one: a triode grid near zero bias conducts on +positive half-cycles and charges instantly, and R4 × C21 = 1 MΩ × 200 pF +discharges it — a **200 µs** time constant, which is `@detect 0.2`. + +That single number carries the instrument's pitch character, because an RC +that slow cannot follow a fast envelope back down. Measured here, the second +harmonic runs from −14.0 dB at A2 to −19.3 dB at A6, and the level falls +2.0 dB across those five octaves. The ondes gets purer and quieter as it +goes up, and it does so for a reason you can point at in a schematic. + +## The ribbon is linear in semitones + +The circuit paper's Eq. 7 gives the variable oscillator's capacitance +against ribbon displacement, and what falls out is +`f = 55 Hz · 2^(d / 12·d₀)`. + +So `@ribbon` is **semitones above A1**, not Hz. A hand moving at constant +speed makes a constant-rate glissando; nothing quantizes, and nothing +should. This is why an ondes glide sounds the way it does, and it is the one +place where taking the units from the paper rather than from convention +changes how the object feels to play. + +## `tap.touche~` — 50 dB in four and a half millimetres + +The intensity key is a graphite-and-mica powder bag working as a rheostat: +compress it and the number of conducting bead paths rises, so resistance +falls. Messiaen called it the instrument's greatest invention. What the +player feels is a well-chosen nonlinear spring. + +The curve in this object is **not modelled and not fitted**. Quartier, +Meurisse, Colmars, Frelat and Vaiedelich (*Acta Acustica* 101(2), 421–428, +2015) measured finger force, key displacement and sound simultaneously on +instrument No. 320, and published the boundaries of the six musical nuances +across the key's travel. Those seven points are the object, interpolated +with monotone cubic segments that pass through every one of them. + +![The published key curve: 50 dB rising steeply between 4.3 and 8.8 mm, seven measured points on it, a straight line for comparison, and the bottom 4.3 mm shaded silent](images/touche/curve.svg) + +*Seven measured points, and the shape between them. The straight line is what a fit would have thrown away.* + +Three things follow, and each is a decision the paper made rather than this +object: + +- **Position, not force and not velocity.** The paper states explicitly that + the intensity depends on displacement, and *not* on the speed of the + gesture. A static memoryless map is the finding, not a simplification. +- **50 dB over about 4.5 mm**, from 4.3 mm (the instrument's noise floor) to + 8.8 mm. The paper notes most traditional instruments rarely exceed 25 dB + of per-note dynamic range. +- **The shape is not a line.** Equal 8.3 dB steps take displacement steps of + 1.0, 0.6, 0.5, 0.4, 0.5 and 1.5 mm. It steepens through the middle and + flattens hard at the top. + +And the thing that surprises everyone who patches it: on a 0–1 control, +**roughly the bottom 45 % of the travel is silent**. That is not a dead zone +in the object. It is the key's own first phase — the elastic strip bending +before it reaches the powder bag — and it is exactly why the instrument can +be attacked so sharply, because the useful 50 dB lives in the 4.5 mm right +after it. + +## `tap.triode~` — the stage is a citation + +The valves are where the rest of the character is, and there was nothing to +invent. The circuit paper does not merely mention a tube model: it names the +**enhanced Norman Koren** model (Koren, *Glass Audio* 8(5), 1996, with Cohen +& Hélie's grid-current extension, AES 129, 2010), writes out its equations, +and publishes parameter sets **fitted to the actual valves in ondes No. 169** +in its Table II — 6F5 in the oscillators, 6C5 in the demodulator and +preamplifier, 2A3 in the power amplifier — along with each stage's supply +voltage, cathode resistor and plate load. + +A stage is then the static solution of the load line, which is a memoryless +nonlinearity in exactly the DAFx-07 sense `tap.fuzz~` uses. Where the fuzz +reaches for a tanh, this one solves a valve. + +![Two panels: the 6C5's plate characteristics with its load line and quiescent point marked, and the transfer curves of the three published stages, all sloping downward](images/ondes/tube.svg) + +*Left: the published operating point, solved. Right: the stages invert, and they are visibly lopsided.* + +Two properties matter before you patch `tap.triode~` on its own: + +- **It inverts**, as a real common-cathode stage does. That is not cosmetic. + The valve's asymmetry acts on whichever side of the waveform reaches its + grid, so the sign decides which half gets bent. +- **It is strongly asymmetric.** At the demodulator's operating point, equal + grid swings either way give plate swings in a **2.17 : 1** ratio. That + ratio is where a triode's even harmonics come from. + +`drive` is normalized out of the level — the gain-staging lesson `tap.fuzz~` +learned the hard way, applied here from the start — so turning it up gets +dirtier rather than louder. + +## `drive` on the voice, and where it starts from + +![Harmonic content rising from 0.221 to 0.344 as drive sweeps 0 to 8, with the demodulator's own floor marked, while the fundamental level falls gently](images/ondes/drive.svg) + +*The valves add to a signal that was already rich. The floor is the demodulator's.* + +The important thing in that figure is the dotted line. At `@drive 0.` the +tone still measures 0.221 of harmonic content, because the demodulator made +it. The knob sweeps 0.221 → 0.344, monotonically, without the level running +away. + +## The two controls that are choices + +Most of this object is a citation. Two controls are not, and both are +labelled as such because both measure as audible. + +- **`keyplacement`** — the paper's five stages do not include the intensity + key, so where it sits is undetermined. After the valves (the default) it + is a clean output law: pressure is level. Before them, pressure drives the + valves: soft is clean and hard is dirty. The two differ by about 0.09 of + total harmonic content at a half-press. +- **`polarity`** — the two valve stages are coupled through a transformer + whose winding sense is not in the source, and the sign decides which side + of the waveform the preamplifier's asymmetry acts on. Worth about 0.12. + +## `power`, and taking the authors at their word + +The 2A3 power stage is off by default, following the paper: they measure +almost 5 % second harmonic there, but report its contribution as much less +important than the two stages before it, and drop it for real-time. + +Measured here, switching it on moves total harmonic content from 0.248 to +0.251 and the second harmonic by 0.1 dB. They were right, which is why it is +a switch rather than a deletion. + +## `oversample` + +The nonlinear chain runs oversampled. Worst non-harmonic energy relative to +the fundamental, at 1× / 2× / 4× / 8×: + +| tone | 1× | 2× | 4× | 8× | +|------|----|----|----|----| +| 587 Hz | −79.3 | −91.2 | −104.5 | −103.8 | +| 1175 Hz | −65.8 | −77.2 | −90.6 | −92.5 | +| 1760 Hz | −57.6 | −70.9 | −81.1 | −82.2 | +| 2637 Hz | −51.1 | −61.4 | −71.8 | −83.8 | +| 3520 Hz | −45.4 | −56.8 | −67.0 | −74.2 | + +Every doubling is worth about 12 dB up to 4×; past that it is worth 7–12 dB +at the top of the range and nothing at the bottom, where the measurement has +already bottomed out. Never worse. 4× is the default because that is where +the cost stops buying uniformly; 8× is there for anyone playing the top +octave hard. + +Readers of the `tap.fuzz~` chapter will notice this is the *opposite* of +what that object measured. That is not a contradiction, and the appendix +explains why it is evidence. + +## What is missing, deliberately + +The real instrument has **waveform registers** — switchable timbres. Their +filter shapes are in none of the sources obtained, and inventing them is the +one thing this object will not do. + +There is also no diffuseur in `tap.ondes~`, because that is +`tap.metallique~` and `tap.palme~`, and patching one after the other is how +the instrument works anyway. + +## Recipes + +- **The instrument:** `tap.ondes~` → `tap.palme~ @mix 60`. Ribbon and key on + signals; that is the whole performance surface. +- **Ribbon on a slider:** `@ribbon` takes a signal, and a `line~` from 0 to + 36 over four seconds is a three-octave glissando that sounds like one + because the law is linear in semitones. +- **The key alone:** `tap.touche~` on any source. It is a published + expressive gain law, and nothing about it is ondes-specific once it is + detached. +- **Thin and pure:** `@depth 0.4 @detect 0.6 @drive 0.`. The envelope never + closes and the detector smooths what is left. +- **Dirty on hard presses:** `@keyplacement 1 @drive 4 @polarity -1`. + Pressure drives the valves. +- **A valve on a guitar:** `tap.triode~ @tube 2 @stage 2 @drive 6` — the 2A3 + power stage, used for something it was never in this instrument for. + +## When it is not the right tool + +- **A subtractive synth.** There is no filter, no envelope generator and no + waveform selection here. It is one voice with a ribbon and a key. +- **A polyphonic anything.** The instrument is monophonic; so is this. +- **A specific recording.** The valve parameters are a fit to *one* + instrument's tubes, and tube-to-tube spread in 1930s valves is wide. + +## Checkpoint + +A heterodyne instrument whose oscillators are nearly pure, so the character +lives downstream: a demodulator whose `2|cos|` envelope makes more harmonics +than either valve does, two valve stages that are a published model with +published parameters, and a pressure key that is a published measurement +interpolated rather than fitted. The ribbon is linear in semitones because +Eq. 7 says so. Two controls are choices rather than reconstructions and are +labelled as choices. The waveform registers are missing on purpose. Every +number here lives twice, as a cell in `ondes.ipynb` or `touche.ipynb` and as +a pinned scenario in `tests/ondes_test.cpp` or `tests/touche_test.cpp`. diff --git a/book/src/scrub.md b/book/src/scrub.md new file mode 100644 index 0000000..33fdb34 --- /dev/null +++ b/book/src/scrub.md @@ -0,0 +1,135 @@ +# Two hands on the same tape + +`tap.stammer~` and `tap.scrub~` record the same way. Both keep a rolling +tape of what just went past — the same `capture`, literally the same code, +not a second copy of it — and both put a read pattern on top of it. The +stutter's pattern is a slicer with dice. The scrub's is a pad you drag. + +That is the whole difference, and it is the difference between a machine +that decides and a machine you play. The stammer is a die you load; the +scrub is a surface you push around, in the Kaoss-pad school of instruments +where an XY surface over live capture is the entire interface. It belongs in +this part of the book for the same reason the tape echo does: nobody sets +this object up and walks away from it. + +It is an original design in the granular / brassage tradition (Roads, +*Microsound*, MIT Press 2001) — not a port, and not a reconstruction of any +product. No preset, timing or parameter value in it came from a piece of +hardware. + +Companion material: the executed notebook `scrub.ipynb`, the pinned +scenarios in `tests/scrub_test.cpp`, and the `radiohead_render` scenes +`scrub_gesture` and `scrub_freeze`. + +## The two axes are actually two axes + +`position` is how far back the playhead sits, as a lag in milliseconds +behind the live edge. `pitch` is transposition in semitones. On tape those +would be the same knob — moving the head *is* the pitch change — and the +whole point of doing this with grains is that here they are not. Hold the +position and sweep the pitch and the material transposes without going +anywhere. Sweep the position at a fixed pitch and you rake through the last +few seconds without the tape rising or falling. + +`drift` is the third one, and it is the playhead's own motion through the +tape in playback-rate units: `1.` runs forward at the speed the recorder is +writing, `0.` holds station, negative runs backwards. Set `@drift 1.` and +let go of the position and the scrub is a delay; set `@drift 0.` and it is a +freeze that you can still transpose. + +## The identity underneath it + +Grains are Hann-windowed and fired every `size / overlap` samples. Hann +overlap-adds to exactly 1 at that hop, so with the pitch at unity, `spray` +at zero and the position held on a whole sample, the scrub is *the input, +delayed*, to floating point — 4.4e-16 in the pinned test. + +![Two panels: the scrub's output lying exactly on top of the input delayed by 480 samples, and the window sum for overlaps 1, 2 and 4 — flat at 1 for 2 and 4, dipping to zero for 1](images/scrub/null.svg) + +*Left: held still at unity, the object is a delay and nothing else. Right: the window sum that makes it one.* + +This matters more than it sounds. Everything else the object does is a +*departure* from a plain delay, and a departure is only trustworthy if you +know the thing it departs from is exact. When the position drags, when the +pitch moves, when spray scatters the origins — those are the object working. +If the still case were approximate, you could not tell them apart from +noise. + +`overlap 1` leaves gaps between grains, which is the dipping curve in that +figure. That is a chopped, gated texture rather than a defect, and it is +worth having; it is just not the setting the null lives at. + +## What transposing costs, honestly + +Reading tape at a rate the write head does not share means the read pointer +drifts away from where the position says it is, and it has to be pulled back +or the position stops meaning anything. Every pull-back is a splice between +two grains reading material a little apart. + +What that costs is *not* the pitch. Swept over seven fundamentals and seven +intervals, 98.8 % of a perfect shifter's energy lands within ±15 Hz of the +transposed pitch — worst case 91.7 %. The note is where you asked for it. + +What it costs is concentration. The band holds a narrow comb rather than one +clean line: 92.0 % as concentrated as a clean shift, 75.0 % at its worst. + +![Two curves against pitch from −12 to +19 semitones: energy at the transposed pitch staying near 1, and concentration dipping to about 0.75](images/scrub/two-hands.svg) + +*The pitch goes where you put it. What the splices take is focus.* + +Audibly that is a warble, and it is the classic single-delay-line +pitch-shifting artifact rather than anything peculiar to this kernel. If you +want the warble gone, `spray` trades the comb for a broadband smear, which +some material prefers. If you want a clean shift, this is the wrong object — +see below. + +## `freeze`, and what it does not stop + +`freeze` stops the *recorder*. The playhead keeps going, so the position now +addresses fixed tape and the grains loop the same window: a granular hold +you can still scrub, transpose and drift through. It does not stop time +inside a grain — a grain in flight when freeze engages was already +scheduled, and it finishes. + +## `spray` and `seed` + +`spray` scatters each grain's origin randomly back from the position. At +exactly 0 the dice are never rolled, so the seed provably cannot matter — +the same contract `tap.garden~` and `tap.stammer~` carry, pinned by the same +kind of test. With spray up, the same seed and the same moves give the same +render bit for bit, and two instances decorrelate by seed alone. + +## Recipes + +- **The pad:** `@drift 0. @size 80 @overlap 2 @mix 100`, then ride + `position` with a signal. The default instrument. +- **Granular freeze:** `@freeze 1 @drift 0. @size 120 @spray 40`. Hold, then + move `pitch` for a chord that was never played. +- **Backwards tape:** `@drift -1. @pitch 0.` — the playhead walking against + the recorder. +- **Chopped:** `@overlap 1 @size 40`. Gaps between grains, on purpose. +- **Into the diffuseur:** `tap.scrub~` → `tap.palme~` with the palme's + `@mix` around 40. The strings sustain what the scrub chops. + +## When it is not the right tool + +- **Clean transposition.** The warble above is inherent to the method. + `tap.shift~` and `tap.pitchaccum~` are the objects built for that job — + with one caveat worth stating plainly: measured on this same sweep, + `tap.pitchaccum~` retained mean 0.908 of band energy with a **worst case + of 0.004**, well below the scrub's worst of 0.917. That is recorded as an + open question against `tap.pitchaccum~` rather than a recommendation + against it, but audition before you assume. +- **A tidy delay.** `tap.delay~` and `tap.tapecho~` cost far less and do not + window anything. +- **Slicing to a grid.** That is `tap.stammer~`, on the same tape. + +## Checkpoint + +One tape shared with the stutter, one grain scheduler on top of it, and two +axes that stay independent because grains let them. The still case is a +bit-exact delay, which is what makes every departure from it legible. +Transposing warbles, and the warble is measured rather than apologized for: +the note holds to 98.8 % of a clean shifter's energy, and 92.0 % of its +focus. Every number here lives twice, as a cell in `scrub.ipynb` and as a +pinned scenario in `tests/scrub_test.cpp`. From 07f927e74b7ab5e053f7d621a79a4442c7e85c4a Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 17 Aug 2026 21:45:12 +0000 Subject: [PATCH 19/22] Sort the umbrella header's includes touche.h sorts before the tr808_* block under the house SortIncludes: CaseSensitive, and it was appended after them. This has failed the clang-format job on every commit since tap.touche~ landed; the local pre-commit hook was not installed in this clone, which is why six commits went out without it being caught. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- include/taptools/taptools.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/taptools/taptools.h b/include/taptools/taptools.h index c8a925a..3a98574 100644 --- a/include/taptools/taptools.h +++ b/include/taptools/taptools.h @@ -33,6 +33,7 @@ #include "tape_loop.h" #include "tapecho.h" #include "tb303_voice.h" +#include "touche.h" #include "tr808_clap.h" #include "tr808_cowbell.h" #include "tr808_cymbal.h" @@ -40,7 +41,6 @@ #include "tr808_kick.h" #include "tr808_rim.h" #include "tr808_snare.h" -#include "touche.h" #include "tr808_tom.h" #include "vca.h" #include "vco.h" From f1ebdfc23aaad78eaf7564d4e71f7273e3d14114 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 17 Aug 2026 22:11:07 +0000 Subject: [PATCH 20/22] Retract the pitchaccum cancellation, and file what survives The recorded "near-total cancellation" in tap.pitchaccum~ (band energy 0.004 at 311 Hz +19 semitones) was an artifact of the metric, not the object. The sweep integrated a fixed +-15 Hz band: about 115 cents wide at 220 Hz but only 26 cents at 932 Hz, so at high transposed pitches the probe was narrower than the shifter's own spread and missed the energy. Widened to a constant 3 %, the two "cancellations" read 0.63 and 0.85 and none exists anywhere on the sweep. This is the mistake machine/scrub.md had just finished warning about, committed one section later, so the appendix now carries the second half of its own rule: a band wide enough in the units the process works in. For a pitch shifter that unit is cents, never hertz. What survives is filed as issue #33: mean 0.907 / worst 0.633 band energy against the scrub's 0.988 / 0.917; the strongest spectral line sitting 5-20 Hz beside the intended pitch; and yin reading up to +35 cents sharp at 110 Hz for the +7 and +19 intervals, which is ambiguous between a real error and a detector artifact and is written up as ambiguous. Corrects book/src/scrub.md, book/src/machine/scrub.md and book/PLAN-radiohead-family.md. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-family.md | 25 ++++++++++++++++++------- book/src/machine/scrub.md | 14 ++++++++++++++ book/src/scrub.md | 10 ++++++---- 3 files changed, 38 insertions(+), 11 deletions(-) diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index c6b5c46..450ea34 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -423,13 +423,24 @@ are the house precedent for schematic-based recreation. **Naming is an open ques - ~~**One capture component or two.**~~ Resolved at the scrub's ship: **one**. `scrub.h` includes `stammer.h` and uses `stammer::capture` directly; the only change the stutter needed was a fractional read it does not itself call. -- **`tap.pitchaccum~` has the same warble, and worse.** Measured on the same sweep the scrub was - measured on (5 fundamentals × 7 intervals, band energy retained around the transposed pitch): - the scrub returns mean 0.988 / worst 0.917, `tap.pitchaccum~` returns mean 0.908 / **worst - 0.004** — a near-total cancellation at 311 Hz up 19 semitones, where its ratio is exactly 3 - and the two taps land a half-window apart. That is a real finding about a shipped object, - recorded rather than acted on: fixing it is its own job, with its own tests and its own - consumers, and it should not ride along on an unrelated kernel. +- **`tap.pitchaccum~` has the same warble, and worse** — now filed as + [taptools#33](https://github.com/tap/TapTools/issues/33), **and partially retracted on the way + there.** The original entry here recorded a "near-total cancellation" at 311 Hz +19 semitones, + band energy 0.004. That number was an artifact of the metric: the sweep integrated a fixed + **±15 Hz** band, which is about 115 cents wide at 220 Hz but only 26 cents at 932 Hz, so at + high transposed pitches the probe was narrower than the shifter's own spread and missed the + energy. Widened to a constant 3 % — the same width in cents everywhere — the two "cancellations" + read 0.63 and 0.85, and none exists anywhere on the sweep. + + What survives: on 5 fundamentals × 7 intervals, `tap.pitchaccum~` retains mean 0.907 / worst + 0.633 against the scrub's 0.988 / 0.917; its strongest spectral line sits 5–20 Hz *beside* the + intended pitch (consistent with two-tap crossfade sidebands); and `tap::dsp::yin` reads it up to + +35 cents sharp at 110 Hz for the +7 and +19 intervals, falling to −5 cents at 440 Hz — which is + ambiguous between a real error and a detector artifact and is written up as such in the issue. + + **The lesson is the one `machine/scrub.md` had just finished writing**, committed one section + later: if a process can smear or shift a partial, the probe must be wide enough *in the units + the process works in*. For a pitch shifter that unit is cents, never hertz. - ~~**Chapters for the six newest objects.**~~ — ✅ shipped 2026-08-17 as six chapters, three user-facing and three machine appendices: `book/src/scrub.md`, `diffuseurs.md`, `ondes.md` (which carries `tap.ondes~`, `tap.triode~` and `tap.touche~` together, since the triode and diff --git a/book/src/machine/scrub.md b/book/src/machine/scrub.md index b2af664..6943a24 100644 --- a/book/src/machine/scrub.md +++ b/book/src/machine/scrub.md @@ -77,6 +77,20 @@ pitch-shifter: **if the process can smear a partial, a single-bin probe is measuring the smear, not the partial.** Integrate a band wide enough to contain the artifact you already know about. +And then, immediately, the same mistake in its other half. The comparison +against `tap.pitchaccum~` used that ±15 Hz band unchanged across the whole +sweep — but ±15 Hz is about 115 cents wide at 220 Hz and only 26 cents at +932 Hz, so at the top of the sweep the probe was again narrower than the +process it was measuring, and it produced two readings of 0.0001 and 0.0006 +that were recorded as near-total cancellations of a shipped object. Widened +to a constant 3 %, they read 0.63 and 0.85 and no cancellation exists. The +retraction and what survives it are [issue #33](https://github.com/tap/TapTools/issues/33). + +So the rule has a second half: a band wide enough **in the units the process +works in**. A pitch shifter works in cents. A fixed hertz window is a +different width at every pitch, and the place it is narrowest is exactly +where a shifter's error is largest. + Two related mistakes are recorded here because both were committed: - **Analysing mostly silence.** The first wander sweep ran 1 second of diff --git a/book/src/scrub.md b/book/src/scrub.md index 33fdb34..4f6aaf1 100644 --- a/book/src/scrub.md +++ b/book/src/scrub.md @@ -116,10 +116,12 @@ render bit for bit, and two instances decorrelate by seed alone. - **Clean transposition.** The warble above is inherent to the method. `tap.shift~` and `tap.pitchaccum~` are the objects built for that job — with one caveat worth stating plainly: measured on this same sweep, - `tap.pitchaccum~` retained mean 0.908 of band energy with a **worst case - of 0.004**, well below the scrub's worst of 0.917. That is recorded as an - open question against `tap.pitchaccum~` rather than a recommendation - against it, but audition before you assume. + `tap.pitchaccum~` retained mean 0.907 of band energy against the scrub's + 0.988, worst 0.633 against 0.917. Its two-tap crossfade also puts its + strongest spectral line a few hertz *beside* the intended pitch, which is + filed as [issue #33](https://github.com/tap/TapTools/issues/33). None of + that makes it the wrong object — it is a shimmer, and shimmer is what those + sidebands are — but audition before you assume it is the transparent one. - **A tidy delay.** `tap.delay~` and `tap.tapecho~` cost far less and do not window anything. - **Slicing to a grid.** That is `tap.stammer~`, on the same tape. From 2785d24d438af0013d50b34d3ae7318cfb3c3560 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 17 Aug 2026 22:29:01 +0000 Subject: [PATCH 21/22] Cascade the fuzz oversampler, and correct a default drawn from one tone The imaging hypothesis was right. fuzz.h zero-stuffed by N in one step and filtered once at 0.45/N normalized (0.056 at 8x), which left N-1 images for a single filter to suppress at a corner that tightened with every doubling; residuals entering the clipper intermodulated into exactly the non-harmonic products the alias probe measures. ondes.h had supplied the evidence without being built for it -- same filters, comparably hard nonlinearity, but a source with nothing zero-stuffed, and no reversal. The chain is now one 2x stage per doubling, each filtering at 0.225 of its own operating rate, a corner that never tightens however deep the cascade goes. The reversal is gone: worst step-up past 2x is a ratio of 1.017, where the old chain ran up to 3x worse per doubling. Where 4x and 8x were merely adequate they are now two to four orders of magnitude better (5171 Hz at 8x: 2.3e-3 to 1.9e-7). The 2x column is unchanged, as it must be -- one doubling is one stage either way, which is the best available check that nothing else moved. Cost: 3.16 % of a core at 8x against 3.02 %. A second, larger error surfaced doing it. Every number in the original write-up came from a single test tone at 3733 Hz, where 2x happens to look best. Swept across nine tones, 2x collapses above about 6 kHz and at 10499 Hz measures worse than no oversampling at all, because the clipper's low harmonics already exceed the base Nyquist there. The shipped default of 2x was safe only for material below 6 kHz. The default is now 4x, and 8x earns its keep above about 7.5 kHz where harmonics start folding inside the 4x band. The aliasing scenario now asserts the property the cascade delivers -- the sequence never reverses -- and that 4x beats 2x at a bright tone, which the old chain would have failed. fuzz.ipynb SS5 is re-executed with the nine-tone sweep and the probe's own floor plotted. The chapter, the appendix (whose "hypothesis that died" section becomes "a hypothesis that was right", plus a new "one tone is not a sweep"), ondes.h's cross-reference and both plans follow. Still open, unchanged: whether overdrive.h is owed the same change. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-radiohead-chapters.md | 20 ++-- book/PLAN-radiohead-family.md | 43 ++++++--- book/src/fuzz.md | 61 ++++++++---- book/src/machine/fuzz.md | 105 ++++++++++++++------- book/src/machine/ondes.md | 31 +++++-- book/src/ondes.md | 6 +- include/taptools/fuzz.h | 160 ++++++++++++++++++++++---------- include/taptools/ondes.h | 15 ++- notebooks/fuzz.ipynb | 153 ++++++++++++++++++------------ tests/fuzz_test.cpp | 44 ++++++--- 10 files changed, 424 insertions(+), 214 deletions(-) diff --git a/book/PLAN-radiohead-chapters.md b/book/PLAN-radiohead-chapters.md index e030e69..677ce8c 100644 --- a/book/PLAN-radiohead-chapters.md +++ b/book/PLAN-radiohead-chapters.md @@ -154,8 +154,8 @@ class boundary is a seam. Added with the object. The user-facing chapter opens by placing it against `tap.overdrive~` (two dirt objects, not competing) and spends its length on the three things a patcher can act -on: the knee as a character control, why the gain floor sits below unity, and why -`oversample` 2 beats 8. The appendix is deliberately **about two mistakes**, because the DSP +on: the knee as a character control, why the gain floor sits below unity, and what +`oversample` actually buys. The appendix is deliberately **about mistakes**, because the DSP is a published recipe followed closely and the failures are the reusable part: - *Small-signal gain compounds across a cascade.* The tanh family's slope is `k/tanh(k)`, so a @@ -164,11 +164,17 @@ is a published recipe followed closely and the failures are the reusable part: keeping is that it was **inaudible** — it sounded like a distortion at every setting because it was one — so only a swept measurement found it. - *The house oversampler measured wrong here, and so did the first explanation.* 4th order made - 4× worse than 2×; 8th order improves 4× ~6× but does not restore an ordering. An earlier - draft of both the appendix and the plan claimed it did; that is corrected, the measured table - is in the chapter, and the ruled-out hypothesis (biquad conditioning, disproved by an - impulse-response check) is recorded alongside the surviving one (imaging) rather than left - as a vague "needs investigation". + 4× worse than 2×; 8th order improves 4× ~6× but did not restore an ordering. An earlier + draft of both the appendix and the plan claimed it did; that was corrected, and the + ruled-out hypothesis (biquad conditioning, disproved by an impulse-response check) was + recorded alongside the surviving one (imaging) rather than left as a vague "needs + investigation". +- *And then the surviving hypothesis was acted on, 2026-08-17.* Cascaded 2× resampling removed + the reversal; the appendix's "Mistake two" section is rewritten from *a hypothesis that died* + to *a hypothesis that was right*, with a before/after table. **A third mistake was found + doing it and got its own section**: every number in the original write-up came from one test + tone, and swept properly the shipped default of 2× collapses above 6 kHz. The default is now + 4×. The section is called "one tone is not a sweep" and it is the reusable part. Two aliasing test-design errors are also written up in the appendix — a tone dividing the sample rate, and probes near enough the fundamental to read window leakage — since both passed diff --git a/book/PLAN-radiohead-family.md b/book/PLAN-radiohead-family.md index 450ea34..d679283 100644 --- a/book/PLAN-radiohead-family.md +++ b/book/PLAN-radiohead-family.md @@ -288,14 +288,16 @@ sketched, so `tap.ondes~` needs a design pass against these findings before impl > 2. *The house oversampler is not steep enough here — and steepening it was not the whole > story.* With the 4th-order Butterworth that `tap.ladder~` / `overdrive.h` use, alias > energy at 4× came out worse than at 2× (1.7e-2 vs 2.8e-3). Eighth order improves 4× by -> ~6× but does **not** make the sequence monotone: measured, 1×/2×/4×/8× run -> 1.2e-1 / 2.7e-5 / 7.4e-4 / 1.8e-3, so 2× is best and is now the default. An earlier -> draft of this record claimed 8th order "restored monotonicity" — it does not, and the -> notebook plot is the correction. The cause is open: the obvious suspect (ill-conditioned -> biquads at low normalized cutoffs) was tested and **ruled out** by an impulse-response -> check; the untested hypothesis is imaging, which would point at cascaded 2× resampling -> as the real fix. Whether `overdrive.h` is owed the 8th-order change is a separate live -> question needing its own measurement. +> ~6× but did **not** make the sequence monotone: measured, 1×/2×/4×/8× ran +> 1.2e-1 / 2.7e-5 / 7.4e-4 / 1.8e-3, so 2× shipped as the default. An earlier draft of +> this record claimed 8th order "restored monotonicity" — it did not, and the notebook +> plot was the correction. The cause was recorded open, with ill-conditioned biquads +> **ruled out** by an impulse-response check and imaging left as the untested hypothesis. +> **Both halves of that were later closed** (see the open-questions list): imaging was +> right, the chain now cascades 2× stages and the reversal is gone — and the whole +> conclusion turned out to rest on a single test tone, so the default is now 4×. +> Whether `overdrive.h` is owed the 8th-order change is still a separate live question +> needing its own measurement. > > Two test-design errors were also caught and are recorded in the suite itself, since both > are easy to repeat: an alias test whose tone divided the sample rate (every fold lands on @@ -447,13 +449,24 @@ are the house precedent for schematic-based recreation. **Naming is an open ques the key only make sense next to the instrument they are stages of), plus `machine/scrub.md`, `machine/diffuseur.md` and `machine/ondes.md`. Eight new measured figures in `book/figures/radiohead.py`. Drafting record in `PLAN-radiohead-chapters.md`. -- ~~**The oversampler's non-monotone sequence** (`fuzz.h`'s open question)~~ — not resolved, but - no longer without evidence. `ondes.h` runs the same 8th-order chain around a comparably hard - nonlinearity as a **source**, with no zero-stuffing and therefore no images, and its sequence - never reverses: about 12 dB per doubling to 4× and 7–12 dB more at 8× in the top octave, where - `fuzz.h` got *worse* at 4×. Same filters, no upsampler, no reversal — which is what the imaging - hypothesis predicted. The next move is unchanged (cascaded 2× halfband resampling in `fuzz.h`), - but it now has a reason behind it rather than a guess. +- ~~**The oversampler's non-monotone sequence** (`fuzz.h`'s open question)~~ — ✅ **resolved + 2026-08-17, and the imaging hypothesis was right.** `ondes.h` supplied the evidence by + accident: same 8th-order chain, comparably hard nonlinearity, but a **source** with nothing + zero-stuffed, and no reversal. Acting on it, `fuzz.h` now cascades one 2× stage per doubling + — each filtering at 0.225 of its own operating rate, a corner that never tightens however deep + the cascade goes — instead of zero-stuffing by N once at 0.45/N (0.056 at 8×). The reversal is + gone: worst step-up past 2× is a ratio of 1.017, and 4× / 8× improved by two to four orders of + magnitude (5171 Hz at 8×: 2.3e-3 → 1.9e-7). Cost: 3.16 % of a core at 8× against 3.02 %. + + **And a second, larger error surfaced doing it.** Every number in the original write-up came + from a *single* test tone at 3733 Hz, where 2× happens to look best. Swept across nine tones, + 2× collapses above about 6 kHz and at 10499 Hz measures worse than no oversampling at all. The + shipped default of 2× was safe only for material below 6 kHz; it is now **4×**. One probe is + not a sweep — the same lesson as the pitchaccum retraction above, from the other direction: + there, one metric applied everywhere; here, one point of the input domain. + + Still open, unchanged: whether `overdrive.h` is owed the same change. Different nonlinearity, + different gain structure, so it needs its own measurement rather than this one's conclusion. - **Diffuseur delivery.** Ship the resonators inside `tap.ondes~` only, or as standalone externals (`tap.palme~` / `tap.metallique~`) from day one? The components chapter's lesson leans standalone-from-day-one. diff --git a/book/src/fuzz.md b/book/src/fuzz.md index 0da88c5..0b82f59 100644 --- a/book/src/fuzz.md +++ b/book/src/fuzz.md @@ -81,28 +81,49 @@ voicing section is most of the identity — the scoop is the sound people mean when they describe it — so it is a first-class part of the object rather than an afterthought bolted on at the end. -## `oversample` — where 2 beats 8 +## `oversample` — and a default that was wrong twice A static curve makes harmonics without limit, so anything above Nyquist folds -back. The clipper pair therefore runs oversampled. Two things about the -setting are worth knowing, and both are measurements rather than opinions. +back. The clipper pair therefore runs oversampled. Everything about this +control has been re-measured, because the first two conclusions drawn from it +were wrong, and wrong in the same way. First, the anti-alias filter here is **8th order**, where the rest of the house uses 4th. Measured in this kernel the 4th-order pair is not steep enough — alias energy at 4× came out worse than at 2×. -Second, and more surprising: **bigger is not better**. Fold energy measures -1.2e-1 / 2.7e-5 / 7.4e-4 / 1.8e-3 at 1× / 2× / 4× / 8×. Every factor is worth -having over none — 2× alone is four orders of magnitude — but the sequence is -not monotone, and 2× wins. That is why the default is 2 rather than the -largest available number. The cause is genuinely open: the obvious suspect -(filters going ill-conditioned at the very low normalized cutoffs a high -factor needs) was tested and ruled out, and the untested candidate is -imaging from the zero-stuff upsampler intermodulating in the clipper. The -appendix says more. - -Use a higher factor if a specific patch measures better there. Do not assume -it will. +Second, the chain is a **cascade of 2× stages** — one doubling, one filter, +repeated — rather than a single zero-stuff by the whole factor. That is what +finally made more oversampling mean less aliasing. The single-stage chain left +N−1 images for one filter to suppress at a corner that got tighter with every +doubling, and the residue intermodulated in the clipper into exactly the +non-harmonic junk the probe measures. Cascading removes the reversal outright, +and where 4× and 8× used to be merely adequate they are now two to four orders +of magnitude cleaner. It costs about 5 % more CPU at 8×. + +Third — and this is the part worth taking away — **the old default came from a +single test tone.** Every number in the original write-up was measured at +3733 Hz, and 2× happens to look best there. Swept across tones, 2× collapses +above about 6 kHz; at 10.5 kHz it is *worse than not oversampling at all*, +because the clipper's low harmonics already exceed the base Nyquist and one +doubling does not move them out of the way. + +| input tone | 1× | 2× | 4× | 8× | +|---|---|---|---|---| +| 3733 Hz | 1.2e-1 | 3.0e-5 | 2.1e-5 | 2.2e-5 | +| 5171 Hz | 1.5e-1 | 3.3e-4 | 2.0e-7 | 1.9e-7 | +| 6421 Hz | 8.5e-2 | 3.2e-2 | 3.9e-7 | 3.6e-7 | +| 8123 Hz | 9.0e-2 | 7.8e-2 | 1.1e-3 | 2.0e-5 | +| 10499 Hz | 1.5e-1 | 1.7e-1 | 1.2e-5 | 1.6e-6 | + +So: **4× is the default.** More is never worse now, and 4× is +indistinguishable from 8× below about 7.5 kHz. Above that, harmonics start +folding inside the 4× band before decimation — 8123 Hz in the table is that +happening — and 8× is worth the extra 1.4 % of a core. + +Use 2× only if you have measured your own material and it holds up there. It +is kept because it is cheap and because on a bass-heavy source it is fine, not +because it is good. ## Recipes @@ -111,8 +132,8 @@ it will. - **The scoop:** `@gain 0.8 @edge 0.6 @contrast 1. @bass 0.4 @treble 0.2`. The sound the control is named for. - **Lopsided and mean:** `@gain 0.9 @edge 1. @asymmetry 0.7 @oversample 8`. - Hard knee plus even harmonics; the one setting where a bigger oversample - factor is worth auditioning. + Hard knee plus even harmonics, and 8× because a hard knee on a bright source + is exactly where the top octave folds. - **Into the echo:** `tap.fuzz~` → `tap.tapecho~` with the echo's `@drive` low. Two saturators in series get muddy fast; let the pedal be the dirt and the tape be the space. @@ -133,7 +154,9 @@ One clipping family with a knee control, cascaded twice, into a voicing section that scoops the middle. The gain knob's floor is below unity because small-signal gain compounds through a cascade — a lesson that cost this kernel one wrong first draft. `asymmetry` is the even-harmonic control and -costs no DC. And the oversample setting is a measurement, not a -bigger-is-better dial: 2× is the default because 2× wins. Every number here +costs no DC. And the oversample setting is a +measurement twice corrected: cascaded 2× stages, because a single zero-stuff +by N was what made bigger measure worse — and a default of 4× rather than 2×, +because the old default had been generalized from one test tone. Every number here lives twice, as a cell in `fuzz.ipynb` and as a pinned scenario in `tests/fuzz_test.cpp`. diff --git a/book/src/machine/fuzz.md b/book/src/machine/fuzz.md index 35429d5..b7b822b 100644 --- a/book/src/machine/fuzz.md +++ b/book/src/machine/fuzz.md @@ -42,7 +42,7 @@ waveshaper's small-signal slope is part of the gain structure**, and if the curve family's slope depends on a user-facing parameter, that dependence propagates to every stage downstream of it. -## Mistake two: the house oversampler, and a hypothesis that died +## Mistake two: the house oversampler, and a hypothesis that was right The oversampling chain in `tap.ladder~`, `tap.svf~` and `overdrive.h` is zero-stuff plus a 4th-order Butterworth, cut at 0.45 of the base rate @@ -54,38 +54,69 @@ leaves content just above the base Nyquist barely attenuated, and a higher factor pushes more clipper-generated content into exactly that band before decimation. Moving to 8th order improved 4× about sixfold. -It did not fix the ordering, and this is where the appendix has to be careful, -because an earlier draft of this file claimed it did. Measured against a -3733 Hz tone: - -| factor | fold energy | vs. 1× | -|--------|-------------|--------| -| 1× | 1.2e-1 | — | -| 2× | 2.7e-5 | 4618× better | -| 4× | 7.4e-4 | 166× better | -| 8× | 1.8e-3 | 69× better | - -Every factor is worth having. 2× is the best of them, so 2× is the default. - -**The cause is not established, and one hypothesis is dead.** The obvious -suspect was numerical: at 8× the filters are cut at 0.056 normalized, where -biquad poles crowd the unit circle and direct-form sections are known to -misbehave. That was tested — the cascade's impulse response was run out to -400,000 samples at each factor — and it decays cleanly to denormal every -time. Not conditioning. - -The surviving hypothesis, untested, is imaging. Zero-stuffing by N leaves -N−1 images for a single filter to suppress; residual images entering a -*nonlinearity* intermodulate with the signal into products that are not -harmonics of the input, which is precisely what the probe measures, and there -are more of them at higher N. If that is right, the fix is the standard one: -cascaded 2× (halfband/polyphase) resampling rather than one stage at 1/N, so -each step suppresses a single image at a comfortable normalized frequency. -That is the known next move on this file. - -Whether `overdrive.h` is owed the 8th-order change is a separate question. -Different nonlinearity, different gain structure, different spectrum — it -needs its own measurement, not this one's conclusion. +It did not fix the ordering. An earlier draft of this file recorded that as an +open question with one hypothesis ruled out and one surviving: + +- **Ruled out: numerics.** At 8× the filters are cut at 0.056 normalized, + where biquad poles crowd the unit circle. Tested by running the cascade's + impulse response out to 400,000 samples at each factor; it decays cleanly to + denormal every time. +- **Surviving: imaging.** Zero-stuffing by N leaves N−1 images for a single + filter to suppress; residual images entering a *nonlinearity* intermodulate + with the signal into products that are not harmonics of the input, which is + precisely what the probe measures, and there are more of them at higher N. + +`ondes.h` then supplied evidence for the survivor without being built to: +same 8th-order chain, comparably hard nonlinearity, but a **source** with +nothing zero-stuffed on the way up, and its sequence never reversed. + +**Acting on it settled it.** The chain is now one 2× stage per doubling, each +filtering at 0.225 of its own operating rate — a corner that never tightens +however deep the cascade goes, which is the whole difference. Same probe, same +material, only the resampler changed: + +| tone | old 4× | old 8× | new 4× | new 8× | +|---|---|---|---|---| +| 3733 Hz | 7.4e-4 | 1.8e-3 | 2.1e-5 | 2.2e-5 | +| 4409 Hz | 7.9e-4 | 2.1e-3 | 3.7e-7 | 3.7e-7 | +| 5171 Hz | 9.2e-4 | 2.3e-3 | 2.0e-7 | 1.9e-7 | +| 6421 Hz | 5.8e-4 | 1.3e-3 | 3.9e-7 | 3.6e-7 | +| 9337 Hz | 2.9e-4 | 6.2e-5 | 1.8e-6 | 2.4e-8 | + +The worst step-up past 2× is a ratio of 1.017 — flat, where the old chain ran +up to 3× worse per doubling. The 2× column is unchanged in both, as it must +be: one doubling is one stage either way, and that it *is* unchanged is the +best available check that nothing else moved. + +The cost is 3.16 % of a core at 8× against 3.02 % before. The filters are +cheap next to the clipper they surround, which is worth knowing in advance +next time this trade looks expensive. + +## Mistake three: one tone is not a sweep + +Every number in the two sections above — the 4th-order finding, the reversal, +the "2× is best" default that shipped — came from **a single test tone at +3733 Hz**. The tone was chosen carefully, for good reasons that are still +good: it does not divide the sample rate, and its folds land where nothing +else lives. It was still one tone. + +Swept properly, 2× does not merely fail to be best. It collapses above about +6 kHz, and at 10499 Hz it measures *worse than no oversampling at all* +(1.7e-1 against 1.5e-1), because the clipper's low harmonics already exceed +the base Nyquist there. The default that shipped was safe only for material +that stays below 6 kHz. + +This is the same error as the two in the next section, one level up: those are +about choosing a bad probe, this is about choosing too few. A probe that is +correct at one point on the input domain tells you about that point. The fix +is not cleverness, it is a `for` loop over tones, and it costs seconds. + +Two properties of this particular probe bound where the loop can go, and both +are now written down next to it: it only measures folding at all above about +3 kHz, since below that harmonics 8–13 are still under Nyquist and it reads +real harmonics instead; and tones that are simple rational multiples of the +sample rate stack folds on top of each other or put one exactly at Nyquist, +where it reads nonsense. ## Two ways to measure aliasing wrong @@ -110,6 +141,8 @@ A published cascade, followed closely. One curve whose normalization keeps the knee from becoming a volume control. A gain floor set below unity because small-signal slope compounds across stages — the bug that sounded fine. An 8th-order oversampling filter because the house 4th-order one measured worse, -and a default of 2× because bigger measured worse still, with the cause -recorded as open and one hypothesis explicitly ruled out rather than left -hanging. +and a cascade of 2× stages because a single zero-stuff by N was what made +bigger measure worse — the imaging hypothesis, recorded as open here for two +waves, then confirmed by acting on it. And a default of 4× rather than 2×, +because the 2× default had been generalized from one test tone and collapses +above 6 kHz. diff --git a/book/src/machine/ondes.md b/book/src/machine/ondes.md index 3dc36fa..826e1c5 100644 --- a/book/src/machine/ondes.md +++ b/book/src/machine/ondes.md @@ -133,10 +133,10 @@ state, 131072-point Hann — showed 8× continuing to improve in the top octave. Corrected to "never worse", with the full table in the header, the test comment and the notebook. -## Evidence for an open question in `fuzz.h` +## The evidence that closed an open question in `fuzz.h` `fuzz.h` measured its oversampling sequence going the wrong way — 4× worse -than 2× — and left an untested hypothesis behind: that the culprit is +than 2× — and had left an untested hypothesis behind: that the culprit is *imaging*, since zero-stuffing by N leaves N−1 images for one filter to suppress, and residual images entering a nonlinearity intermodulate into products that are not harmonics of the input. @@ -156,10 +156,23 @@ The difference between the two files is exactly the hypothesis: this object is a **source**. Nothing is zero-stuffed on the way up — the detector simply runs fast — so there are no images at all. -That is evidence, not proof. The nonlinearities differ too, and one -confounded comparison does not settle a question. But it is the first -evidence either way and it points the same direction, and both headers now -record it as such. +That was evidence, not proof — the nonlinearities differ too, and one +confounded comparison does not settle a question. But it was the first +evidence either way, and it pointed somewhere specific enough to act on. + +**Acting on it settled it.** `fuzz.h` now cascades one 2× stage per doubling +instead of zero-stuffing by N once, each stage filtering at a corner that +never tightens however deep the cascade goes. Its reversal is gone — worst +step-up past 2× is a ratio of 1.017 — and its 4× and 8× improved by two to +four orders of magnitude, for about 5 % more CPU. This file needed no change, +having no upsampler to fix. + +Worth naming the shape of it, because it is not the usual one: the evidence +that resolved a two-wave-old open question in one file came from **building a +different file that happened to differ in exactly the right variable**. It +was not designed as an experiment. It was noticed, written down in both +headers as evidence rather than proof, and left where the next person would +trip over it. ## A wrapper test that found a kernel bug @@ -196,7 +209,7 @@ A stage that required no design because the paper published the model and its fitted parameters. A detector that is exact rather than approximate, and cheaper than the thing it replaces. One sign error that inverted the meaning of a distortion knob and was invisible at any single setting. Three -measurements that lied in three different ways, all recorded. Evidence for -`fuzz.h`'s open oversampler question from a file that happens to differ in -exactly the right variable. And a wrapper test that found a kernel bug, +measurements that lied in three different ways, all recorded. The evidence that closed `fuzz.h`'s +oversampler question, from a file that happened to differ in exactly the +right variable and was not built as an experiment. And a wrapper test that found a kernel bug, which is the split doing its job. diff --git a/book/src/ondes.md b/book/src/ondes.md index 2d1c612..8c4934d 100644 --- a/book/src/ondes.md +++ b/book/src/ondes.md @@ -205,9 +205,9 @@ already bottomed out. Never worse. 4× is the default because that is where the cost stops buying uniformly; 8× is there for anyone playing the top octave hard. -Readers of the `tap.fuzz~` chapter will notice this is the *opposite* of -what that object measured. That is not a contradiction, and the appendix -explains why it is evidence. +Readers of the `tap.fuzz~` chapter will notice this used to be the *opposite* +of what that object measured. That was not a contradiction — it was the clue +that fixed the fuzz. The appendix explains how. ## What is missing, deliberately diff --git a/include/taptools/fuzz.h b/include/taptools/fuzz.h index 5959d87..7d710db 100644 --- a/include/taptools/fuzz.h +++ b/include/taptools/fuzz.h @@ -43,17 +43,17 @@ /// - `pedal` — input gain, the two stages inside the oversampled region, the DC /// blocker, the tone stack, output level. /// -/// Aliasing: the clipper pair runs oversampled (1/2/4/8x, **default 2x**) — -/// zero-stuff plus an 8th-order Butterworth anti-image on the way up, a matching -/// anti-alias before decimation. Two things here differ from the house pattern and -/// both are measurements rather than preferences. The pattern's 4th-order filter is -/// not steep enough (it made 4x worse than 2x); and even at 8th order the sequence -/// is *not* monotone — 2x measures best, so 2x is the default, not the largest -/// factor. DAFx-07 notes that typical implementations use 8-10x and that residual -/// aliases there tend to be masked by the dense spectrum of guitar distortion; this -/// kernel's curve is C-infinity rather than a hard corner, which is why a modest -/// factor already buys four orders of magnitude. See butterworth8's comment for the -/// numbers and for what is and is not known about the cause. +/// Aliasing: the clipper pair runs oversampled (1/2/4/8x, **default 4x**) by +/// **cascaded 2x stages** — one zero-stuff-by-two and one 8th-order Butterworth per +/// doubling, each cutting at 0.225 of its own output rate, and the mirror of that on +/// the way down. Two things here differ from the house pattern and both are +/// measurements rather than preferences: the pattern's 4th-order filter is not steep +/// enough for this curve, and its single zero-stuff-by-N is what made more +/// oversampling measure *worse* here. Cascading fixes that — see butterworth8's +/// comment for the before/after table. DAFx-07 notes that typical implementations +/// use 8-10x and that residual aliases there tend to be masked by the dense spectrum +/// of guitar distortion; this kernel's curve is C-infinity rather than a hard corner, +/// which is why a modest factor already buys two to three orders of magnitude. /// /// Honest limits: /// - The nonlinearity is static. The pole-moves-with-voltage behaviour of the real @@ -75,6 +75,7 @@ #pragma once #include +#include #include #include @@ -90,6 +91,11 @@ namespace tap::tools { // family's slope is knee/tanh(knee), ~2 at the stock knee), so a floor at unity would // arrive at the limiter already saturated and the knob would do nothing over most of its // travel. Gain staging across a cascade is the whole game; these two numbers are it. + constexpr int k_max_os = 8; // 1, 2, 4 or 8 + constexpr int k_max_stages = 3; // log2(k_max_os): one 2x resampler per doubling + constexpr int k_default_os = 4; // measured: within noise of 8x, and never bad + constexpr double k_os_fc_norm = 0.225; // each 2x stage's corner, of its own output rate + constexpr double k_gain_min_db = -12.0; constexpr double k_gain_max_db = 36.0; constexpr double k_level_range_db = 24.0; @@ -222,31 +228,55 @@ namespace tap::tools { /// 1.7e-2 at 4x against 2.8e-3 at 2x — more oversampling was *worse*. Eighth order cuts /// that to 2.7e-3, a ~6x improvement at 4x. /// - /// It does NOT make the sequence monotone, and this file does not claim it does. Measured - /// against a 3733 Hz tone (fuzz.ipynb §5), fold-frequency energy runs 1.2e-1 / 2.7e-5 / - /// 7.4e-4 / 1.8e-3 at 1x / 2x / 4x / 8x: every factor is worth having over none, and 2x - /// is the best of them, which is why it is the default. + /// **Eighth order did not fix the ordering; cascading did.** The chain used to zero-stuff + /// by N in one step and filter once, at 0.45/N normalized — 0.056 at 8x. That leaves N-1 + /// images for a single filter to suppress at a corner that gets tighter with every + /// doubling, and residuals entering the clipper intermodulate into products that are not + /// harmonics of the input, which is exactly what the probe measures. ondes.h supplied the + /// first evidence for that reading: same filters, comparably hard nonlinearity, but a + /// SOURCE with nothing zero-stuffed, and no reversal. + /// + /// Acting on it confirms it. The chain is now one 2x stage per doubling, each filtering at + /// 0.225 of its own operating rate — a corner that never tightens however deep the cascade + /// goes. Fold energy against a hard-driven sine, same probe both sides (fuzz.ipynb §5): + /// + /// tone single zero-stuff by N cascaded 2x + /// 1x 2x 4x 8x 2x 4x 8x + /// 3067 7.8e-2 1.0e-3 2.5e-3 3.1e-3 1.0e-3 9.1e-4 8.9e-4 + /// 3733 1.2e-1 2.7e-5 7.4e-4 1.8e-3 3.0e-5 2.1e-5 2.2e-5 + /// 4409 1.4e-1 9.4e-7 7.9e-4 2.1e-3 8.6e-7 3.7e-7 3.7e-7 + /// 5171 1.5e-1 3.3e-4 9.2e-4 2.3e-3 3.3e-4 2.0e-7 1.9e-7 + /// 6421 8.5e-2 3.2e-2 5.8e-4 1.3e-3 3.2e-2 3.9e-7 3.6e-7 + /// 7211 1.0e-1 8.9e-2 4.3e-4 9.6e-4 8.9e-2 4.5e-7 4.3e-7 + /// 8123 9.0e-2 7.8e-2 1.1e-3 1.1e-3 7.8e-2 1.1e-3 2.0e-5 + /// 9337 9.1e-2 8.1e-2 2.9e-4 6.2e-5 8.1e-2 1.8e-6 2.4e-8 + /// 10499 1.5e-1 1.7e-1 1.8e-3 1.4e-4 1.7e-1 1.2e-5 1.6e-6 + /// + /// The worst step-up past 2x is now a ratio of 1.017 — flat, where the old chain ran up to + /// 3x worse per doubling. Where the old 4x and 8x were merely adequate they are now two to + /// four orders of magnitude better (5171 Hz at 8x: 2.3e-3 to 1.9e-7). The 2x column is + /// unchanged, as it must be: one doubling is one stage either way. + /// + /// It cost essentially nothing: 8x runs 3.16 % of a core against the old 3.02 % (20 s of + /// audio), because the extra filter instances are cheap next to the clipper they surround. /// - /// The cause is not established. The obvious suspect — biquads going ill-conditioned at - /// the low normalized cutoffs a high factor needs (0.056 at 8x) — was tested and ruled - /// out: the cascade's impulse response decays cleanly to denormal at every factor. The - /// next hypothesis was imaging: zero-stuffing by N leaves N-1 images for one filter to - /// suppress, and residuals intermodulate in the clipper into products that are not - /// harmonics of the input, which is exactly what the probe measures. If that is right, - /// the fix is cascaded 2x (halfband/polyphase) resampling rather than a single stage at - /// 1/N — each step then suppresses one image at a comfortable normalized frequency. That - /// is the known next move on this file. + /// **The old default was also generalized from one probe.** Every earlier number here came + /// from 3733 Hz, where 2x happens to look best. Swept across tones, 2x collapses above + /// about 6 kHz — at 10.5 kHz it is *worse than no oversampling at all* — because the + /// clipper's low harmonics already exceed the base Nyquist there and one doubling does not + /// move them out of the way. **4x is the default now.** 8x earns its keep above about + /// 7.5 kHz, where harmonics start folding inside the 4x band before decimation (8123 Hz is + /// the visible case above); below that the two are indistinguishable. /// - /// **There is now evidence for it.** ondes.h runs the same butterworth8 chain around a - /// comparably hard nonlinearity, but as a SOURCE: nothing is zero-stuffed on the way up, - /// its generator simply runs at the high rate, so there are no images at all. Measured - /// the same way, its sequence never reverses — about 12 dB per doubling to 4x and 7-12 dB - /// more at 8x in the top octave (ondes.ipynb §5). Same filters, same order, no upsampler, - /// no reversal. Evidence rather than proof, since the nonlinearity differs too, but it is - /// the first evidence either way and it points at the upsampler. + /// Two limits of the probe itself, since it is what every number here rests on: it only + /// measures folding at all above about 3 kHz (below that, harmonics 8-13 are still under + /// Nyquist and it reads real harmonics instead), and tones that are simple rational + /// multiples of the sample rate put folds on top of each other or exactly at Nyquist, + /// where it reads nonsense. The sweep tones are chosen to avoid both. /// - /// (Whether overdrive.h is owed the 8th-order change is a live question — different - /// nonlinearity, different gain structure, so it needs its own measurement.) + /// (Whether overdrive.h is owed the same change is a live question — different + /// nonlinearity, different gain structure, so it needs its own measurement. ondes.h does + /// not need it: it is a source and zero-stuffs nothing.) /// /// Pole Qs are the standard 8th-order Butterworth set, Q_k = 1/(2 cos((2k+1)pi/16)). struct butterworth8 { @@ -375,8 +405,12 @@ namespace tap::tools { m_s1.clear(); m_s2.clear(); m_tone.clear(); - m_up.reset(); - m_down.reset(); + for (auto& f : m_up) { + f.reset(); + } + for (auto& f : m_down) { + f.reset(); + } m_dc_x1 = m_dc_y1 = 0.0; } @@ -406,8 +440,9 @@ namespace tap::tools { m_level_db.to(std::clamp(db, -k_level_range_db, k_level_range_db), smooth_samples()); } - /// 1, 2, 4 or 8; 2 is the default and measures best (see the banner — bigger is not - /// better here). Reconfigures the stage corners and the filters — not real-time-safe. + /// 1, 2, 4 or 8; 4 is the default. Reconfigures the stage corners and the resampler + /// cascade — not real-time-safe. 2x is offered but measures badly above about 6 kHz + /// (see the butterworth8 banner); prefer 4 unless something specific measures better. void set_oversample(int os) { const int v = (os >= 8) ? 8 : (os >= 4) ? 4 : (os >= 2) ? 2 : 1; if (v != m_os) { @@ -462,12 +497,33 @@ namespace tap::tools { y = core(x, drive, knee2, bias); } else { - // zero-stuff + anti-image up, the clipper pair at the high rate, anti-alias - // + decimate down (the tap.ladder~ / overdrive.h chain). - for (int j = 0; j < m_os; ++j) { - const double up = m_up.tick(j == 0 ? x * m_os : 0.0); - y = m_down.tick(core(up, drive, knee2, bias)); + // Cascaded 2x: each stage doubles the rate and suppresses the single image + // that doubling creates, at a comfortable normalized corner. See the + // butterworth8 banner for why this is not one zero-stuff by N. + std::array a{}, b{}; + a[0] = x; + int count = 1; + for (int i = 0; i < m_stages; ++i) { + for (int j = 0; j < count; ++j) { + b[static_cast(2 * j)] = m_up[i].tick(a[static_cast(j)] * 2.0); + b[static_cast(2 * j + 1)] = m_up[i].tick(0.0); + } + std::swap(a, b); + count *= 2; + } + for (int j = 0; j < count; ++j) { + a[static_cast(j)] = core(a[static_cast(j)], drive, knee2, bias); } + for (int i = m_stages - 1; i >= 0; --i) { + for (int j = 0; j < count / 2; ++j) { + // Filter every sample, keep the first of each pair. + b[static_cast(j)] = m_down[i].tick(a[static_cast(2 * j)]); + m_down[i].tick(a[static_cast(2 * j + 1)]); + } + std::swap(a, b); + count /= 2; + } + y = a[0]; } // Asymmetry generates DC that the shelves would otherwise pass; always on. @@ -496,11 +552,16 @@ namespace tap::tools { m_s1.prepare(osr, k_voice_stage1_hp_hz, k_voice_stage1_lp_hz); m_s2.prepare(osr, k_voice_stage2_hp_hz, k_voice_stage2_lp_hz); m_tone.prepare(m_sr); - if (m_os > 1) { - // Cut just below the original Nyquist, normalized to the oversampled rate. - const double fc_norm = 0.45 / static_cast(m_os); - m_up.design(fc_norm); - m_down.design(fc_norm); + m_stages = 0; + for (int n = m_os; n > 1; n >>= 1) { + ++m_stages; + } + for (int i = 0; i < m_stages; ++i) { + // 0.225 of each stage's own output rate — its input Nyquist, with margin. + // Every stage gets the same comfortable corner however deep the cascade is, + // which is the entire point of cascading rather than zero-stuffing by N. + m_up[i].design(k_os_fc_norm); + m_down[i].design(k_os_fc_norm); } m_tone_bass = m_tone_treble = m_tone_contrast = std::nan(""); m_configured = true; @@ -512,12 +573,13 @@ namespace tap::tools { double m_sr{48000.0}; double m_smooth_ms{k_default_smooth_ms}; - int m_os{2}; + int m_os{k_default_os}; bool m_configured{false}; stage m_s1, m_s2; tone m_tone; - butterworth8 m_up, m_down; + butterworth8 m_up[k_max_stages], m_down[k_max_stages]; + int m_stages{1}; // log2(m_os); 0 at 1x double m_dc_x1{0.0}, m_dc_y1{0.0}; // Cached tone targets so the biquads are only redesigned when a control actually moves. diff --git a/include/taptools/ondes.h b/include/taptools/ondes.h index f7010cb..eb9039e 100644 --- a/include/taptools/ondes.h +++ b/include/taptools/ondes.h @@ -104,15 +104,20 @@ /// bottomed out. **Never worse.** 4× is the default because it is where the cost /// stops buying uniformly; 8× is there for anyone playing the top octave hard. /// -/// That matters beyond this file, because `fuzz.h` measured the opposite — 4× came -/// out *worse* than 2× there — and left an untested hypothesis behind: that the +/// That mattered beyond this file. `fuzz.h` measured the opposite — 4× came out +/// *worse* than 2× there — and had left an untested hypothesis behind: that the /// culprit is *imaging*, since zero-stuffing by N leaves N−1 images for one filter to /// suppress and their residuals intermodulate in the clipper into products that are /// not harmonics of the input. This object is a **source**. Nothing is zero-stuffed /// on the way up; the detector simply runs fast, so there are no images at all — and -/// the sequence never reverses. Evidence for that hypothesis rather than proof of it -/// (the nonlinearity differs too), but it is the first evidence either way, and it -/// points the same direction. +/// the sequence never reverses. Same filters, no upsampler, no reversal, which was +/// the first evidence either way. +/// +/// **It was acted on, and it held.** `fuzz.h` now cascades one 2× stage per doubling +/// instead of zero-stuffing by N once, and its reversal is gone: worst step-up past +/// 2× is a ratio of 1.017, and its 4× and 8× improved by two to four orders of +/// magnitude. This file needs no such change — it has no upsampler to fix — but the +/// cross-check is worth keeping, because it is why the change was made. /// /// Honest limits: /// - **This is not a circuit solve.** It is the published *reductions* of one: the diff --git a/notebooks/fuzz.ipynb b/notebooks/fuzz.ipynb index c3bcada..45f795f 100644 --- a/notebooks/fuzz.ipynb +++ b/notebooks/fuzz.ipynb @@ -34,10 +34,10 @@ "id": "ab2f98c2", "metadata": { "execution": { - "iopub.execute_input": "2026-08-16T15:48:08.196502Z", - "iopub.status.busy": "2026-08-16T15:48:08.196324Z", - "iopub.status.idle": "2026-08-16T15:48:08.614437Z", - "shell.execute_reply": "2026-08-16T15:48:08.612509Z" + "iopub.execute_input": "2026-08-17T22:20:45.005745Z", + "iopub.status.busy": "2026-08-17T22:20:45.005553Z", + "iopub.status.idle": "2026-08-17T22:20:45.388054Z", + "shell.execute_reply": "2026-08-17T22:20:45.386929Z" } }, "outputs": [], @@ -96,10 +96,10 @@ "id": "55661e28", "metadata": { "execution": { - "iopub.execute_input": "2026-08-16T15:48:08.617335Z", - "iopub.status.busy": "2026-08-16T15:48:08.617016Z", - "iopub.status.idle": "2026-08-16T15:48:08.785331Z", - "shell.execute_reply": "2026-08-16T15:48:08.784211Z" + "iopub.execute_input": "2026-08-17T22:20:45.390618Z", + "iopub.status.busy": "2026-08-17T22:20:45.390316Z", + "iopub.status.idle": "2026-08-17T22:20:45.544131Z", + "shell.execute_reply": "2026-08-17T22:20:45.543168Z" } }, "outputs": [ @@ -169,16 +169,16 @@ "id": "69e2f549", "metadata": { "execution": { - "iopub.execute_input": "2026-08-16T15:48:08.787360Z", - "iopub.status.busy": "2026-08-16T15:48:08.787162Z", - "iopub.status.idle": "2026-08-16T15:48:09.152316Z", - "shell.execute_reply": "2026-08-16T15:48:09.151169Z" + "iopub.execute_input": "2026-08-17T22:20:45.546190Z", + "iopub.status.busy": "2026-08-17T22:20:45.545971Z", + "iopub.status.idle": "2026-08-17T22:20:45.943821Z", + "shell.execute_reply": "2026-08-17T22:20:45.942449Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -239,10 +239,10 @@ "id": "f8eb603c", "metadata": { "execution": { - "iopub.execute_input": "2026-08-16T15:48:09.154321Z", - "iopub.status.busy": "2026-08-16T15:48:09.154136Z", - "iopub.status.idle": "2026-08-16T15:48:09.520788Z", - "shell.execute_reply": "2026-08-16T15:48:09.519882Z" + "iopub.execute_input": "2026-08-17T22:20:45.945953Z", + "iopub.status.busy": "2026-08-17T22:20:45.945746Z", + "iopub.status.idle": "2026-08-17T22:20:46.346155Z", + "shell.execute_reply": "2026-08-17T22:20:46.344844Z" } }, "outputs": [ @@ -307,16 +307,16 @@ "id": "8d265bab", "metadata": { "execution": { - "iopub.execute_input": "2026-08-16T15:48:09.523527Z", - "iopub.status.busy": "2026-08-16T15:48:09.523342Z", - "iopub.status.idle": "2026-08-16T15:48:10.351214Z", - "shell.execute_reply": "2026-08-16T15:48:10.350062Z" + "iopub.execute_input": "2026-08-17T22:20:46.348463Z", + "iopub.status.busy": "2026-08-17T22:20:46.348235Z", + "iopub.status.idle": "2026-08-17T22:20:47.267302Z", + "shell.execute_reply": "2026-08-17T22:20:47.265690Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -365,26 +365,39 @@ "clipper pair therefore runs oversampled, with an anti-image filter on the way up and a matching\n", "anti-alias filter before decimation.\n", "\n", - "The house pattern (`tap.ladder~`, `overdrive.h`) uses a **4th-order** Butterworth there. Measured\n", - "in this kernel it is not steep enough — fold energy at 4× came out *worse* than at 2× (1.7e-2\n", - "against 2.8e-3). Eighth order improves 4× by about 6×, and this file uses it.\n", + "Two things about the house pattern (`tap.ladder~`, `overdrive.h`) did not survive being measured\n", + "here, and the second took two attempts to see.\n", "\n", - "It does **not** make the sequence monotone, and the plot below is the honest picture: every\n", - "factor beats no oversampling by orders of magnitude, and **2× measures best**, which is why 2×\n", - "is the default rather than the largest factor. The cause is not established. The obvious\n", - "suspect — biquads going ill-conditioned at the low normalized cutoffs a high factor needs\n", - "(0.056 at 8×) — was tested and ruled out: the cascade's impulse response decays cleanly to\n", - "denormal at every factor. The untested next hypothesis is imaging (zero-stuffing by N leaves\n", - "N−1 images for one filter to suppress, and residuals intermodulate in the clipper into exactly\n", - "the non-harmonic products this probe measures), which would point at cascaded 2× resampling as\n", - "the fix.\n", + "**The 4th-order Butterworth is not steep enough.** Fold energy at 4× came out *worse* than at 2×\n", + "(1.7e-2 against 2.8e-3). Eighth order improves 4× by about 6×, and this file uses it.\n", "\n", - "Measuring this correctly took two tries, and both mistakes are easy to repeat:\n", + "**The single zero-stuff-by-N is what made more oversampling worse.** Eighth order did not fix the\n", + "ordering — 2× still beat 4× beat 8× — and the surviving hypothesis was imaging: zero-stuffing by\n", + "N leaves N−1 images for one filter to suppress, at a corner that gets tighter with N (0.056\n", + "normalized at 8×), and residuals entering the clipper intermodulate into exactly the non-harmonic\n", + "products this probe measures. `ondes.h` supplied the first evidence for it, running the same\n", + "filters around a comparably hard nonlinearity but as a *source* with nothing zero-stuffed, and\n", + "never reversing.\n", + "\n", + "Acting on it confirms it. The chain is now **cascaded 2×**: one zero-stuff-by-two and one\n", + "8th-order Butterworth per doubling, each cutting at 0.225 of its own output rate — a corner that\n", + "never gets tighter however deep the cascade goes. The reversal is gone at every tone below.\n", + "\n", + "**And the old conclusion was generalized from one probe.** Every earlier number came from\n", + "3733 Hz, where 2× happens to look best. Swept across tones, 2× collapses above about 6 kHz — at\n", + "10.5 kHz it is *worse than no oversampling at all*, because the clipper's low harmonics already\n", + "exceed the base Nyquist and one doubling does not move them out of the way. That is why the\n", + "default is now **4×** rather than 2×.\n", + "\n", + "Measuring this correctly took three tries, and all three mistakes are easy to repeat:\n", "\n", "* **The test tone must not divide the sample rate.** At 3 kHz into 48 kHz, every alias folds\n", " back exactly onto a harmonic of the input and is invisible.\n", "* **Probes must sit far from the fundamental**, or they measure window leakage from it rather\n", - " than aliasing." + " than aliasing.\n", + "* **One tone is not a sweep.** The probe only measures folding at all when harmonics 8–13 exceed\n", + " Nyquist, and which of them fold — and how badly a given factor handles them — depends entirely\n", + " on where the tone sits. A conclusion from a single tone is a conclusion about that tone." ] }, { @@ -393,18 +406,18 @@ "id": "5d6dcfdf", "metadata": { "execution": { - "iopub.execute_input": "2026-08-16T15:48:10.353688Z", - "iopub.status.busy": "2026-08-16T15:48:10.353380Z", - "iopub.status.idle": "2026-08-16T15:48:10.664303Z", - "shell.execute_reply": "2026-08-16T15:48:10.663130Z" + "iopub.execute_input": "2026-08-17T22:20:47.269561Z", + "iopub.status.busy": "2026-08-17T22:20:47.269299Z", + "iopub.status.idle": "2026-08-17T22:20:49.124354Z", + "shell.execute_reply": "2026-08-17T22:20:49.122949Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -414,18 +427,29 @@ "name": "stdout", "output_type": "stream", "text": [ - "1x: 1.228e-01\n", - "2x: 2.659e-05 ( 4618x better than 1x)\n", - "4x: 7.399e-04 ( 166x better than 1x)\n", - "8x: 1.774e-03 ( 69x better than 1x)\n" + " tone 1x 2x 4x 8x\n", + " 3067 7.813e-02 9.985e-04 9.116e-04 8.904e-04\n", + " 3733 1.228e-01 3.003e-05 2.136e-05 2.172e-05\n", + " 4409 1.410e-01 8.555e-07 3.669e-07 3.697e-07\n", + " 5171 1.485e-01 3.310e-04 2.036e-07 1.925e-07\n", + " 6421 8.466e-02 3.180e-02 3.935e-07 3.616e-07\n", + " 7211 1.026e-01 8.912e-02 4.541e-07 4.341e-07\n", + " 8123 9.009e-02 7.788e-02 1.116e-03 2.007e-05\n", + " 9337 9.103e-02 8.096e-02 1.785e-06 2.386e-08\n", + " 10499 1.492e-01 1.725e-01 1.171e-05 1.587e-06\n", + "\n", + "probe floor (nearly clean): 4.8e-11 to 1.5e-09\n", + "worst step-up ratio past 2x: 1.017 (1.0 = flat; >1 would be a reversal)\n" ] } ], "source": [ - "f0 = 3733.0 # deliberately not a submultiple of the sample rate\n", + "# Harmonics 8..13 only fold at all above ~3 kHz, so the sweep starts there.\n", + "tones = [3067.0, 3733.0, 4409.0, 5171.0, 6421.0, 7211.0, 8123.0, 9337.0, 10499.0]\n", + "factors = [1, 2, 4, 8]\n", "\n", - "def alias_energy(os):\n", - " y = pedal(gain=1.0, edge=1.0, oversample=os).process(tone_in(f0, amp=0.5))\n", + "def alias_energy(os, f0, gain=1.0, edge=1.0):\n", + " y = pedal(gain=gain, edge=edge, oversample=os).process(tone_in(f0, amp=0.5))\n", " f, m = spectrum(y)\n", " total = 0.0\n", " for k in range(8, 14):\n", @@ -437,18 +461,29 @@ " total += at(fold, f, m) ** 2\n", " return np.sqrt(total)\n", "\n", - "factors = [1, 2, 4, 8]\n", - "energies = [alias_energy(o) for o in factors]\n", + "table = np.array([[alias_energy(o, f0) for o in factors] for f0 in tones])\n", "\n", - "fig, ax = plt.subplots()\n", - "ax.semilogy(factors, energies, color=C[0], marker=\"o\", ms=6)\n", + "# The probe's own floor: the same measurement with the pedal nearly clean.\n", + "floor = np.array([[alias_energy(o, f0, gain=0.0, edge=0.0) for o in factors] for f0 in tones])\n", + "\n", + "fig, ax = plt.subplots(figsize=(7.2, 3.4))\n", + "for row, f0 in zip(table, tones):\n", + " ax.semilogy(factors, row, marker=\"o\", ms=4, lw=1.2,\n", + " color=plt.cm.viridis(0.1 + 0.8 * tones.index(f0) / (len(tones) - 1)))\n", + "ax.axhspan(floor.min(), floor.max(), color=\"0.85\", zorder=0)\n", + "ax.text(4.2, floor.max() * 1.15, \"the probe's own floor (pedal nearly clean)\", fontsize=8.5, color=\"0.35\")\n", + "ax.text(1.05, table[-1][0] * 0.55, \"3.1 kHz (bottom) to 10.5 kHz (top)\", fontsize=8.5, color=\"0.35\")\n", "ax.set_xticks(factors)\n", "ax.set_xlabel(\"oversample factor\"); ax.set_ylabel(\"energy at fold frequencies\")\n", - "ax.set_title(\"aliasing against oversampling — every factor helps; 2x measures best\")\n", + "ax.set_title(\"cascaded 2x: more is never worse, and 2x is not enough above 6 kHz\")\n", "plt.show()\n", "\n", - "for o, e in zip(factors, energies):\n", - " print(f\"{o}x: {e:.3e}\" + (\"\" if o == 1 else f\" ({energies[0] / e:>5.0f}x better than 1x)\"))" + "print(f\"{'tone':>7} \" + \" \".join(f\"{o}x\".rjust(9) for o in factors))\n", + "for f0, row in zip(tones, table):\n", + " print(f\"{f0:7.0f} \" + \" \".join(f\"{v:.3e}\" for v in row))\n", + "print(f\"\\nprobe floor (nearly clean): {floor.min():.1e} to {floor.max():.1e}\")\n", + "worst_ratio = max((table[i][j + 1] / table[i][j]) for i in range(len(tones)) for j in range(1, 3))\n", + "print(f\"worst step-up ratio past 2x: {worst_ratio:.3f} (1.0 = flat; >1 would be a reversal)\")" ] }, { @@ -465,8 +500,10 @@ "- `asymmetry` is the even-harmonic control, and it costs no DC: silence stays exactly silent.\n", "- The voicing section is three linear filters outside the nonlinearity.\n", "- Oversampling buys orders of magnitude against none, with an 8th-order filter because the\n", - " house 4th-order one measured worse at higher factors — but bigger is not better here, 2×\n", - " measures best, and why that is remains open.\n", + " house 4th-order one measured worse at higher factors, and a **cascade of 2× stages** because\n", + " a single zero-stuff-by-N was what made 4× and 8× measure worse than 2×. With the cascade the\n", + " sequence never reverses. The default is 4×, because the old default of 2× was generalized\n", + " from a single test tone and collapses above about 6 kHz.\n", "\n", "Every number above lives twice: as a cell in this notebook and as a pinned scenario in\n", "`tests/fuzz_test.cpp`." diff --git a/tests/fuzz_test.cpp b/tests/fuzz_test.cpp index b242195..3ac0df2 100644 --- a/tests/fuzz_test.cpp +++ b/tests/fuzz_test.cpp @@ -195,27 +195,32 @@ SCENARIO("asymmetry is what puts even harmonics in the spectrum") { // thing being measured. // // What is asserted is what is true: oversampling drops aliasing by two orders of magnitude -// against no oversampling. It is deliberately NOT asserted that 8x beats 2x — measured, the -// residual above 2x sits around -60 dB where filter numerics and window leakage dominate, and a -// test that pinned an ordering there would be pinning noise. +// against no oversampling. Since the resampler became a cascade of 2x stages it is also true +// that more is never meaningfully worse, and that IS asserted below — it is the property the +// cascade was built to deliver, and the single zero-stuff-by-N chain it replaced failed it. +// +// A third thing is asserted that the old chain would have passed while being broken: that 4x +// works at a *high* tone. Every number in the original write-up came from 3733 Hz alone, and +// 2x happens to look best there; swept properly, 2x collapses above about 6 kHz. One probe is +// not a sweep. SCENARIO("oversampling drops the aliased energy by orders of magnitude") { const double f0 = 3733.0; // deliberately not a submultiple of the sample rate - auto alias_floor = [&](int os) { + auto alias_floor = [&](int os, double tone) { pedal p = make(); p.set_gain(1.0); p.set_edge(1.0); p.set_oversample(os); - const std::vector y = render(p, f0, 0.5, 0.4); + const std::vector y = render(p, tone, 0.5, 0.4); const size_t b = at(0.2), e = at(0.4); - // Where harmonics 8..13 of f0 fold back, skipping any fold that lands near the + // Where harmonics 8..13 of the tone fold back, skipping any fold that lands near the // fundamental (those probes read leakage, not aliasing). double acc = 0.0; for (int k = 8; k <= 13; ++k) { - double f = k * f0; + double f = k * tone; while (f > k_sr * 0.5) { f = (f > k_sr) ? f - k_sr : k_sr - f; } - if (std::abs(f - f0) < 1000.0) { + if (std::abs(f - tone) < 1000.0) { continue; } const double m = goertzel(y, f, b, e); @@ -224,15 +229,28 @@ SCENARIO("oversampling drops the aliased energy by orders of magnitude") { return std::sqrt(acc); }; - const double none = alias_floor(1); - const double two = alias_floor(2); - const double four = alias_floor(4); - const double eight = alias_floor(8); - INFO("alias energy: 1x = " << none << ", 2x = " << two << ", 4x = " << four << ", 8x = " << eight); + const double none = alias_floor(1, f0); + const double two = alias_floor(2, f0); + const double four = alias_floor(4, f0); + const double eight = alias_floor(8, f0); + INFO("alias energy at " << f0 << ": 1x = " << none << ", 2x = " << two << ", 4x = " << four << ", 8x = " << eight); REQUIRE(none > 0.05); // the test material really does alias when nothing is done REQUIRE(two < none * 0.05); // and oversampling really does fix it REQUIRE(four < none * 0.05); REQUIRE(eight < none * 0.05); + + // The cascade's promise: the sequence never reverses. A 15 % tolerance, because past 2x the + // readings sit within about an order of magnitude of the probe's own floor (4e-5 to 1.5e-4 + // with the pedal nearly clean) and pinning a tighter ordering there would pin noise. + REQUIRE(four <= two * 1.15); + REQUIRE(eight <= four * 1.15); + + // And the reason the default moved to 4x: one doubling is not enough for a bright input, + // where the clipper's low harmonics already exceed the base Nyquist. + const double bright_two = alias_floor(2, 6421.0); + const double bright_four = alias_floor(4, 6421.0); + INFO("alias energy at 6421: 2x = " << bright_two << ", 4x = " << bright_four); + REQUIRE(bright_four < bright_two * 0.1); } SCENARIO("the tone stack moves the band it says it moves") { From 8b15302a4e1e61647a4f2ec32ef4be17347071d8 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 17 Aug 2026 22:40:55 +0000 Subject: [PATCH 22/22] Add three Radiohead-family recipes, and record the register source hunt The recipes are what make the family a rig rather than nine objects: - recipes/tape-and-stutter.md -- fuzz into stutter into tape echo, and why that order (a stutter of a distorted signal is a stutter; a distortion of a stuttered signal amplifies every slice edge). Carries the occupancy numbers, the seed contract, the bitwise bypass at density 0, and the material contract. - recipes/scrub-pad.md -- the two-axis controller the object needs before it means anything, freeze as a six-step performance, and the one real constraint (keep the position at least size*(rate-1) back, or the grain tail runs off the front of the tape). - recipes/ondes-rig.md -- the assembled instrument. Most of its length is the two hands rather than the settings, because the ribbon being linear in semitones and the key's bottom 45 % being silent are the two facts that decide whether it sounds like an ondes or like a synthesizer. Writing them caught a documentation error the chapters had missed: a first draft set the stutter's jump to 0.15, reading it as a probability like reverse. It is milliseconds. Recipes are the only part of the book that must name every control with a legal value, so they check the reference pages in a way prose does not -- noted in the drafting record. Also records the second waveform-register source hunt in PLAN-ondes.md. It did not close the gate, but it leaves the next attempt further along: Leipp's Bulletin du GAM n.60 (1972) is confirmed to exist and to be held in the Catgut archive but is digitized nowhere reachable; the ribbon-oscillator companion paper is out of scope by its own title; and the best new lead is the patents (the 1928 "Perfectionnements aux instruments de musique electriques" and FR 841.128 of 1939), which are published, expired and schematic-bearing but which Google Patents and Espacenet both refused to serve here. The abundant hobbyist descriptions of the register waveforms are recorded as a trap rather than a source: none is published literature and none gives a filter shape, so implementing from them would break both the IP policy and the promise the header makes. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_018HKD7onDgpfjRi2PA8mhn5 --- book/PLAN-ondes.md | 42 +++++-- book/PLAN-radiohead-chapters.md | 17 ++- book/src/SUMMARY.md | 3 + book/src/recipes/ondes-rig.md | 158 +++++++++++++++++++++++++++ book/src/recipes/scrub-pad.md | 135 +++++++++++++++++++++++ book/src/recipes/tape-and-stutter.md | 148 +++++++++++++++++++++++++ 6 files changed, 492 insertions(+), 11 deletions(-) create mode 100644 book/src/recipes/ondes-rig.md create mode 100644 book/src/recipes/scrub-pad.md create mode 100644 book/src/recipes/tape-and-stutter.md diff --git a/book/PLAN-ondes.md b/book/PLAN-ondes.md index 4e61531..d1709f0 100644 --- a/book/PLAN-ondes.md +++ b/book/PLAN-ondes.md @@ -5,7 +5,8 @@ > and the heterodyne source 2026-08-17 as `tap.triode~` and `tap.ondes~`. The book chapters > followed the same day — `book/src/ondes.md` (voice, triode and intensity key together) and > `book/src/diffuseurs.md`, plus `machine/ondes.md` and `machine/diffuseur.md`. What remains is -> the waveform registers, which are still unsourced (see the last section). +> the waveform registers, which are still unsourced — a second hunt on 2026-08-17 failed to +> close the gate but left two concrete leads (see the last section). > The source gate is closed — > `PLAN-radiohead-family.md` §3 records what was found and how far each paper was read. This > file is the design pass those findings forced, written before any code, because what the @@ -219,12 +220,39 @@ delivers value before the flagship is finished. - Modal data for either diffuseur specific to the instrument — falling back to Fletcher & Rossing for the general plate/string physics, which is a recreation rather than a model, and must be labelled as such. -- The waveform-register filter shapes. The circuit paper covers five stages but not the timbre - registers in detail; Leipp (*Bulletin du GAM* n°60, 1972) and Laurendeau's monograph are the - next places to look, neither yet obtained. If they do not settle it, the registers are a - recreation voiced by ear and the header says so. **This is now the only thing standing between - `tap.ondes~` and a complete instrument**, and the header states its absence rather than filling - it with invention. +- The waveform-register filter shapes. **This is the only thing standing between `tap.ondes~` + and a complete instrument**, and the header states its absence rather than filling it with + invention. A second source hunt ran 2026-08-17 and **did not close the gate**; what it found + is below, so the next attempt starts further along rather than repeating it. + + *Confirmed to exist, not obtainable from here:* + - **Leipp, "Les ondes Martenot", *Bulletin du GAM* n°60, April 1972.** The citation is real — + it appears in an academic bibliography, and the Catgut Acoustical Society Library holds 45 + GAM issues (1963–1978) as a physical archive. Nothing is digitized anywhere reachable. This + needs a library request, not a search. + - **Laurendeau, *Maurice Martenot, luthier de l'électronique* (1990).** A print monograph; not + obtained. + + *Ruled out as sources for this:* + - The TASLP circuit paper, read in full: five stages, and the registers are not among them. + - Its companion, "Simulation of the Ondes Martenot **Ribbon-Controlled Oscillator**" + (HAL hal-02425249) — the title is the scope. + + *New lead, and the best one: the patents.* Martenot's 1928 "Perfectionnements aux instruments + de musique électriques" and **FR 841.128 (February 1939)**. Patents are exactly the right class + of source here — published, long expired, schematic-bearing, and IP-clean in a way a blog never + is. Google Patents and Espacenet both refused to serve this environment (503 / access denied), + so they remain unread. **Try these first next time, from a machine that can reach them.** + + *And the trap to avoid.* Hobbyist and encyclopedic descriptions of the register *waveforms* are + abundant and broadly consistent — creux as a peak-limited triangle, gambe as a pulse at roughly + 35/65 duty, nasillard as a very narrow pulse, octaviant as an added octave, petit gambe as + gambe lowpassed, souffle as noise, feutré as a softening filter. Every one of those is a blog, + a forum, a retailer's history page, a performer's site or a replica manual; none is published + literature and **none gives a filter shape, a corner, or a component value**. Implementing from + them would break the published-literature-only policy *and* the promise the header makes, to + buy a register set that would be guesswork wearing the instrument's vocabulary. Not done, on + purpose. - **Where the intensity key sits in the chain.** The paper's five stages do not include it, so `tap.ondes~` offers both readings as a switch (`key_placement`): after the valves it is a clean output law, before them the dirt comes up with the pressure. Measured, the difference is real diff --git a/book/PLAN-radiohead-chapters.md b/book/PLAN-radiohead-chapters.md index 677ce8c..b68da98 100644 --- a/book/PLAN-radiohead-chapters.md +++ b/book/PLAN-radiohead-chapters.md @@ -313,8 +313,17 @@ restating the header. ## Still deliberately not covered -- **A recipes entry.** Now genuinely earnable — `tap.ondes~` → `tap.palme~` with the ribbon - and key on signals is a rig, and the scrub into a diffuseur is another. Deferred rather than - declined: `recipes/` entries are whole patches with patcher-level detail, and that is a - separate piece of work from the chapters. +- ~~**A recipes entry.**~~ — ✅ written 2026-08-17, three of them, appended to Part XI: + `recipes/tape-and-stutter.md` (the fuzz → stutter → echo rig, and why that order), + `recipes/scrub-pad.md` (the two-axis controller, freeze as a performance, and the grain/live-edge + constraint), and `recipes/ondes-rig.md` (the assembled instrument, where most of the length goes + to the two hands rather than the settings, because the ribbon being linear in semitones and the + key's bottom 45 % being silent are the two facts that decide whether it sounds like an ondes). + Between them they name all nine family objects. + + One process note worth keeping: writing them **caught a documentation error the chapters had + missed**. A first draft set the stutter's `jump` to 0.15, reading it as a probability like + `reverse`; it is milliseconds. Recipes are the only part of the book that has to name every + control with a legal value, so they check the reference pages in a way prose never does. Verify + a recipe's controls against `docs/*.maxref.xml` before committing it. - **The Max-side surface**, and **comparative listening claims**. Unchanged. diff --git a/book/src/SUMMARY.md b/book/src/SUMMARY.md index 7913576..e1d7e61 100644 --- a/book/src/SUMMARY.md +++ b/book/src/SUMMARY.md @@ -95,3 +95,6 @@ - [Sixteenths into a listening filter](recipes/funk-filter.md) - [A field guide to rooms](recipes/rooms.md) - [Chords with no keyboard](recipes/comb-drones.md) +- [The part that comes apart, on tape](recipes/tape-and-stutter.md) +- [Two hands on a live buffer](recipes/scrub-pad.md) +- [The instrument in the corner of the room](recipes/ondes-rig.md) diff --git a/book/src/recipes/ondes-rig.md b/book/src/recipes/ondes-rig.md new file mode 100644 index 0000000..64cdc17 --- /dev/null +++ b/book/src/recipes/ondes-rig.md @@ -0,0 +1,158 @@ +# The instrument in the corner of the room + +The Ondes Martenot is not a synthesizer, and the fastest way to make it +sound like one is to patch it like one. This recipe assembles the four +objects that make up the actual instrument — voice, key, and a loudspeaker +with a body — and then spends most of its length on the part that is not +a setting at all: what your two hands do. + +Everything measured here is borrowed from [the instrument that is not a +synthesizer](../ondes.md) and [loudspeakers you can +play](../diffuseurs.md), which in turn cite the circuit paper (Najnudel, +Hélie, Roze & Boutin, IEEE/ACM TASLP 28, 2020) and the intensity-key +measurement (Quartier et al., *Acta Acustica* 101(2), 2015). + +## The chain + +```text +[ribbon signal] ──▶ tap.ondes~ ──▶ tap.palme~ ──▶ out +[key signal] ──▶ ▲ (or tap.metallique~) +``` + +Two signals in, one instrument out. That is the whole rig, and the +temptation to put things between the stages should be resisted until you +have played it as it stands — the voice and the diffuseur were designed to +be adjacent, and every stage you insert is a stage the real instrument does +not have. + +## The voice + +| control | setting | why | +|---|---|---| +| `ribbon` | driven by signal | semitones above A1, not Hz | +| `key` | driven by signal | 0–1 of the physical travel | +| `depth` | `1.` | equal oscillators; the full harmonic series | +| `detect` | `0.2` | the published R4 × C21, 200 µs | +| `drive` | `1.` | nominal; the harmonics are already there | +| `keyplacement` | `0` | pressure is level | +| `polarity` | `1` | | +| `power` | `0` | the 2A3 moves total harmonics by 0.003 | +| `oversample` | `4` | | +| `smooth` | `0.` | the signal inlets are not ramped anyway | + +Start there and change exactly one thing at a time, because most of these +are citations rather than tastes and the object will tell you when you have +left the instrument behind. + +The two that are genuinely yours: `keyplacement 1` moves the key in front +of the valves, so hard presses get dirty as well as loud — worth about 0.09 +of total harmonic content at a half-press, and it is the single change that +most makes the object feel like a synthesizer rather than an ondes. +`polarity -1` flips which side of the waveform the preamplifier bends, +worth about 0.12. Try both; keep whichever suits the piece. + +`depth` below 1 is the cheapest real timbre move in the object. At `0.4` +the envelope never closes and the tone thins toward a sinusoid — the +closest thing here to a "register", and it is a physical mismatch between +two oscillators rather than an invented control. + +## The hands + +This is the recipe. + +**The ribbon is linear in semitones**, because the circuit paper's Eq. 7 +makes it so. That single fact is why an ondes glissando sounds like an +ondes glissando: a hand moving at constant speed produces a constant-rate +glide, not the accelerating swoop a linear-in-Hz control gives you. So +drive `ribbon` with something that moves *linearly in semitones over time*: + +```text +line~ 0. 36. 4000 ──▶ tap.ondes~ left inlet +``` + +Three octaves in four seconds, and it will sound even the whole way. Build +your phrases the same way — `line~` or a slow `sig~` ramp per note, never a +quantized step unless you specifically want the instrument to sound wrong. +Nothing here rounds to a semitone, and that is deliberate. + +**The key is the dynamics, and it starts silent.** Roughly the bottom 45 % +of the travel makes no sound at all. That is the key's own first phase, the +elastic strip bending before it reaches the powder bag, and it is why the +instrument attacks so sharply: the whole 50 dB lives in the 4.5 mm right +after the silence. Practically: + +- Drive `key` from a pedal, a fader, or a `line~` — anything continuous. +- Expect nothing below about `0.45`. If you want the note to speak the + instant your controller leaves zero, rescale: `scale 0. 1. 0.45 1.`. + Do that only if you want to give up the attack, because that dead travel + is what lets you place an entrance to the millisecond. +- The curve steepens through the middle and flattens at the top. Crescendos + therefore want a *decelerating* controller move, not a linear one — which + is exactly the feedback a player's finger gets from the real spring. + +**Play them together.** The ribbon without the key is a test tone; the key +without the ribbon is a volume pedal. The instrument is the two hands, and +`ondes_ribbon.wav` in the render set exists to demonstrate what that +sounds like when both are moving. + +## The loudspeaker, which is an instrument too + +`tap.palme~` is the default answer. Twelve strings on a board, and they +sustain what the voice has already stopped playing: + +| control | setting | +|---|---| +| `root` | `110.` — put the lowest string under your part's key | +| `tuning` | `0` chromatic, so the board answers every note | +| `decay` | `6.` | +| `damping` | `4000.` | +| `detune` | `4.` — cents of scatter, so the board is not a chorus unit | +| `drive` / `asymmetry` / `saturation` | `1.` / `0.3` / `0.2` | +| `mix` | `60` | + +`tuning 1` puts the harmonic series on the root instead: the board then +answers only what belongs to that key, which turns a chromatic line into +something that blooms on some notes and stays dry on others. Use it when +the piece really is in one key, and hear it as a compositional decision +rather than a preset. + +Watch the level. Twelve resonant loops add up, and a driven board can be a +great deal louder than what went into it — `level` is there for that, and +it is the one control on these objects you will need to touch first. + +`tap.metallique~` is the other cabinet: eight plate modes rather than +twelve strings, so it colours instead of harmonizing. +`@pitch 180 @decay 6 @tilt 0.8 @brightness 1. @mix 50` is the gong. Push +`drive` to 3 with `asymmetry 0.5` and the distortion happens *before* the +plate, because that is where the transducer is — a distorted waveform +ringing a gong, not a distorted gong. It is not subtle and it is the most +distinctive sound in the family. + +## What each ingredient buys, in order + +1. **`tap.ondes~` with both hands moving.** Everything else is optional. + A static ribbon and a static key is a demo, not an instrument. +2. **The diffuseur.** The voice alone is thin on purpose — it is a valve + preamplifier output, and it was never meant to be heard without a body + after it. +3. **`depth`.** The one timbre control that costs nothing and is physical. +4. **`keyplacement` / `polarity`.** Real, measured, and yours to choose. +5. **`power`.** Measured at 0.003 of total harmonic content. Last. + +## When to leave the recipe + +- **You want the waveform registers.** The real instrument has switchable + timbres — creux, gambe, nasillard and the rest. They are not here, and + they are not here on purpose: no source obtained describes their filter + shapes, and inventing them is the one thing these objects will not do. + If you need those colours, put a filter after `tap.ondes~` and call it + your filter, not Martenot's. +- **You want polyphony.** The instrument is monophonic and so is this. Two + `tap.ondes~` in parallel is a duet, not a chord — which is how ondes + ensembles actually worked, so it is not a bad answer. +- **You want the diffuseurs on something else.** Take them. A guitar into + `tap.palme~` is the best argument for shipping them standalone, and + nothing about them needs the voice in front. +- **You want `tap.triode~` on its own.** It is a published valve stage and + it works on anything: `@tube 2 @stage 2 @drive 6` is the 2A3 power stage + used for something it was never in this instrument for. diff --git a/book/src/recipes/scrub-pad.md b/book/src/recipes/scrub-pad.md new file mode 100644 index 0000000..e59db22 --- /dev/null +++ b/book/src/recipes/scrub-pad.md @@ -0,0 +1,135 @@ +# Two hands on a live buffer + +`tap.scrub~` is the object in this library that most needs a controller +attached before it means anything. Everything below assumes one: an XY pad, +two faders, a trackpad, a phone sending OSC — anything that gives you two +continuous values at once. The recipe is mostly about what to put on each +axis and why. + +Measured claims are borrowed from [two hands on the same +tape](../scrub.md). + +## The chain + +```text +source ──┬─▶ tap.scrub~ ──▶ tap.palme~ ──▶ out + └────── (its own dry path, via mix) ──────▶ +``` + +The scrub records what passes through it, so it goes *in* the signal path +rather than on a send — there is nothing to send it that it is not already +hearing. Its `mix` is the dry/wet, and at `mix 0` it is the input bit for +bit, which means you can leave it in the chain permanently and have it be +audibly absent until you touch it. + +## The pad + +| control | setting | +|---|---| +| `maxhistory` | `4.` s (object argument; bought at DSP start) | +| `position` | **X axis**, 0–1500 ms | +| `pitch` | **Y axis**, −12 to +12 st | +| `drift` | `0.` | +| `size` | `80.` ms | +| `overlap` | `2` | +| `spray` | `0.` | +| `mix` | `100` while playing | +| `smooth` | `0.` if driving by signal, `20.` if by messages | + +**X is position, Y is pitch, and the whole object exists because those are +independent.** On tape they would be the same axis — moving the head *is* +the pitch change. Here you can rake back through the last second and a half +at the pitch you started at, or hold still and transpose, or do both at +once in different directions. Spend the first five minutes doing each +separately; the object does not become obvious until you have felt that +they do not interact. + +**`size` is the texture control.** 80 ms is a granular pad. Down at 20 ms +it turns metallic and starts pitching itself at the grain rate; up at +200 ms it stops being granular and becomes a soft varispeed. Sizes that +divide evenly by `overlap` have an exactly flat window sum — 80 with +overlap 2 does — which matters when you want the still position to be +clean. + +**`overlap 1` is a texture, not a mistake.** It leaves gaps between grains: +a gated, chopped version of the same gesture. Worth a switch on the +controller. + +## The honest bit about pitch + +Transposing here warbles, and it is measured rather than apologized for: +98.8 % of a perfect shifter's energy lands within ±15 Hz of the transposed +pitch (worst case 91.7 %), so the *note* is right — what the object loses +is concentration, 92.0 % as focused as a clean shift and 75.0 % at worst. +Audibly that is a warble, and it is the classic single-delay-line +pitch-shifting artifact rather than anything peculiar to this kernel. + +Two ways to work with it: + +- **Lean in.** `spray 30.` trades the narrow comb for a broadband smear. + On sustained material this reads as a texture rather than a fault, and it + is the better answer for pads. +- **Stay out of its way.** Keep the Y axis to ±7 and let the position do + the work. Small intervals warble least and the object is a scrub pad + first. + +If you need a clean shift, this is the wrong object — `tap.shift~` is built +for it. (`tap.pitchaccum~` is built for shimmer rather than transparency, +and has [an open issue](https://github.com/tap/TapTools/issues/33) about +where its line actually sits.) + +## Freeze, which is the other half + +`freeze 1` stops the recorder. The playhead keeps going, so the position +now addresses fixed tape and the grains loop the same window — and you can +still scrub, transpose, drift and spray through it. Nothing is going into +the input any more, which is the point: it is a hold you can perform. + +A sequence that works on stage: + +1. Play the phrase through at `mix 0`. Nothing happens; the tape fills. +2. `mix 100`, `freeze 1`. The last few seconds are now the instrument. +3. Drag X slowly. This is the scrub. +4. `drift -0.3`. The playhead walks backwards on its own while you keep + your hand free for Y. +5. `spray 40.`, `size 200.`. It stops being a phrase and becomes a pad. +6. `freeze 0`, `mix 0`. The room comes back. + +Step 6 is exact — `mix 0` is bitwise passthrough — so the return is clean +however far out step 5 went. + +## The one constraint + +A grain born `position` behind the live edge and playing at rate *r* +reaches `position − size·(r−1)` behind it by its end. Transpose *up* with +the position near the live edge and the grain's tail runs off the front of +the tape into the oldest material — a seam. + +Nothing clamps it, because clamping would silently bend the pitch to keep +the grain in bounds, which is a worse failure than the seam. Practically: +**keep the position at least `size·(rate−1)` back**. At `size 80` and one +octave up that is 80 ms. Setting the X axis to start at 100 ms rather than +0 makes the whole problem disappear, and this is why the table above says +0–1500 rather than 0–1500 starting at zero. + +## What each ingredient buys, in order + +1. **A controller with two continuous axes.** Without it this is a delay. +2. **`freeze`.** The half of the object you can build a performance on. +3. **`size`.** The texture, and the only control that changes what kind of + thing you are playing. +4. **A diffuseur after it.** `tap.palme~ @mix 40` sustains what the scrub + chops; the strings fill the gaps that `overlap 1` opens. +5. **`spray`.** Trades one artifact for another. Real, and last. + +## When to leave the recipe + +- **You want it in time.** Nothing here syncs. That is `tap.stammer~`, on + the same tape — literally the same `capture` code — and the two are + meant to be swapped between rather than combined. +- **You want a clean delay.** `tap.delay~` costs a fraction as much and + windows nothing. +- **You want the position to feel like a jog wheel.** Put `drift` on a + spring-loaded control and leave `position` alone: drift is velocity where + position is location, and for wheel-like gestures velocity is the right + variable. diff --git a/book/src/recipes/tape-and-stutter.md b/book/src/recipes/tape-and-stutter.md new file mode 100644 index 0000000..2c79df9 --- /dev/null +++ b/book/src/recipes/tape-and-stutter.md @@ -0,0 +1,148 @@ +# The part that comes apart, on tape + +Three objects and one posture: hands on the controls while it runs. The +stutter takes a phrase apart, the tape echo smears the pieces, and the fuzz +decides how hard the whole thing is being pushed. None of the three has a +"right" setting, which is the point of the part of the book they live in. + +This recipe is a rig, not a record. What is documented about the Kid A-era +working method is that a laptop running Max sat in the signal path and got +played — the objects here are informed by *what that rig was for*, not by +anyone's patch. Nothing below is claimed to be a reconstruction of a +specific track. + +Measured claims are borrowed from [four heads and a +motor](../tapecho.md), [the part that comes apart](../stammer.md) and +[the dirt with two stages](../fuzz.md). + +## The chain + +```text +source ──▶ tap.fuzz~ ──▶ tap.stammer~ ──▶ tap.tapecho~ ──▶ out +``` + +Order matters, and this order is the useful one: + +- **Fuzz first**, because a stutter of a distorted signal is a stutter; a + distortion of a stuttered signal turns every slice edge into a transient + the clipper amplifies. +- **Echo last**, because the echo is the only object here that is supposed + to blur. Put it before the stutter and the stutter slices the blur, which + sounds like a mistake rather than a decision. + +## The dirt + +Keep it low. Two saturators in series get muddy fast, and the echo has its +own `drive`. + +| control | setting | +|---|---| +| `gain` | `0.35` | +| `edge` | `0.3` | +| `asymmetry` | `0.2` | +| `bass` / `treble` / `contrast` | `0.` / `0.1` / `0.3` | +| `oversample` | `4` | +| `level` | to taste, usually negative | + +`contrast` is the scoop, and a scooped source stutters better than a +mid-heavy one — the slices stop fighting the vocal or the guitar they came +from. Leave `oversample` at 4 and resist the urge to save the cycles at 2: +a hard `edge` on bright material is exactly the case where one doubling +stops being enough, and 2 measures badly above about 6 kHz. + +## The stutter + +| control | setting | what it does | +|---|---|---| +| `step` | `60.` ms | the grid | +| `divisions` | `1` | | +| `density` | `0.3` | how often it grabs | +| `repeats` | `4` | how long it holds | +| `reverse` | `0.2` | chance a repeat plays backwards | +| `jump` | `250.` ms | how far back a slice may reach | +| `fade` | `2.` ms | the flanks | +| `seed` | any integer | | +| `mix` | `100` | | + +**The one thing to internalize: `repeats` is the hold, `density` is the +grab.** Occupancy — how much of the timeline has a slice in flight — +measures 41 % at density 0.3 / repeats 1 and **90 %** at density 0.9 / +repeats 1, but density 0.3 with repeats 6 already sits at 76 %. If the part +feels too busy, pull `repeats` before you touch `density`; you will keep +the sparseness of the *entrances* while shortening what each one does. + +`seed` is a contract, not a flavour: the same seed and the same moves give +a bit-identical render, and two instances on two tracks decorrelate by seed +alone. Different seeds change 89 % of samples, so it is a real dice roll, +not a phase tweak. + +At `density 0.` the object is a bitwise bypass — worth knowing, because it +means you can automate density to zero and get the dry signal back exactly, +with no crossfade artifact to work around. + +**The material contract.** This object flatters a played phrase and +flatters a sustained note far too much. Slice similarity measures 1.000 on +a held sine against 0.286 on a plucked phrase: on sustained material every +slice is interchangeable, so the stutter has nothing to expose and sounds +like a tremolo. Feed it something with transients and pitch variety. + +## The tape + +| control | setting | +|---|---| +| `span` | `400.` ms | +| `heads` | `3` | +| `ratios` | `0.25 0.5 1.` | +| `levels` | `0.7 0.85 1.` | +| `pans` | `0.2 0.8 0.5` | +| `regen` | `0.55` (the ride starts here) | +| `darken` | `5000.` | +| `drive` | `0.4` | +| `wow` / `flutter` | `0.4 0.35` / `0.3 8.` | +| `mix` | `35` | + +`span` is defined at the ratio-1.0 head, so the head at `1.` returns at +400 ms and the others at 100 and 200. Change `span` while it runs and the +whole thing glides like tape speed rather than splicing — that is the +transport, and it is the second-best gesture in this rig. + +The best one is `regen`. **It goes past 1 on purpose.** Past unity the line +self-oscillates, and it stays bounded because the saturator caps what comes +back: the ceiling is `|in|max + regen/drive`, measured under that value at +every drive tried. So a ride up to `1.4` and back is a controlled build, +not a fire. Keep `drive` up while you do it — `drive 0.` removes the +saturator and the cap falls back to unity, which is the setting where a +long ride will *not* behave. + +`darken` is the generation loss, and it is what makes repeats decay into a +shape instead of just getting quieter. 5 kHz is a good default; below 3 kHz +the tail turns to mud, which is sometimes what you want under a chorus. + +## The gestures, in order of value + +1. **Ride `regen` past unity and back**, while `mix` stays put. One hand, + whole arrangement. +2. **Automate `density` to 0 and back.** Exact bypass, so it reads as the + part reassembling rather than a fade. +3. **Move `span` during a held note.** Varispeed glide, not a splice. +4. **Change `seed` between takes**, never during one. +5. **`reverse` and `jump`.** Character, and cheap to overdo. Note `jump` is + *milliseconds*, not a probability — at 250 the machine starts quoting + material from a quarter-second before the slice it just took, which is + where a stutter stops sounding like a stutter and starts sounding like + an edit. + +## When to leave the recipe + +- **The source is sustained.** See the material contract. Put the stutter + on the drums and leave the pad alone. +- **You want the slices in time with something.** Nothing here syncs to a + transport; `step` is milliseconds. Drive it from your own clock if you + need bars. +- **You want the echo to stay clean.** `drive 0.` gets you a clean line — + but then do not ride `regen` past 1, because the cap that makes that safe + is the saturator you just removed. +- **You want the dirt to be the point.** Then the fuzz belongs last, not + first, and this is a different recipe: `tap.tapecho~` → `tap.fuzz~` with + the echo's own `drive` at 0. Distorting a wash is a real sound; it is + just not this one.