GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Convolution Reverb (uniformly partitioned overlap-save convolution with impulse responses
//! we generate ourselves) and Surround Reverb (early reflections + the FDN late field).

use super::time::Reverb;
use super::util::{DelayLine, OnePole, Prng};
use crate::fft::Fft;
use crate::{AudioEffect, ParamSpec, ParamValues, Smoothed, Unit, block_len, db_to_gain, param_plumbing};

/// Partition (block) size; the effect's latency.
const PART: usize = 256;

/// Built-in impulse responses (generated, see [`generate_ir`]).
pub const IMPULSES: &[&str] = &["Small Room", "Medium Room", "Large Hall", "Cathedral", "Plate", "Ambience", "Vocal Booth"];

/// Character of a generated impulse.
#[derive(Clone, Copy, Debug)]
struct IrSpec {
    rt60: f32,
    /// Early-reflection span (ms) and count.
    er_ms: f32,
    er_count: usize,
    /// How fast the high frequencies die relative to the low ones (1/s).
    hf_decay: f32,
    /// Late-field onset (ms).
    onset_ms: f32,
    seed: u64,
}

const IR_SPECS: [IrSpec; 7] = [
    IrSpec { rt60: 0.45, er_ms: 25.0, er_count: 10, hf_decay: 6.0, onset_ms: 8.0, seed: 11 },
    IrSpec { rt60: 0.8, er_ms: 45.0, er_count: 14, hf_decay: 4.0, onset_ms: 15.0, seed: 12 },
    IrSpec { rt60: 1.9, er_ms: 80.0, er_count: 18, hf_decay: 2.2, onset_ms: 30.0, seed: 13 },
    IrSpec { rt60: 3.2, er_ms: 120.0, er_count: 22, hf_decay: 1.4, onset_ms: 45.0, seed: 14 },
    IrSpec { rt60: 1.6, er_ms: 0.0, er_count: 0, hf_decay: 1.0, onset_ms: 1.0, seed: 15 },
    IrSpec { rt60: 0.3, er_ms: 15.0, er_count: 8, hf_decay: 8.0, onset_ms: 4.0, seed: 16 },
    IrSpec { rt60: 0.2, er_ms: 8.0, er_count: 6, hf_decay: 12.0, onset_ms: 2.0, seed: 17 },
];

fn ir_len(spec: &IrSpec, sr: f32) -> usize {
    ((spec.rt60 * 1.1 + spec.er_ms * 0.001) * sr) as usize + 1
}

/// Fill `out` (stereo, equal lengths) with a synthetic impulse response: sparse early
/// reflections plus exponentially decaying noise whose bandwidth narrows over time (high
/// frequencies decay faster), fading in over the onset, each channel normalised to unit energy.
/// Deterministic for a given index and sample rate.
fn generate_ir(index: usize, sr: f32, out: [&mut [f32]; 2]) {
    let spec = IR_SPECS[index.min(IR_SPECS.len() - 1)];
    for (c, buf) in out.into_iter().enumerate() {
        let len = buf.len();
        let mut rng = Prng::new(spec.seed * 2 + c as u64);
        let mut lp = OnePole::default();
        let onset = (spec.onset_ms * 0.001 * sr).max(1.0);
        for (i, v) in buf.iter_mut().enumerate() {
            let t = i as f32 / sr;
            let env = (-6.907_755 * t / spec.rt60).exp();
            let fade = (i as f32 / onset).min(1.0);
            let fc = (16000.0 * (-t * spec.hf_decay).exp()).max(800.0);
            let a = OnePole::alpha(fc, sr);
            *v = lp.lp(a, rng.uniform()) * env * fade;
        }
        for _ in 0..spec.er_count {
            let t = 0.002 + (rng.uniform() * 0.5 + 0.5) * spec.er_ms * 0.001;
            let i = ((t * sr) as usize).min(len - 1);
            let amp = 0.6 * (-3.0 * t / (spec.er_ms * 0.001 + 1e-3)).exp() * if rng.uniform() < 0.0 { -1.0 } else { 1.0 };
            buf[i] += amp;
        }
        let e: f64 = buf.iter().map(|&v| (v as f64) * (v as f64)).sum();
        let g = if e > 0.0 { (1.0 / e.sqrt()) as f32 } else { 0.0 };
        buf.iter_mut().for_each(|v| *v *= g);
    }
}

/// Convolution reverb with generated impulses (mono-summed input, decorrelated stereo IR).
pub struct ConvolutionReverb {
    pv: ParamValues,
    sr: f32,
    fft: Fft,
    /// Base impulse (current preset) and the processed one (size, damping) per output channel.
    base: [Vec<f32>; 2],
    base_len: usize,
    /// Partition spectra (B+1 bins, re/im interleaved per partition): `h[ch][p * 2(B+1) ..]`.
    h: [Vec<f32>; 2],
    parts: usize,
    /// The previous partition set, still audible until the next block crossfades from it to `h`.
    h_prev: [Vec<f32>; 2],
    parts_prev: usize,
    xfade: bool,
    /// A block has been convolved since construction or reset, so an impulse change can click.
    primed: bool,
    /// Frequency-domain delay line of input spectra (same layout), ring of `max_parts`.
    fdl: Vec<f32>,
    head: usize,
    max_parts: usize,
    /// Time-domain input history (2B) and block in/out buffers.
    hist: Vec<f32>,
    inbuf: Vec<f32>,
    out: [Vec<f32>; 2],
    pos: usize,
    re: Vec<f32>,
    im: Vec<f32>,
    pre: DelayLine,
    dry_delay: Vec<DelayLine>,
    key: (usize, f32, f32, f32),
    /// Impulse, size or damping changed since the last rebuild; rebuilt at the next `process`.
    dirty: bool,
    mix: Smoothed,
    gain: Smoothed,
    width: Smoothed,
    predelay: Smoothed,
}

impl ConvolutionReverb {
    pub const PARAMS: &'static [ParamSpec] = &[
        ParamSpec::choice("impulse", "Impulse", IMPULSES, 1),
        ParamSpec::new("mix", "Mix", 0.0, 100.0, 30.0, Unit::Percent),
        ParamSpec::new("room_size", "Room Size", 10.0, 100.0, 100.0, Unit::Percent),
        ParamSpec::log("damping_lf", "Damping LF", 10.0, 1000.0, 10.0, Unit::Hertz),
        ParamSpec::log("damping_hf", "Damping HF", 1000.0, 20000.0, 20000.0, Unit::Hertz),
        ParamSpec::new("predelay", "Pre-Delay", 0.0, 500.0, 0.0, Unit::Milliseconds),
        ParamSpec::new("width", "Width", 0.0, 100.0, 100.0, Unit::Percent),
        ParamSpec::new("gain", "Gain", -24.0, 12.0, 0.0, Unit::Decibels),
    ];

    pub fn new(sample_rate: f32, channels: usize) -> Self {
        let max_len = IR_SPECS.iter().map(|s| ir_len(s, sample_rate)).max().unwrap_or(1);
        let max_parts = max_len.div_ceil(PART);
        let bins2 = 2 * (PART + 1);
        let mut s = ConvolutionReverb {
            pv: ParamValues::new(Self::PARAMS),
            sr: sample_rate,
            fft: Fft::new(2 * PART),
            base: [vec![0.0; max_len], vec![0.0; max_len]],
            base_len: 0,
            h: [vec![0.0; max_parts * bins2], vec![0.0; max_parts * bins2]],
            parts: 0,
            h_prev: [vec![0.0; max_parts * bins2], vec![0.0; max_parts * bins2]],
            parts_prev: 0,
            xfade: false,
            primed: false,
            fdl: vec![0.0; max_parts * bins2],
            head: 0,
            max_parts,
            hist: vec![0.0; 2 * PART],
            inbuf: vec![0.0; PART],
            out: [vec![0.0; PART], vec![0.0; PART]],
            pos: 0,
            re: vec![0.0; 2 * PART],
            im: vec![0.0; 2 * PART],
            pre: DelayLine::new((0.5 * sample_rate) as usize + 2),
            dry_delay: vec![DelayLine::new(PART + 2); channels.max(1)],
            key: (usize::MAX, 0.0, 0.0, 0.0),
            dirty: false,
            mix: Smoothed::with_ms(0.0, sample_rate, 20.0),
            gain: Smoothed::with_ms(1.0, sample_rate, 20.0),
            width: Smoothed::with_ms(1.0, sample_rate, 20.0),
            predelay: Smoothed::with_ms(0.0, sample_rate, 50.0),
        };
        s.apply_params(true);
        s
    }

    /// Rebuild the partition spectra (only when the impulse, size or damping changed). Once audio
    /// has run, the audible set is kept in `h_prev` and the next block crossfades to the new one.
    fn rebuild(&mut self) {
        let key = (self.pv.idx("impulse"), self.pv.v("room_size"), self.pv.v("damping_lf"), self.pv.v("damping_hf"));
        if key == self.key {
            return;
        }
        if self.primed && !self.xfade {
            std::mem::swap(&mut self.h, &mut self.h_prev);
            self.parts_prev = self.parts;
            self.xfade = true;
        }
        if key.0 != self.key.0 {
            let len = ir_len(&IR_SPECS[key.0.min(IR_SPECS.len() - 1)], self.sr).min(self.base[0].len());
            let [a, b] = &mut self.base;
            generate_ir(key.0, self.sr, [&mut a[..len], &mut b[..len]]);
            self.base_len = len;
        }
        self.key = key;
        // Room size shortens the impulse by resampling it (linear interpolation).
        let scale = (key.1 / 100.0).clamp(0.1, 1.0);
        let len = ((self.base_len as f32 * scale) as usize).max(1);
        self.parts = len.div_ceil(PART).min(self.max_parts);
        let (alf, ahf) = (OnePole::alpha(key.2, self.sr), OnePole::alpha(key.3, self.sr));
        let bins2 = 2 * (PART + 1);
        for c in 0..2 {
            let mut hp = OnePole::default();
            let mut lp = OnePole::default();
            for p in 0..self.parts {
                for k in 0..2 * PART {
                    self.re[k] = 0.0;
                    self.im[k] = 0.0;
                }
                for k in 0..PART {
                    let i = p * PART + k;
                    if i >= len {
                        break;
                    }
                    let src = i as f32 / scale;
                    let i0 = src as usize;
                    let fr = src - i0 as f32;
                    let b = &self.base[c];
                    let v0 = b.get(i0).copied().unwrap_or(0.0);
                    let v1 = b.get(i0 + 1).copied().unwrap_or(0.0);
                    let mut v = (v0 + (v1 - v0) * fr) * scale.sqrt().recip();
                    if key.2 > 10.5 {
                        v = hp.hp(alf, v);
                    }
                    if key.3 < 19999.0 {
                        v = lp.lp(ahf, v);
                    }
                    self.re[k] = v;
                }
                self.fft.forward(&mut self.re, &mut self.im);
                let dst = &mut self.h[c][p * bins2..(p + 1) * bins2];
                for k in 0..=PART {
                    dst[2 * k] = self.re[k];
                    dst[2 * k + 1] = self.im[k];
                }
            }
        }
    }

    fn apply_params(&mut self, snap: bool) {
        if snap {
            self.rebuild();
        } else {
            self.dirty = true;
        }
        self.mix.set(self.pv.v("mix") / 100.0);
        self.gain.set(db_to_gain(self.pv.v("gain")));
        self.width.set(self.pv.v("width") / 100.0);
        self.predelay.set(self.pv.v("predelay") * 0.001 * self.sr);
        if snap {
            self.mix.snap();
            self.gain.snap();
            self.width.snap();
            self.predelay.snap();
        }
    }

    /// Convolve the collected block (`inbuf`) and fill `out`, crossfading linearly over the block
    /// from the previous partition set when the impulse changed.
    fn block(&mut self) {
        let bins2 = 2 * (PART + 1);
        self.primed = true;
        self.hist.copy_within(PART.., 0);
        self.hist[PART..].copy_from_slice(&self.inbuf);
        self.re.copy_from_slice(&self.hist);
        self.im.iter_mut().for_each(|v| *v = 0.0);
        self.fft.forward(&mut self.re, &mut self.im);
        self.head = (self.head + self.max_parts - 1) % self.max_parts;
        {
            let slot = &mut self.fdl[self.head * bins2..(self.head + 1) * bins2];
            for k in 0..=PART {
                slot[2 * k] = self.re[k];
                slot[2 * k + 1] = self.im[k];
            }
        }
        if std::mem::take(&mut self.xfade) {
            let mut prev = [[0.0f32; PART]; 2];
            convolve(&self.fft, &self.fdl, self.head, self.max_parts, &self.h_prev, self.parts_prev, &mut self.re, &mut self.im);
            for k in 0..PART {
                prev[0][k] = self.re[PART + k];
                prev[1][k] = self.im[PART + k];
            }
            convolve(&self.fft, &self.fdl, self.head, self.max_parts, &self.h, self.parts, &mut self.re, &mut self.im);
            for k in 0..PART {
                let g = (k + 1) as f32 / PART as f32;
                self.re[PART + k] = prev[0][k] + g * (self.re[PART + k] - prev[0][k]);
                self.im[PART + k] = prev[1][k] + g * (self.im[PART + k] - prev[1][k]);
            }
        } else {
            convolve(&self.fft, &self.fdl, self.head, self.max_parts, &self.h, self.parts, &mut self.re, &mut self.im);
        }
        let s = 1.0 / (2 * PART) as f32;
        for k in 0..PART {
            self.out[0][k] = self.re[PART + k] * s;
            self.out[1][k] = self.im[PART + k] * s;
        }
    }
}

