Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-audio

Source of release 0.4.2

0.4.2 / src / studio.lucb

## Studio processing the synthwave and retro records lean on: a tape machine
## (wow, flutter, head bump, saturation, hiss), a tempo-synced pump (the
## French-touch sidechain), an eight-line hall that can be gated (the 80s
## snare), and the JP-8000's supersaw. Sources: reports/Synthwave artist
## production techniques.md. Nothing here allocates or traps.
import dsp
import analog
import kinds
import models
import effects
from dsp import State, Ports, clampf, absf, exp2, decibels
from effects import tap_frac, put, allpass

# ---------------------------------------------------------------- tape

let most_tape: f32 = 0.05

## A tape machine: the signal recorded through a saturating head (tanh with
## a little bias for even harmonics, antiderivative anti-aliased), its
## speed wandering (wow: a slow sine plus drift; flutter: a faster wobble),
## the playback head's low bump, the high end rolling off, and hiss. Mode
## sets the machine: Studio (a 15 ips deck: small wow, bump at 50 Hz),
## Cassette (wobblier, bump at 90 Hz, darker), VHS (slow seasick warble,
## bump at 110 Hz, darker still).
## Inputs: left, right. Params: Mode, Drive (dB), Wow, Flutter, Bump (dB),
## Tone (Hz), Hiss (dB), Mix.
pub func tape(s: State*, p: Ports*):
    let left_in = p.inputs[0]
    let right_in = p.inputs[1] if p.wired[1] else p.inputs[0]
    let left = p.outputs[0]
    let right = p.outputs[1]
    let mode = (i32)p.params[0]
    let drive = decibels(clampf(p.params[1], -12.0, 30.0))
    let wow = clampf(p.params[2], 0.0, 1.0)
    let flutter = clampf(p.params[3], 0.0, 1.0)
    let bump_db = clampf(p.params[4], 0.0, 9.0)
    var tone = clampf(p.params[5], 1000.0, 20000.0)
    let hiss = decibels(clampf(p.params[6], -120.0, -20.0))
    let wet = clampf(p.params[7], 0.0, 1.0)
    let length = (usize)(most_tape * p.rate) + 4
    let line = s.line
    if line.length < 2 * length:
        for i in 0..<p.frames:
            left[i] = left_in[i]
            right[i] = right_in[i]
        return
    # The machines: wow rate (Hz) and its pitch swing at Wow 1 (fraction),
    # flutter rate and swing, the bump's frequency, a ceiling on Tone.
    var wow_hz: f32 = 0.5
    var wow_swing: f32 = 0.004
    var flutter_hz: f32 = 7.0
    var flutter_swing: f32 = 0.0015
    var bump_hz: f32 = 50.0
    if mode == 1:
        wow_hz = 1.1
        wow_swing = 0.008
        flutter_hz = 11.0
        flutter_swing = 0.003
        bump_hz = 90.0
        if tone > 11000.0: tone = 11000.0
    elif mode == 2:
        wow_hz = 0.3
        wow_swing = 0.012
        flutter_hz = 14.0
        flutter_swing = 0.002
        bump_hz = 110.0
        if tone > 7500.0: tone = 7500.0
    # A sine delay swing A at f swings pitch by 2πfA: A = swing / (2πf).
    let wow_depth = wow * wow_swing / (6.2831855 * wow_hz) * p.rate
    let flutter_depth = flutter * flutter_swing / (6.2831855 * flutter_hz) * p.rate
    let center = 2.0 + wow_depth * 1.6 + flutter_depth
    # The bump: an RBJ peak, Q 0.9.
    let w = bump_hz / p.rate
    let cos_w = dsp.sin_turns(w + 0.25)
    let alpha = dsp.sin_turns(w) / 1.8
    let big = exp2(bump_db * 0.0415241)
    let a0 = 1.0 + alpha / big
    let b0 = (1.0 + alpha * big) / a0
    let b1 = -2.0 * cos_w / a0
    let b2 = (1.0 - alpha * big) / a0
    let a2 = (1.0 - alpha / big) / a0
    let lp = analog.one_pole(tone, p.rate)
    let bias: f32 = 0.15
    let rest = analog.tanh(bias)
    var wow_phase = (f32)s.a
    var flutter_phase = (f32)s.b
    var wander = (f32)s.c
    var seed = s.seed
    for i in 0..<p.frames:
        wow_phase += wow_hz / p.rate
        if wow_phase >= 1.0: wow_phase -= 1.0
        flutter_phase += flutter_hz / p.rate
        if flutter_phase >= 1.0: flutter_phase -= 1.0
        wander = wander + (dsp.white(&seed) - wander) * (2.0 / p.rate)
        let swing = wow_depth * (dsp.sin_turns(wow_phase) + 18.0 * wander) + flutter_depth * dsp.sin_turns(flutter_phase)
        let delay = clampf(center + swing, 1.0, (f32)(length - 2))
        for side: usize in 0..<2:
            let x = left_in[i] if side == 0 else right_in[i]
            # Record: through the head.
            let u = x * drive + bias
            let previous = s.damp[side]
            s.damp[side] = u
            let recorded = (analog.tanh_adaa(u, previous) - rest) / drive
            put(line, side * length, length, &s.heads[side], recorded)
            # Play back: the wandering speed, the bump, the roll-off, hiss.
            var y = tap_frac(line, side * length, length, s.heads[side], delay)
            let z = 2 + side * 2
            let bumped = b0 * y + s.damp[z]
            s.damp[z] = b1 * y - b1 * bumped + s.damp[z + 1]
            s.damp[z + 1] = b2 * y - a2 * bumped
            y = bumped + hiss * dsp.white(&seed)
            let f = 6 + side * 2
            s.damp[f] = s.damp[f] + (y - s.damp[f]) * lp
            s.damp[f + 1] = s.damp[f + 1] + (s.damp[f] - s.damp[f + 1]) * lp
            let out = x + (s.damp[f + 1] - x) * wet
            if side == 0:
                left[i] = out
            else:
                right[i] = out
    s.a = (f64)wow_phase
    s.b = (f64)flutter_phase
    s.c = (f64)wander
    s.seed = seed

