circuitpython-synthtools 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

{circuitpython_synthtools-0.7.0.dist-info → circuitpython_synthtools-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: circuitpython-synthtools
-Version: 0.7.0
+Version: 0.8.0
 Summary: CircuitPython helper library to do help doing synthio
 Author-email: Tod Kurt <tod@todbot.com>
 License: MIT
@@ -125,16 +125,17 @@ Usage Example
 What's Included
 ===============
 
+* ``Patch`` -- inert, JSON-able patch data; save/load with
+  ``save_patches()`` / ``load_patches()``
 * ``Synth`` -- synth engine base: shared voice, patch, and modulation handling,
-  with ``mono`` mode for a single-voice synth with ``glide_time``  portamento
+  complex filter & pitch envelopes, and a ``mono`` mode for a single-voice
+  synth with ``glide_time``  portamento
 * ``SubtractiveSynth`` -- subtractive two-oscillator synth w/ detune
+* ``WavetableSynth`` -- wavetable-playback with adjustable LFO for wave_pos
 * ``FMSynth`` -- two-operator phase-modulation voice: a carrier waveform
   pre-rendered from ``sin(theta + fm_index*sin(fm_ratio*theta))``.
   ``fm_ratio`` must be an integer; ``fm_index`` is PM depth in radians,
-  0 = plain single-oscillator. (Not a live audio-rate bend modulator --
-  synthio's Math/LFO blocks only update every 256 samples, too slow for
-  that; see the module docstring for why.)
-* ``WavetableSynth`` -- wavetable-playback with adjustable wave_pos
+  0 = plain single-oscillator. (Not a full FM synth, see module for details)
 * ``BasslineSynth`` -- TB-303-style acid bassline: monophonic, one
   oscillator, a decay-only filter sweep, per-step slide and accent. Can
   own its own filter/distortion/echo effects chain via ``fx_*`` patch
@@ -144,26 +145,24 @@ What's Included
   ``tracking_filter()`` builds extra filter stages that follow the synth's
   own cutoff and resonance for a steeper slope (needs ``audiofilters`` in
   the build)
-* ``Patch`` -- inert, JSON-able patch data; save/load with
-  ``save_patches()`` / ``load_patches()``
+* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
+  "analog" variants)
 * ``Wavetable`` -- loads a wavetable WAV file and lerps between frames
 * ``AHREnvelope`` -- shared-block attack/release envelope, used for both
   the filter and pitch envelopes
-* ``Waves`` -- waveform factory (saw, square, sine, triangle, noise, and
-  "analog" variants)
 * ``Arpeggiator`` / ``StepSequencer`` / ``TrigSequencer`` -- poll-based
   sequencers with on/off callbacks
-* ``Param`` / ``ParamSet`` -- knob-pickup and scaling for UIs with fewer
-  knobs than parameters
-* ``ParamScaler`` -- proportional ("scale") knob takeover for a single
-  control, when you are not using ``ParamSet``
-* ``GaugeCluster`` -- a bar-graph display of a parameter page
 * ``Glider`` -- a standalone pitch-slide block for hand-built
   ``synthio.Note`` graphs (the engines above have their own portamento,
   via ``mono`` + ``glide_time``)
-* ``RollingAverage`` -- moving-average smoothing for noisy knob reads
 * ``Scale`` / ``chord`` -- scales and diatonic/chromatic chords for
   mapping pads and MIDI onto pitch
+* ``Param`` / ``ParamSet`` -- (UI) knob-pickup and scaling for UIs with fewer
+  knobs than parameters
+* ``ParamScaler`` -- (UI) proportional ("scale") knob takeover for a single
+  control, when you are not using ``ParamSet``
+* ``GaugeCluster`` -- (UI) a bar-graph display of a parameter page
+* ``RollingAverage`` -- moving-average smoothing for noisy knob reads
 
 Documentation
 =============