/// Multiply the input spectra in the delay line with the first `parts` partitions of `h`; the
/// unscaled left and right outputs land in `re[PART..]` and `im[PART..]`.
#[allow(clippy::too_many_arguments)]
fn convolve(fft: &Fft, fdl: &[f32], head: usize, max_parts: usize, h: &[Vec<f32>; 2], parts: usize, re: &mut [f32], im: &mut [f32]) {
    let bins2 = 2 * (PART + 1);
    // Accumulate Y_L and Y_R (half spectra) then pack Z = Y_L + j·Y_R for one inverse FFT.
    let mut yl = [0.0f32; 2 * (PART + 1)];
    let mut yr = [0.0f32; 2 * (PART + 1)];
    for p in 0..parts {
        let xi = ((head + p) % max_parts) * bins2;
        let x = &fdl[xi..xi + bins2];
        let hl = &h[0][p * bins2..(p + 1) * bins2];
        let hr = &h[1][p * bins2..(p + 1) * bins2];
        for k in 0..=PART {
            let (xr, xim) = (x[2 * k], x[2 * k + 1]);
            yl[2 * k] += xr * hl[2 * k] - xim * hl[2 * k + 1];
            yl[2 * k + 1] += xr * hl[2 * k + 1] + xim * hl[2 * k];
            yr[2 * k] += xr * hr[2 * k] - xim * hr[2 * k + 1];
            yr[2 * k + 1] += xr * hr[2 * k + 1] + xim * hr[2 * k];
        }
    }
    let n = 2 * PART;
    for k in 0..n {
        let (lr, li, rr, ri) = if k <= PART {
            (yl[2 * k], yl[2 * k + 1], yr[2 * k], yr[2 * k + 1])
        } else {
            let m = n - k;
            (yl[2 * m], -yl[2 * m + 1], yr[2 * m], -yr[2 * m + 1])
        };
        // Z = Y_L + j·Y_R
        re[k] = lr - ri;
        im[k] = li + rr;
    }
    fft.inverse(re, im);
}