# ---------------------------------------------------------------- pump

let pump_beats: f32[6] = [0.25, 0.5, 1.0, 2.0, 4.0, 8.0]

## The French-touch pump: the level ducks on every beat (or other step) of
## the song and swells back, as a compressor keyed by the kick would (the
## shape LFOTool and Kickstart draw). Depth is how far it ducks, Release the
## part of the step it takes to come back, Curve how it comes back (1 a
## line, higher sooner), Attack a few ms of fade into the duck so it does
## not click. With the key input wired it follows that signal instead: its
## level over Threshold ducks.
## Inputs: left, right, key. Params: Rate, Depth, Release, Curve, Attack
## (ms), Offset (of the step), Threshold (dB), Mix.
pub func pump(s: State*, p: Ports*):
    let left_in = p.inputs[0]
    let right_in = p.inputs[1] if p.wired[1] else p.inputs[0]
    let keys = p.inputs[2]
    let left = p.outputs[0]
    let right = p.outputs[1]
    let step = pump_beats[(usize)clampf(p.params[0], 0.0, 5.0)]
    let depth = clampf(p.params[1], 0.0, 1.0)
    let release = clampf(p.params[2], 0.02, 1.0)
    let curve = clampf(p.params[3], 0.3, 6.0)
    let attack_s = clampf(p.params[4], 0.0, 50.0) * 0.001
    let offset = clampf(p.params[5], 0.0, 1.0)
    let threshold = decibels(clampf(p.params[6], -60.0, 0.0))
    let wet = clampf(p.params[7], 0.0, 1.0)
    let seconds_per_beat = 1.0 / ((f32)p.beats_per_sample * p.rate) if p.beats_per_sample > 0.0 else 0.5
    let attack = attack_s / (step * seconds_per_beat)
    var level = (f32)s.a
    let rise = analog.one_pole(1.0 / (attack_s + 0.0005), p.rate)
    let fall = analog.one_pole(1.0 / (release * step * seconds_per_beat), p.rate)
    for i in 0..<p.frames:
        var gain: f32 = 1.0
        if p.wired[2]:
            let k = absf(keys[i])
            level = level + (k - level) * (rise if k > level else fall)
            gain = 1.0 - depth * clampf(level / threshold, 0.0, 1.0)
        else:
            let beat = (f32)(p.beat + p.beats_per_sample * (f64)i) / step - offset
            let t = beat - dsp.floorf(beat)
            # Into the duck over Attack, then back over Release.
            var duck: f32 = 0.0
            if t < attack:
                duck = t / attack
            else:
                let back = clampf((t - attack) / release, 0.0, 1.0)
                duck = 1.0 - pow_curve(back, curve)
            gain = 1.0 - depth * duck
        let g = 1.0 + (gain - 1.0) * wet
        left[i] = left_in[i] * g
        right[i] = right_in[i] * g
    s.a = (f64)level