{circuitpython_synthtools-0.7.0.dist-info → circuitpython_synthtools-0.8.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-circuitpython_synthtools-0.7.0.dist-info/licenses/LICENSE,sha256=jhhRyxpqyQxyF_D6SzY2-jCA5v8Z8JXfezCtxBS85CM,1075
-synthtools/__init__.py,sha256=n0ZXMz7Uu0pPEqalR51IxkClI9DTwuUbpu5yPj_whn8,2752
+circuitpython_synthtools-0.8.0.dist-info/licenses/LICENSE,sha256=jhhRyxpqyQxyF_D6SzY2-jCA5v8Z8JXfezCtxBS85CM,1075
+synthtools/__init__.py,sha256=dB2eJTgbLs_sfEMCFcm8F_FNoblgNcZd6toMpHFQThw,2752
 synthtools/ahr_envelope.py,sha256=fWhjp7LahNGjL8qtTgyiAnX5hnviAULuyc9dEJ6t74I,9233
 synthtools/arpeggiator.py,sha256=n2sPnpZcu9soXsFJCh6OP65_0DuPnvQGUP0ao7V8SXM,3901
-synthtools/audio_fx.py,sha256=VzdWT_pCwfQU5GTb8hVGGMwoFV4lxPwWE1Nm7A1a_Fc,6675
-synthtools/bassline_synth.py,sha256=Gkz7MKKUITgND4Se5nAJly9sZLQjHhFdd-aFrOAjeVM,28112
+synthtools/audio_fx.py,sha256=PjnETf5kKIlG_tLKwM49PCvSkM2txfZf2o7MuEnU2W4,8778
+synthtools/bassline_synth.py,sha256=X8efKBgemBP2qAX0hL3PgWk3c_jkBWo0aX4KrgccHKE,51547
 synthtools/blocks.py,sha256=EsGcDEzIJX_dvBN8CVlDrewtl16x5leU03tum9jrhr0,1995
 synthtools/fm_synth.py,sha256=-r4NcsESjEechkbmV0tZx4pXayHIz4qUfIznKtQoKgQ,6073
 synthtools/gauge_cluster.py,sha256=lcMkRK-db6KV6pu0PUJRWAOJT8IdjgpE_4bAi0lQwxc,2910
@@ -16,12 +16,12 @@ synthtools/step_sequencer.py,sha256=SkQuDsRtpAdKOXU3OsFmngeDPVQ0OXt3Gj5wqFCkEPM,
 synthtools/subtractive_synth.py,sha256=WIpmhbiiLtyQRFV9mHWWM-duST5RfY9HUN4SRf5wTOw,3382
 synthtools/swarm_synth.py,sha256=kCYsdVuaafTKkD06_m22iFaPUMCzeBKX67mkrsEq3pk,10945
 synthtools/synth.py,sha256=ZdmAKWBVzJqPyzU5W1hxnJ6j09D4rnCWm77s5jRW_Ww,36528
-synthtools/trig_sequencer.py,sha256=PaWgsTqOvuRjFUJ6VjxMLBuRkyeYCML9WQXBzx02Onk,2921
+synthtools/trig_sequencer.py,sha256=J3_PdbNmYEoFkz7Hj58qNzMRZQuUm-sf2dKZIrBTV8U,3052
 synthtools/utils.py,sha256=deKQbkGXIBdGUOXBOpRCc-UHdPiL8YmybIJ3BBo9aA4,648
 synthtools/waves.py,sha256=lwDka71TsoHGJcyVfmG4t-TEf6TjBwftJEXSS4Qxyx0,22407
-synthtools/wavetable.py,sha256=K1rghAptDYIOwy0PcL9xCllnJH6X3h875MpeuXCm6lQ,2492
-synthtools/wavetable_synth.py,sha256=WUs4FfrKd1hosPiPYnf05I4S8t98ngEMi8qhShkbCps,12896
-circuitpython_synthtools-0.7.0.dist-info/METADATA,sha256=WY049mABTbxBi_qkmr_a_Dh3AZ9ImrnVP0w81veUu0M,7189
-circuitpython_synthtools-0.7.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-circuitpython_synthtools-0.7.0.dist-info/top_level.txt,sha256=1xt53cH064i7vvFVDFyuJugc1NogReXvzsXbYGlgnKE,11
-circuitpython_synthtools-0.7.0.dist-info/RECORD,,
+synthtools/wavetable.py,sha256=7zQdAvHyiSp7wiVjl-lIfeifpbdsp7M5cCVbMT7eku0,3725
+synthtools/wavetable_synth.py,sha256=nggGXEr3tlADvTI38gCDRSw8XEaB5kHkzvQGSFfw16E,7969
+circuitpython_synthtools-0.8.0.dist-info/METADATA,sha256=K6l8EWT1soJUgzphRNq1V1Qhi3mdcCYXt0VAHjE5MFw,7139
+circuitpython_synthtools-0.8.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+circuitpython_synthtools-0.8.0.dist-info/top_level.txt,sha256=1xt53cH064i7vvFVDFyuJugc1NogReXvzsXbYGlgnKE,11
+circuitpython_synthtools-0.8.0.dist-info/RECORD,,

synthtools/__init__.py

@@ -36,7 +36,7 @@ Anything not listed below is still importable by its module path::
 
 import sys
 
-__version__ = "0.7.0"
+__version__ = "0.8.0"
 __repo__ = "https://github.com/todbot/CircuitPython_SynthTools.git"
 
 #: Public name -> the submodule that defines it. Every entry is loaded on

synthtools/audio_fx.py

@@ -26,10 +26,14 @@
 # Identical resonant sections stacked this way do pile up gain at the cutoff,
 # each stage adding its own peak on top of the last. At a squelchy filt_q
 # that is real headroom to watch, and also most of why a cascaded resonant
-# filter reads as more aggressive than a single one.
+# filter reads as more aggressive than a single one. tracking_filter()'s
+# `spread` is the lever: offsetting the stages spreads those peaks out the
+# way a real ladder's mismatched poles do.
 
 import synthio
 
+from .blocks import product
+
 try:
     import audiofilters
 except ImportError:  # not in every CircuitPython build
@@ -103,33 +107,66 @@ class EffectsChain:
             src = stage
 
 
-def tracking_filter(synth, stages=1, buffer_size=1024, mix=1.0):
+def tracking_filter(synth, stages=1, buffer_size=1024, mix=1.0, hpf_f=None, spread=1.0):
     """Build one ``audiofilters.Filter`` holding ``stages`` extra Biquads
     that track ``synth.filter``'s cutoff AND resonance; see the module
     comment for why that's automatic once they share the live blocks.
     ``stages`` extra 12 dB/octave sections plus the synth's own give
     ``12*(stages+1)`` overall.
 
+    ``spread`` offsets each stage's cutoff above the last by that ratio,
+    approximating a real ladder's wide pole spread instead of stacking
+    identical resonant peaks on one frequency; 1.0 shares one node and
+    allocates nothing.
+
+    ``hpf_f`` adds a fixed high-pass section at that frequency in Hz, in
+    the SAME biquad tuple, so it costs no extra buffer and no extra pass.
+    It is a plain number rather than a shared block on purpose: it must
+    not follow the cutoff. A TB-303's thin bass comes from small coupling
+    capacitors between the filter and the VCA, which sit at one corner
+    whatever the filter is doing. ``stages=0`` is legal with it, for a
+    high-pass alone.
+
     Raises ``ImportError`` if this build has no ``audiofilters``,
-    ``ValueError`` if ``stages < 1`` or ``synth`` has no filter to track
-    (either a poly synth, which has no ``.filter`` at all, or a mono one
-    built with ``filt_type=None``).
+    ``ValueError`` if ``stages < 1`` without an ``hpf_f``, or if tracking
+    stages were asked for and ``synth`` has no filter to track (either a
+    poly synth, which has no ``.filter`` at all, or a mono one built with
+    ``filt_type=None``).
     """
     if audiofilters is None:
         raise ImportError("audiofilters is not in this CircuitPython build")
-    if stages < 1:
+    if stages < 1 and not hpf_f:
         raise ValueError("stages must be >= 1")
     src = getattr(synth, "filter", None)
-    if src is None:
+    if stages >= 1 and src is None:
         raise ValueError("synth has no filter to track (mono-only, and filt_type must be set)")
     synthesizer = synth.synthio
     # Copies sharing src's frequency AND Q blocks, both live, so both track
     # the synth (sweep, accent, a filt_q turn) with nothing to keep in sync
     # by hand. One Filter holding a tuple, not a Filter each: `filter` runs
     # the sample through them in order, saving a buffer and a pass per stage.
-    biquads = tuple(
-        synthio.Biquad(src.mode, frequency=src.frequency, Q=src.Q) for _ in range(stages)
-    )
+    # `spread` offsets each stage above the last by that ratio. Identical
+    # cascaded sections pile their resonant peaks on one frequency; real
+    # ladder filters do not, and the TB-303's least of all, its bottom
+    # ladder capacitor being half the value of the other three. Mismatched
+    # stages approximate that wider pole spread and take the edge off the
+    # ringing. 1.0, the default, shares one node and allocates nothing.
+    #
+    # An offset node needs NO rooting: measured on rp2040, a Math reachable
+    # only through a Biquad inside an audiofilters.Filter tracks the sweep
+    # exactly, while an otherwise identical one reachable from nothing at
+    # all reads 0.0 forever. Nesting counts across the audiofilters
+    # boundary, so `synthesizer.blocks` stays out of this.
+    sections = []
+    ratio = 1.0
+    for _ in range(stages):
+        freq = src.frequency if ratio == 1.0 else product(src.frequency, ratio)
+        sections.append(synthio.Biquad(src.mode, frequency=freq, Q=src.Q))
+        ratio *= spread
+    biquads = tuple(sections)
+    if hpf_f:
+        # last, so it sheds low end from everything ahead of it
+        biquads += (synthio.Biquad(synthio.FilterMode.HIGH_PASS, frequency=hpf_f, Q=0.707),)
     return audiofilters.Filter(
         filter=biquads,
         mix=mix,