impl AudioEffect for ConvolutionReverb {
    param_plumbing!("convolution_reverb");
    fn latency(&self) -> usize {
        PART
    }
    fn reset(&mut self) {
        self.fdl.iter_mut().for_each(|v| *v = 0.0);
        self.hist.iter_mut().for_each(|v| *v = 0.0);
        self.inbuf.iter_mut().for_each(|v| *v = 0.0);
        self.out.iter_mut().for_each(|o| o.iter_mut().for_each(|v| *v = 0.0));
        self.head = 0;
        self.pos = 0;
        self.primed = false;
        self.xfade = false;
        self.pre.reset();
        self.dry_delay.iter_mut().for_each(DelayLine::reset);
        self.mix.snap();
        self.gain.snap();
        self.width.snap();
        self.predelay.snap();
    }
    fn process(&mut self, channels: &mut [&mut [f32]]) {
        let n = block_len(channels);
        let nch = channels.len().min(self.dry_delay.len());
        if nch == 0 {
            return;
        }
        if self.dirty {
            self.dirty = false;
            self.rebuild();
        }
        for i in 0..n {
            let (mix, gain, width, pd) = (self.mix.tick(), self.gain.tick(), self.width.tick(), self.predelay.tick());
            let mono = channels[..nch].iter().map(|c| c[i]).sum::<f32>() / nch as f32;
            self.pre.push(mono);
            self.inbuf[self.pos] = self.pre.read(pd);
            let (wl, wr) = (self.out[0][self.pos], self.out[1][self.pos]);
            self.pos += 1;
            if self.pos == PART {
                self.pos = 0;
                self.block();
            }
            // Width: 0 = mono wet, 1 = full decorrelated stereo.
            let m = 0.5 * (wl + wr);
            let (wl, wr) = (m + width * (wl - m), m + width * (wr - m));
            for ch in 0..nch {
                self.dry_delay[ch].push(channels[ch][i]);
                let dry = self.dry_delay[ch].tap(PART);
                let wet = if nch == 1 {
                    m
                } else if ch == 0 {
                    wl
                } else {
                    wr
                };
                channels[ch][i] = dry + mix * (wet * gain - dry);
            }
        }
    }
}