## 1 - (1 - x)^curve as an exp2/log2 pair: how the pump comes back.
inline func pow_curve(x: f32, curve: f32) -> f32:
    let rest = 1.0 - x
    if rest <= 0.0: return 1.0
    return 1.0 - exp2(curve * log2(rest))

pub inline func log2(x: f32) -> f32:
    let bits = x.bits()
    let exponent = (f32)(i32)((bits >> 23) & 255) - 127.0
    let m = f32.bits((bits & 0x7fffff) | 0x3f800000)
    return exponent + (-2.4967738 + (4.0283728 + (-2.0810602 + (0.62881573 - 0.079150366 * m) * m) * m) * m)

# ---------------------------------------------------------------- hall

## The hall's delays at Size 1 (ms): a predelay, four input diffusers, then
## eight feedback lines (lengths spread, none a multiple of another).
let hall_diffusers: f32[4] = [4.77, 3.59, 12.73, 9.30]
let hall_lines: f32[8] = [43.1, 51.7, 59.3, 67.9, 76.1, 83.9, 92.3, 101.3]
let most_hall_size: f32 = 2.5
let most_hall_predelay: f32 = 0.3
## Room for the lines' swing (ms).
let hall_swing: f32 = 1.5

## The shimmer's grain (s): its octave-up reader sweeps a window this long.
let shimmer_window: f32 = 0.06

## Where the hall's fourteen lines start and how long each is, at `rate`:
## predelay, diffusers, the eight, the shimmer's.
func hall_layout(rate: f32, lengths: usize[], bases: usize[]) -> usize:
    let ms = rate * 0.001
    lengths[0] = (usize)(most_hall_predelay * rate) + 4
    for i in 0..<4: lengths[1 + i] = (usize)(hall_diffusers[i] * ms) + 1
    for i in 0..<8: lengths[5 + i] = (usize)((hall_lines[i] * most_hall_size + hall_swing * 2.0) * ms) + 4
    lengths[13] = (usize)(shimmer_window * rate) + 4
    var at: usize = 0
    for i in 0..<14:
        bases[i] = at
        at += lengths[i]
    return at

## A hall: input diffusion into an eight-line feedback delay network
## (Hadamard mixing, Jot's per-line decay so every line falls 60 dB in
## Decay seconds, a damping low pass in each line, slowly swung delays so
## the tail shimmers and never rings). Gate shuts the tail that long after
## the input falls quiet: the gated snare of the 80s (Gate 0 is off).
## Shimmer feeds the tail back an octave up (two crossfaded grains reading
## twice as fast), so it climbs and glows: the Mercury7 / Valhalla shimmer.
## Inputs: left, right. Params: Decay (s), Size, Predelay (ms), Damping (Hz),
## Mod Depth, Mod Rate (Hz), Low Cut (Hz), Width, Gate (s), Mix, Shimmer.
pub func hall(s: State*, p: Ports*):
    let left_in = p.inputs[0]
    let right_in = p.inputs[1] if p.wired[1] else p.inputs[0]
    let left = p.outputs[0]
    let right = p.outputs[1]
    let decay = clampf(p.params[0], 0.1, 60.0)
    let size = clampf(p.params[1], 0.2, most_hall_size)
    let predelay = clampf(p.params[2], 0.0, most_hall_predelay * 1000.0 - 1.0) * p.rate * 0.001
    let damping = analog.one_pole(clampf(p.params[3], 500.0, 20000.0), p.rate)
    let mod_depth = clampf(p.params[4], 0.0, 1.0) * hall_swing * p.rate * 0.001
    let mod_rate = clampf(p.params[5], 0.01, 5.0)
    let low_cut = analog.one_pole(clampf(p.params[6], 10.0, 1000.0), p.rate)
    let wide = clampf(p.params[7], 0.0, 2.0)
    let gate_time = clampf(p.params[8], 0.0, 2.0)
    let wet = clampf(p.params[9], 0.0, 1.0)
    let shimmer = clampf(p.params[10], 0.0, 1.0)
    var lengths: usize[14]
    var bases: usize[14]
    let total = hall_layout(p.rate, lengths, bases)
    let window = shimmer_window * p.rate
    let line = s.line
    if line.length < total:
        for i in 0..<p.frames:
            left[i] = left_in[i]
            right[i] = right_in[i]
        return
    let ms = p.rate * 0.001
    var delays: f32[8]
    var gains: f32[8]
    for j in 0..<8:
        delays[j] = hall_lines[j] * size * ms + hall_swing * ms
        # Each pass through a line loses 60 dB × delay / Decay.
        gains[j] = exp2(-9.965784 * delays[j] / (decay * p.rate))
    var phase = (f32)s.a
    var low = (f32)s.b
    var follow = (f32)s.c
    var open = (f32)s.d
    var held = (f32)s.more[0]
    var grain = (f32)s.more[1]
    var climbed = (f32)s.more[2]
    let follow_fall = dsp.fall(0.05, p.rate)
    let open_rise = analog.one_pole(300.0, p.rate)
    let open_fall = analog.one_pole(40.0, p.rate)
    for i in 0..<p.frames:
        let dry_l = left_in[i]
        let dry_r = right_in[i]
        var x = 0.5 * (dry_l + dry_r)
        low = low + (x - low) * low_cut
        x = x - low
        put(line, bases[0], lengths[0], &s.heads[0], x)
        x = effects.tap_frac(line, bases[0], lengths[0], s.heads[0], predelay + 1.0)
        for d in 0..<4:
            x = allpass(line, bases[1 + d], lengths[1 + d], &s.heads[1 + d], x, 0.7 if d < 2 else 0.6)
        x = x + climbed * shimmer * 0.6
        phase += mod_rate / p.rate
        if phase >= 1.0: phase -= 1.0
        var v: f32[8]
        for j in 0..<8:
            let swing = mod_depth * dsp.sin_turns(phase * (1.0 + 0.07 * (f32)j) + 0.125 * (f32)j)
            let y = tap_frac(line, bases[5 + j], lengths[5 + j], s.heads[5 + j], clampf(delays[j] + swing, 1.0, (f32)(lengths[5 + j] - 2)))
            s.damp[j] = s.damp[j] + (y - s.damp[j]) * damping
            v[j] = s.damp[j]
        var out_l = (v[0] - v[2] + v[4] - v[6]) * 0.5
        var out_r = (v[1] - v[3] + v[5] - v[7]) * 0.5
        if shimmer > 0.0:
            # Octave up: two readers 180° apart whose delay shrinks a sample
            # a sample (twice the speed), each faded in and out by a triangle.
            put(line, bases[13], lengths[13], &s.heads[13], 0.5 * (out_l + out_r))
            grain += 1.0 / window
            if grain >= 1.0: grain -= 1.0
            var other = grain + 0.5
            if other >= 1.0: other -= 1.0
            let one = tap_frac(line, bases[13], lengths[13], s.heads[13], 1.0 + (1.0 - grain) * window)
            let two = tap_frac(line, bases[13], lengths[13], s.heads[13], 1.0 + (1.0 - other) * window)
            climbed = one * (1.0 - absf(2.0 * grain - 1.0)) + two * (1.0 - absf(2.0 * other - 1.0))
        # The fast Walsh-Hadamard transform, scaled to keep energy.
        var h: usize = 1
        while h < 8:
            var a: usize = 0
            while a < 8:
                for b in a..<a + h:
                    let u = v[b]
                    let w = v[b + h]
                    v[b] = u + w
                    v[b + h] = u - w
                a += h * 2
            h *= 2
        for j in 0..<8:
            let sign: f32 = 1.0 if (j & 1) == 0 else -1.0
            put(line, bases[5 + j], lengths[5 + j], &s.heads[5 + j], x * sign * 0.5 + v[j] * 0.35355339 * gains[j])
        if gate_time > 0.0:
            let level = absf(dry_l) + absf(dry_r)
            follow = level if level > follow else follow * follow_fall
            if follow > 0.003: held = gate_time
            else: held -= 1.0 / p.rate
            let want: f32 = 1.0 if held > 0.0 else 0.0
            open = open + (want - open) * (open_rise if want > open else open_fall)
            out_l *= open
            out_r *= open
        let mid = 0.5 * (out_l + out_r)
        let side = 0.5 * (out_l - out_r) * wide
        left[i] = dry_l + (mid + side - dry_l) * wet
        right[i] = dry_r + (mid - side - dry_r) * wet
    s.a = (f64)phase
    s.b = (f64)low
    s.c = (f64)follow
    s.d = (f64)open
    s.more[0] = (f64)held
    s.more[1] = (f64)grain
    s.more[2] = (f64)climbed