// ------------------------------------------------------------------------- surround reverb

const ER_TAPS: usize = 8;
const ER_MS: [f32; ER_TAPS] = [7.1, 11.3, 15.7, 19.9, 24.2, 31.7, 38.3, 47.9];
const ER_GAIN: [f32; ER_TAPS] = [0.8, -0.7, 0.62, -0.55, 0.47, -0.4, 0.33, -0.27];
const CHUNK: usize = 256;

/// Early reflections (8 taps, alternating sides) plus the 8-line FDN late field, with
/// low/high cut on the wet signal, wet width, and separate dry/wet levels. The centre input
/// level controls how much of the mid (L+R) signal feeds the reverb.
pub struct SurroundReverb {
    pv: ParamValues,
    sr: f32,
    late: Reverb,
    er: DelayLine,
    lc: [OnePole; 2],
    hc: [OnePole; 2],
    scratch: [[f32; CHUNK]; 2],
    dry: Smoothed,
    wet: Smoothed,
    early: Smoothed,
    width: Smoothed,
    centre: Smoothed,
    size: Smoothed,
}

impl SurroundReverb {
    pub const PARAMS: &'static [ParamSpec] = &[
        ParamSpec::new("center_input", "Center Input", 0.0, 100.0, 100.0, Unit::Percent),
        ParamSpec::new("room_size", "Room Size", 0.0, 100.0, 50.0, Unit::Percent),
        ParamSpec::log("decay", "Decay", 0.1, 20.0, 1.5, Unit::Seconds),
        ParamSpec::new("predelay", "Pre-Delay", 0.0, 200.0, 20.0, Unit::Milliseconds),
        ParamSpec::new("damping", "Damping", 0.0, 100.0, 40.0, Unit::Percent),
        ParamSpec::new("early", "Early Reflections", 0.0, 100.0, 40.0, Unit::Percent),
        ParamSpec::log("low_cut", "Low Frequency Cut", 20.0, 1000.0, 20.0, Unit::Hertz),
        ParamSpec::log("high_cut", "High Frequency Cut", 1000.0, 20000.0, 12000.0, Unit::Hertz),
        ParamSpec::new("width", "Width", 0.0, 100.0, 100.0, Unit::Percent),
        ParamSpec::new("dry", "Dry", 0.0, 100.0, 80.0, Unit::Percent),
        ParamSpec::new("wet", "Wet", 0.0, 100.0, 30.0, Unit::Percent),
    ];

    pub fn new(sample_rate: f32, channels: usize) -> Self {
        let mut late = Reverb::new(sample_rate, channels);
        late.set_param("mix", 100.0);
        let sm = |v| Smoothed::with_ms(v, sample_rate, 20.0);
        let mut s = SurroundReverb {
            pv: ParamValues::new(Self::PARAMS),
            sr: sample_rate,
            late,
            er: DelayLine::new((0.1 * sample_rate) as usize),
            lc: [OnePole::default(); 2],
            hc: [OnePole::default(); 2],
            scratch: [[0.0; CHUNK]; 2],
            dry: sm(1.0),
            wet: sm(0.0),
            early: sm(0.0),
            width: sm(1.0),
            centre: sm(1.0),
            size: sm(1.0),
        };
        s.apply_params(true);
        s
    }

    fn apply_params(&mut self, snap: bool) {
        self.late.set_param("size", self.pv.v("room_size"));
        self.late.set_param("decay", self.pv.v("decay"));
        self.late.set_param("predelay", self.pv.v("predelay"));
        self.late.set_param("damping", self.pv.v("damping"));
        self.dry.set(self.pv.v("dry") / 100.0);
        self.wet.set(self.pv.v("wet") / 100.0);
        self.early.set(self.pv.v("early") / 100.0);
        self.width.set(self.pv.v("width") / 100.0);
        self.centre.set(self.pv.v("center_input") / 100.0);
        self.size.set(0.5 + self.pv.v("room_size") / 100.0);
        if snap {
            self.late.reset();
            for s in [&mut self.dry, &mut self.wet, &mut self.early, &mut self.width, &mut self.centre, &mut self.size] {
                s.snap();
            }
        }
    }
}