# ---------------------------------------------------------------- supersaw

## The JP-8000's seven saws (Adam Szabo, "How to Emulate the Super Saw",
## 2010): their measured detune ratios, the knob's measured curve, the
## centre saw's and side saws' levels as Mix moves, free-running phases, and
## a high pass at the fundamental that clears the mud below it.
let saw_offsets: f32[7] = [-0.11002313, -0.06288439, -0.01952356, 0.0, 0.01991221, 0.06216538, 0.10745242]
## Where each saw sits, -1 left to 1 right, at full Spread.
let saw_places: f32[7] = [-1.0, 0.66, -0.33, 0.0, 0.33, -0.66, 1.0]

inline func detune_curve(x: f32) -> f32:
    return ((((((((((10028.7312891634 * x - 50818.8652045924) * x + 111363.4808729368) * x - 138150.6761080548) * x + 106649.6679158292) * x - 53046.9642751875) * x + 17019.9518580080) * x - 3425.0836591318) * x + 404.2703938388) * x - 24.1878824391) * x + 0.6717417634) * x + 0.0030115596

## The supersaw: seven detuned saws, spread across the stereo field.
## Inputs: pitch (octaves), fm (octaves, added), detune (added).
## Params: Octave, Semitones, Fine, Detune, Mix, Spread, Level, Drift.
pub func supersaw(s: State*, p: Ports*):
    let pitch = p.inputs[0]
    let fm = p.inputs[1]
    let detunes = p.inputs[2]
    let left = p.outputs[0]
    let right = p.outputs[1]
    let mix = clampf(p.params[4], 0.0, 1.0)
    let spread = clampf(p.params[5], 0.0, 1.0)
    let level = p.params[6]
    var wander = (f32)s.d
    let walk = analog.drift(&wander, &s.seed, p.frames)
    s.d = (f64)wander
    let drift = (walk * p.params[7] + s.variation * p.params[7] * 0.4) / 1200.0
    let tune = p.params[0] + p.params[1] / 12.0 + p.params[2] / 1200.0 + drift
    let base = 261.62558 / p.rate
    let center = -0.55366 * mix + 0.99785
    let sides = -0.73764 * mix * mix + 1.2841 * mix + 0.044372
    # Equal-power places for each saw.
    var to_left: f32[7]
    var to_right: f32[7]
    for k in 0..<7:
        let place = saw_places[k] * spread
        let gain = center if k == 3 else sides
        to_left[k] = gain * (0.5 - 0.5 * place) * 0.6
        to_right[k] = gain * (0.5 + 0.5 * place) * 0.6
    # First time: free-running phases start anywhere.
    if s.stage == 0:
        for k in 0..<7: s.more[k] = (f64)(0.5 + 0.5 * dsp.white(&s.seed))
        s.stage = 1
    var phases: f32[7]
    for k in 0..<7: phases[k] = (f32)s.more[k]
    var hp_l = s.damp[0]
    var hp_r = s.damp[1]
    for i in 0..<p.frames:
        var octaves = tune
        if p.wired[0]: octaves += pitch[i]
        if p.wired[1]: octaves += fm[i]
        let f0 = base * exp2(octaves)
        var amount = p.params[3]
        if p.wired[2]: amount = amount + detunes[i]
        let spread_ratio = detune_curve(clampf(amount, 0.0, 1.0))
        var l: f32 = 0.0
        var r: f32 = 0.0
        for k in 0..<7:
            let dt = clampf(f0 * (1.0 + saw_offsets[k] * spread_ratio), 0.000001, 0.45)
            var t = phases[k] + dt
            if t >= 1.0: t -= 1.0
            phases[k] = t
            let saw = 2.0 * t - 1.0 - models.blep(t, dt)
            l += saw * to_left[k]
            r += saw * to_right[k]
        # The high pass at the fundamental.
        let g = analog.one_pole(f0 * p.rate, p.rate)
        hp_l = hp_l + (l - hp_l) * g
        hp_r = hp_r + (r - hp_r) * g
        left[i] = (l - hp_l) * level
        right[i] = (r - hp_r) * level
    for k in 0..<7: s.more[k] = (f64)phases[k]
    s.damp[0] = hp_l
    s.damp[1] = hp_r

# ---------------------------------------------------------------- memory

## The line memory (samples) a voice of `kind` needs at `rate`, or 0.
pub func memory_of(kind: u32, rate: f64) -> usize:
    if kind == kinds.tape:
        return 2 * ((usize)(most_tape * (f32)rate) + 4)
    if kind == kinds.eq:
        return 64
    if kind == kinds.limiter:
        return 3 * ((usize)(0.005 * (f32)rate) + 8)
    if kind == kinds.freq_shifter:
        return 66
    if kind == kinds.width:
        return (usize)(most_haas * (f32)rate) + 4
    if kind == kinds.hall:
        var lengths: usize[14]
        var bases: usize[14]
        return hall_layout((f32)rate, lengths, bases)
    return 0

# ---------------------------------------------------------------- tempo LFO

let lfo_beats: f32[10] = [0.125, 0.1666667, 0.25, 0.3333333, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0]

## An LFO locked to the song: one cycle every Rate (1/32 to 4 bars, with
## triplets), started at Phase; as the transport moves it follows the beat,
## so filter sweeps and wobbles land on the bar. Waves: sine, triangle, ramp
## up, ramp down, square, sample-and-hold, smooth random (Elektron's).
## Bipolar -1..1 times Depth, or 0..1 with Unipolar.
## Inputs: none. Params: Wave, Rate, Phase, Depth, Unipolar.
pub func tempo_lfo(s: State*, p: Ports*):
    let out = p.outputs[0]
    let wave = (i32)p.params[0]
    let cycle = lfo_beats[(usize)clampf(p.params[1], 0.0, 9.0)]
    let start = p.params[2]
    let depth = p.params[3]
    let unipolar = p.params[4] > 0.5
    var held = (f32)s.a
    var next = (f32)s.b
    var last_cycle = s.c
    var seed = s.seed
    for i in 0..<p.frames:
        let position = (p.beat + p.beats_per_sample * (f64)i) / (f64)cycle + (f64)start
        let whole = (f64)(i64)position
        let t = (f32)(position - whole)
        if whole != last_cycle:
            last_cycle = whole
            held = next
            next = dsp.white(&seed)
        var value: f32 = 0.0
        if wave == 0: value = dsp.sin_turns(t)
        elif wave == 1: value = 1.0 - 4.0 * absf(t - 0.5)
        elif wave == 2: value = 2.0 * t - 1.0
        elif wave == 3: value = 1.0 - 2.0 * t
        elif wave == 4: value = 1.0 if t < 0.5 else -1.0
        elif wave == 5: value = held
        else:
            # Smooth random: a cosine glide from the last value to the next.
            let blend = 0.5 - 0.5 * dsp.sin_turns(t * 0.5 + 0.25)
            value = held + (next - held) * blend
        if unipolar: value = 0.5 + 0.5 * value
        out[i] = value * depth
    s.a = (f64)held
    s.b = (f64)next
    s.c = last_cycle
    s.seed = seed

# ---------------------------------------------------------------- width

## Stereo width: mid/side (0 mono, 1 as is, 2 twice as wide), the side's
## lows folded to mono below Mono Bass so the low end stays centred, and a
## Haas delay (up to 30 ms) on the right that widens even a mono part.
## Inputs: left, right. Params: Width, Mono Bass (Hz), Haas (ms), Balance.
let most_haas: f32 = 0.032