impl AudioEffect for SurroundReverb {
    param_plumbing!("surround_reverb");
    fn reset(&mut self) {
        self.late.reset();
        self.er.reset();
        self.lc = [OnePole::default(); 2];
        self.hc = [OnePole::default(); 2];
        for s in [&mut self.dry, &mut self.wet, &mut self.early, &mut self.width, &mut self.centre, &mut self.size] {
            s.snap();
        }
    }
    fn process(&mut self, channels: &mut [&mut [f32]]) {
        let n = block_len(channels);
        let nch = channels.len().min(2);
        if nch == 0 {
            return;
        }
        let (alc, ahc) = (OnePole::alpha(self.pv.v("low_cut"), self.sr), OnePole::alpha(self.pv.v("high_cut"), self.sr));
        let ms = self.sr * 0.001;
        let mut start = 0;
        while start < n {
            let len = (n - start).min(CHUNK);
            // Reverb input: side signal plus the centre-weighted mid.
            for i in 0..len {
                let (l, r) = if nch == 2 { (channels[0][start + i], channels[1][start + i]) } else { (channels[0][start + i], channels[0][start + i]) };
                let c = self.centre.tick();
                let (mid, side) = (0.5 * (l + r), 0.5 * (l - r));
                self.scratch[0][i] = c * mid + side;
                self.scratch[1][i] = c * mid - side;
            }
            {
                let [a, b] = &mut self.scratch;
                self.late.process(&mut [&mut a[..len], &mut b[..len]]);
            }
            for i in 0..len {
                let x = if nch == 2 { 0.5 * (channels[0][start + i] + channels[1][start + i]) } else { channels[0][start + i] };
                let size = self.size.tick();
                self.er.push(x);
                let (mut el, mut er) = (0.0, 0.0);
                for k in 0..ER_TAPS {
                    let v = ER_GAIN[k] * self.er.read(ER_MS[k] * size * ms);
                    if k % 2 == 0 { el += v } else { er += v }
                }
                let early = self.early.tick();
                let (dry, wet, width) = (self.dry.tick(), self.wet.tick(), self.width.tick());
                let mut w = [self.scratch[0][i] + early * el, self.scratch[1][i] + early * er];
                for c in 0..2 {
                    w[c] = self.hc[c].lp(ahc, self.lc[c].hp(alc, w[c]));
                }
                let m = 0.5 * (w[0] + w[1]);
                let (wl, wr) = (m + width * (w[0] - m), m + width * (w[1] - m));
                if nch == 2 {
                    channels[0][start + i] = dry * channels[0][start + i] + wet * wl;
                    channels[1][start + i] = dry * channels[1][start + i] + wet * wr;
                } else {
                    channels[0][start + i] = dry * channels[0][start + i] + wet * m;
                }
            }
            start += len;
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::testutil::Rng;

    #[test]
    fn set_param_defers_the_impulse_rebuild_to_process() {
        let mut fx = ConvolutionReverb::new(48_000.0, 2);
        let key = fx.key;
        fx.set_param("damping_hf", 8000.0);
        fx.set_param("room_size", 60.0);
        assert_eq!(fx.key, key, "set_param rebuilt the impulse");
        fx.process(&mut [&mut [0.0; 16][..], &mut [0.0; 16][..]]);
        assert_eq!(fx.key, (key.0, 60.0, key.2, 8000.0));
        assert!(!fx.dirty);
    }

    #[test]
    fn deferred_rebuild_output_is_identical() {
        let changes: &[&[(&str, f32)]] = &[
            &[("room_size", 70.0)],
            &[],
            &[("damping_lf", 200.0), ("damping_hf", 6000.0)],
            &[("impulse", 2.0), ("mix", 80.0)],
            &[("room_size", 30.0), ("room_size", 90.0)],
            &[("impulse", 4.0), ("damping_hf", 20_000.0), ("damping_lf", 10.0)],
        ];
        let mut eager = ConvolutionReverb::new(48_000.0, 2);
        let mut deferred = ConvolutionReverb::new(48_000.0, 2);
        let mut rng = Rng::new(5);
        for (block, set) in changes.iter().cycle().take(24).enumerate() {
            for &(id, v) in *set {
                eager.set_param(id, v);
                eager.rebuild();
                deferred.set_param(id, v);
            }
            let n = 300 + 37 * block;
            let l: Vec<f32> = (0..n).map(|_| rng.uniform()).collect();
            let r: Vec<f32> = (0..n).map(|_| rng.uniform()).collect();
            let (mut l1, mut r1, mut l2, mut r2) = (l.clone(), r.clone(), l, r);
            eager.process(&mut [&mut l1, &mut r1]);
            deferred.process(&mut [&mut l2, &mut r2]);
            for (a, b) in l1.iter().chain(&r1).zip(l2.iter().chain(&r2)) {
                assert_eq!(a.to_bits(), b.to_bits(), "block {block}");
            }
        }
    }

    /// Run `fx` over `l`/`r` in calls of `step` samples, applying `set` before the call that
    /// starts at sample `at`; returns the left output.
    fn run(fx: &mut ConvolutionReverb, l: &[f32], r: &[f32], step: usize, set: &mut dyn FnMut(&mut ConvolutionReverb, usize)) -> Vec<f32> {
        let (mut l, mut r) = (l.to_vec(), r.to_vec());
        let mut at = 0;
        for (a, b) in l.chunks_mut(step).zip(r.chunks_mut(step)) {
            set(fx, at);
            at += a.len();
            fx.process(&mut [a, b]);
        }
        l
    }

    fn sine(n: usize) -> Vec<f32> {
        (0..n).map(|i| 0.5 * (std::f32::consts::TAU * 200.0 * i as f32 / 48_000.0).sin()).collect()
    }

    fn wet() -> ConvolutionReverb {
        let mut fx = ConvolutionReverb::new(48_000.0, 2);
        fx.set_param("mix", 100.0);
        fx
    }

    /// Apply `changes` at once without a crossfade (the old instant swap).
    fn snap(fx: &mut ConvolutionReverb, changes: &[(&str, f32)]) {
        for &(id, v) in changes {
            fx.set_param(id, v);
        }
        fx.primed = false;
        fx.rebuild();
        fx.primed = true;
    }

    fn max_jump(y: &[f32]) -> f32 {
        y.windows(2).map(|w| (w[1] - w[0]).abs()).fold(0.0, f32::max)
    }

    #[test]
    fn impulse_change_crossfades_within_one_partition() {
        let n = 48_000 * 5 / 2;
        let at = 188 * 512;
        let x = sine(n);
        for change in [("impulse", 3.0), ("damping_lf", 800.0), ("room_size", 40.0)] {
            let faded = run(&mut wet(), &x, &x, 512, &mut |fx, i| {
                if i == at {
                    fx.set_param(change.0, change.1);
                }
            });
            let instant = run(&mut wet(), &x, &x, 512, &mut |fx, i| {
                if i == at {
                    snap(fx, &[change]);
                }
            });
            // The latency is unchanged and the new impulse is fully in after one partition.
            let (fade_from, fade_to) = (at + PART, at + 2 * PART);
            for (i, (a, b)) in faded.iter().zip(&instant).enumerate() {
                if !(fade_from..fade_to).contains(&i) {
                    assert_eq!(a.to_bits(), b.to_bits(), "{change:?}: sample {i}");
                }
            }
            assert!(faded[fade_from..fade_to].iter().zip(&instant[fade_from..fade_to]).any(|(a, b)| a != b));
            let steady = max_jump(&faded[at - 4096..at]);
            let around = at - PART..at + 4 * PART;
            let (jf, ji) = (max_jump(&faded[around.clone()]), max_jump(&instant[around]));
            assert!(jf < 1.5 * steady, "{change:?}: jump {jf} vs steady {steady}");
            assert!(ji > 4.0 * jf, "{change:?}: instant jump {ji} vs faded {jf}");
        }
    }

    #[test]
    fn repeated_changes_before_the_crossfade_fade_from_the_audible_impulse() {
        let n = 48_000 * 2;
        let at = 256 * 300;
        let x = sine(n);
        let mut fx = wet();
        let faded = run(&mut fx, &x, &x, 64, &mut |fx, i| {
            if i == at {
                fx.set_param("impulse", 3.0);
            }
            if i == at + 64 {
                assert!(fx.xfade);
                fx.set_param("damping_lf", 800.0);
            }
            if i == at + 128 {
                fx.set_param("room_size", 50.0);
            }
        });
        assert_eq!(fx.key, (3, 50.0, 800.0, 20_000.0));
        assert!(!fx.xfade);
        let instant = run(&mut wet(), &x, &x, 64, &mut |fx, i| {
            if i == at {
                snap(fx, &[("impulse", 3.0), ("damping_lf", 800.0), ("room_size", 50.0)]);
            }
        });
        let (fade_from, fade_to) = (at + PART, at + 2 * PART);
        for (i, (a, b)) in faded.iter().zip(&instant).enumerate() {
            if !(fade_from..fade_to).contains(&i) {
                assert_eq!(a.to_bits(), b.to_bits(), "sample {i}");
            }
        }
        let steady = max_jump(&faded[at - 4096..at]);
        let jf = max_jump(&faded[at - PART..at + 4 * PART]);
        assert!(jf < 1.5 * steady, "jump {jf} vs steady {steady}");
    }

    #[test]
    fn unchanged_impulse_does_not_crossfade() {
        let mut rng = Rng::new(9);
        let x: Vec<f32> = (0..48_000).map(|_| rng.uniform()).collect();
        let plain = run(&mut ConvolutionReverb::new(48_000.0, 2), &x, &x, 512, &mut |_, _| {});
        let touched = run(&mut ConvolutionReverb::new(48_000.0, 2), &x, &x, 512, &mut |fx, i| {
            fx.set_param("room_size", 100.0);
            fx.set_param("damping_hf", 20_000.0);
            fx.set_param("mix", 30.0);
            assert!(!fx.xfade, "sample {i}");
        });
        assert!(plain.iter().zip(&touched).all(|(a, b)| a.to_bits() == b.to_bits()));
    }
}