pub func width(s: State*, p: Ports*):
    let left_in = p.inputs[0]
    let right_in = p.inputs[1] if p.wired[1] else p.inputs[0]
    let left = p.outputs[0]
    let right = p.outputs[1]
    let amount = clampf(p.params[0], 0.0, 3.0)
    let low = analog.one_pole(clampf(p.params[1], 10.0, 500.0), p.rate)
    let haas = clampf(p.params[2], 0.0, 30.0) * p.rate * 0.001
    let balance = clampf(p.params[3], -1.0, 1.0)
    let length = (usize)(most_haas * p.rate) + 4
    let line = s.line
    var side_low = s.damp[0]
    for i in 0..<p.frames:
        var r = right_in[i]
        if haas >= 1.0 and line.length >= length:
            put(line, 0, length, &s.heads[0], r)
            r = tap_frac(line, 0, length, s.heads[0], haas)
        let mid = 0.5 * (left_in[i] + r)
        var side = 0.5 * (left_in[i] - r)
        side_low = side_low + (side - side_low) * low
        side = (side - side_low) * amount
        left[i] = (mid + side) * (1.0 - balance if balance > 0.0 else 1.0)
        right[i] = (mid - side) * (1.0 + balance if balance < 0.0 else 1.0)
    s.damp[0] = side_low

# ---------------------------------------------------------------- frequency shifter

## Two allpass chains whose outputs stay 90° apart from 20 Hz to 20 kHz at
## 44.1-48 kHz (Olli Niemitalo's coefficients, squared here): a Hilbert pair.
let hilbert_a: f32[4] = [0.47940087, 0.87621849, 0.97659759, 0.99749926]
let hilbert_b: f32[4] = [0.1617585, 0.73302893, 0.9453497, 0.99059916]

## One side's Hilbert pair: the in-phase and quadrature parts of `x`. Its
## memory is 32 floats at `m`.
inline func hilbert(m: f32[], base: usize, x: f32) -> (f32, f32):
    var a = x
    var b = x
    for k: usize in 0..<4:
        let i = base + k * 4
        # y = c (x + y[n-2]) - x[n-2]
        let ya = hilbert_a[k] * (a + m[i + 3]) - m[i + 1]
        m[i + 1] = m[i]
        m[i] = a
        m[i + 3] = m[i + 2]
        m[i + 2] = ya
        a = ya
        let j = base + 16 + k * 4
        let yb = hilbert_b[k] * (b + m[j + 3]) - m[j + 1]
        m[j + 1] = m[j]
        m[j] = b
        m[j + 3] = m[j + 2]
        m[j + 2] = yb
        b = yb
    # The first path is a sample late by design.
    let late = m[base + 32]
    m[base + 32] = a
    return (late, b)

## A frequency shifter (the Bode / Eventide kind Com Truise runs drums
## through): every partial moves by Shift Hz, so harmonics stop being
## harmonic; a few Hz is a slow phasing swirl, tens of Hz a metallic detune.
## Spread shifts the right side the other way. Feedback re-shifts the
## output (the barber-pole climb).
## Inputs: left, right, shift (Hz, added). Params: Shift (Hz), Feedback,
## Spread, Mix.
pub func freq_shifter(s: State*, p: Ports*):
    let left_in = p.inputs[0]
    let right_in = p.inputs[1] if p.wired[1] else p.inputs[0]
    let shifts = p.inputs[2]
    let left = p.outputs[0]
    let right = p.outputs[1]
    let feedback = clampf(p.params[1], 0.0, 0.95)
    let spread = p.params[2] > 0.5
    let wet = clampf(p.params[3], 0.0, 1.0)
    let m = s.line
    if m.length < 66:
        for i in 0..<p.frames:
            left[i] = left_in[i]
            right[i] = right_in[i]
        return
    var phase = (f32)s.a
    var fb_l = (f32)s.b
    var fb_r = (f32)s.c
    for i in 0..<p.frames:
        var shift = p.params[0]
        if p.wired[2]: shift = shift + shifts[i]
        phase += shift / p.rate
        phase -= dsp.floorf(phase)
        let c = dsp.sin_turns(phase + 0.25)
        let sn = dsp.sin_turns(phase)
        let (il, ql) = hilbert(m, 0, left_in[i] + fb_l * feedback)
        let (ir, qr) = hilbert(m, 33, right_in[i] + fb_r * feedback)
        let yl = il * c + ql * sn
        let yr = ir * c - qr * sn if spread else ir * c + qr * sn
        fb_l = yl
        fb_r = yr
        left[i] = left_in[i] + (yl - left_in[i]) * wet
        right[i] = right_in[i] + (yr - right_in[i]) * wet
    s.a = (f64)phase
    s.b = (f64)fb_l
    s.c = (f64)fb_r