GitCorner

Code

ossartcraftfilmcraft🌐
f67d38b35cc5
//! Synchronising recordings of the same event by their audio (Synchronize, Merge Clips and
//! Create Multi-Camera Source Sequence "Audio").
//!
//! [`find_offset`] returns the lag `L` (in samples) for which `b[n] ≈ g · a[n + L]`: when `b`
//! started recording two seconds after `a`, `L = 2 · sample_rate`. It works in two passes:
//!
//! 1. **Coarse.** Both signals are DC-removed, normalised, low-pass filtered (windowed sinc) and
//!    decimated to ≤ 8 kHz (further for very long recordings, so the transform stays ≤ 4 M points).
//!    The generalised cross-correlation with partial phase transform weighting (GCC-PHAT-β:
//!    `R = A·B* / |A·B*|^β`) is computed with one complex FFT of both signals packed as `a + i·b`.
//!    PHAT weighting whitens the spectra, so the peak is sharp and independent of the microphones'
//!    gains and frequency responses; β < 1 keeps noise-only bins from dominating.
//! 2. **Refine.** Around the coarse peak, the same correlation is computed at the full sample rate
//!    on the loudest common window (≤ 2.7 s at 48 kHz). Its highest peak, of either sign, gives the
//!    lag and the polarity, and is refined by parabolic interpolation to a fraction of a sample.
//!
//! Two figures say how much to trust the result: `confidence`, the coarse peak's height over the
//! RMS of the correlation, and `distinct`, its height over the highest peak more than 50 ms away
//! (periodic material such as music or a steady hum can match at several lags).
//!
//! References: Knapp & Carter, "The generalized correlation method for estimation of time delay",
//! IEEE Trans. ASSP 24(4), 1976; the β-weighted PHAT variant is standard textbook practice.

use crate::fft::Fft;

/// Tuning of [`find_offset`].
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SyncOptions {
    /// Largest |lag| considered, in samples (None = anything with enough overlap).
    pub max_lag: Option<i64>,
    /// Upper bound of the coarse search's sample rate (Hz).
    pub coarse_rate: u32,
    /// Most samples (both signals together) the coarse transform may hold; longer recordings are
    /// decimated further.
    pub max_coarse_samples: usize,
    /// PHAT weighting exponent (1 = full whitening, 0 = plain cross-correlation).
    pub phat_beta: f32,
    /// Length of the full-rate refinement window (samples).
    pub refine_window: usize,
}

impl Default for SyncOptions {
    fn default() -> Self {
        Self { max_lag: None, coarse_rate: 8000, max_coarse_samples: 1 << 22, phat_beta: 0.75, refine_window: 1 << 17 }
    }
}

/// The offset found between two recordings.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SyncResult {
    /// `b[n]` lines up with `a[n + lag]` (samples at the input rate).
    pub lag: i64,
    /// The same with sub-sample precision (parabolic interpolation of the refined peak).
    pub lag_fine: f64,
    /// Coarse peak height over the RMS of the correlation.
    pub confidence: f32,
    /// Coarse peak height over the next-highest peak more than 50 ms away.
    pub distinct: f32,
    /// True when the signals correlate negatively (one recording has inverted polarity).
    pub inverted: bool,
}

impl SyncResult {
    /// Whether the match is clear enough to trust.
    pub fn reliable(&self) -> bool {
        self.confidence >= 8.0 && self.distinct >= 1.5
    }
}

/// Average interleaved or planar channels into one mono signal.
pub fn mixdown(channels: &[&[f32]]) -> Vec<f32> {
    let n = channels.iter().map(|c| c.len()).min().unwrap_or(0);
    let k = channels.len().max(1) as f32;
    (0..n).map(|i| channels.iter().map(|c| c[i]).sum::<f32>() / k).collect()
}

/// Low-pass filter (Blackman-windowed sinc, cutoff at 0.42 × the new sample rate) and keep every
/// `d`-th sample.
pub fn decimate(x: &[f32], d: usize) -> Vec<f32> {
    if x.is_empty() || d <= 1 {
        return x.to_vec();
    }
    // Factors above the input length cannot produce another output sample. Cap the useful factor
    // as well as the filter width so a public caller cannot turn a tiny input into a huge plan.
    const MAX_FACTOR: usize = 4096;
    let d = d.min(x.len()).min(MAX_FACTOR);
    let half = 8 * d;
    let fc = 0.42 / d as f64; // cycles per input sample
    let taps: Vec<f32> = {
        let n = 2 * half + 1;
        let mut h: Vec<f64> = (0..n)
            .map(|k| {
                let t = k as f64 - half as f64;
                let sinc = if t == 0.0 { 2.0 * fc } else { (2.0 * std::f64::consts::PI * fc * t).sin() / (std::f64::consts::PI * t) };
                let w = 0.42 - 0.5 * (2.0 * std::f64::consts::PI * k as f64 / (n - 1) as f64).cos()
                    + 0.08 * (4.0 * std::f64::consts::PI * k as f64 / (n - 1) as f64).cos();
                sinc * w
            })
            .collect();
        let s: f64 = h.iter().sum();
        h.iter_mut().for_each(|v| *v /= s);
        h.into_iter().map(|v| v as f32).collect()
    };
    let out_len = x.len().div_ceil(d);
    let mut out = Vec::with_capacity(out_len);
    for i in 0..out_len {
        let c = (i * d) as isize;
        let lo = (c - half as isize).max(0) as usize;
        let hi = ((c + half as isize + 1) as usize).min(x.len());
        let k0 = (lo as isize - (c - half as isize)) as usize;
        let mut acc = 0.0f32;
        for (j, &v) in x[lo..hi].iter().enumerate() {
            acc += v * taps[k0 + j];
        }
        out.push(acc);
    }
    out
}

/// Remove the mean and scale to unit RMS (silence stays silence).
fn normalise(x: &mut [f32]) {
    if x.is_empty() {
        return;
    }
    let mean = (x.iter().map(|&v| v as f64).sum::<f64>() / x.len() as f64) as f32;
    x.iter_mut().for_each(|v| *v -= mean);
    let rms = (x.iter().map(|&v| (v as f64) * (v as f64)).sum::<f64>() / x.len() as f64).sqrt();
    if rms > 1e-12 {
        let k = (1.0 / rms) as f32;
        x.iter_mut().for_each(|v| *v *= k);
    }
}

/// GCC-PHAT-β of `a` and `b` (zero-padded to `n`, a power of two ≥ `a.len() + b.len()`):
/// `r[L mod n] = Σ a[i + L]·b[i]` with whitened spectra. Only bins whose frequency (cycles per
/// sample) lies in `band` contribute.
fn gcc(a: &[f32], b: &[f32], n: usize, beta: f32, band: (f32, f32)) -> Vec<f32> {
    let fft = Fft::new(n);
    let mut re = vec![0.0f32; n];
    let mut im = vec![0.0f32; n];
    re[..a.len()].copy_from_slice(a);
    im[..b.len()].copy_from_slice(b);
    fft.forward(&mut re, &mut im);
    // X = A + iB for real a, b: A(k) = (X(k) + X*(n-k)) / 2, B(k) = (X(k) - X*(n-k)) / 2i.
    let weigh = |k: usize, xr: f32, xi: f32, yr: f32, yi: f32| -> (f32, f32) {
        // y = X*(n-k) given as (yr, yi) already conjugated
        let (ar, ai) = (0.5 * (xr + yr), 0.5 * (xi + yi));
        let (dr, di) = (xr - yr, xi - yi);
        let (br, bi) = (0.5 * di, -0.5 * dr);
        // R = A·conj(B)
        let rr = ar * br + ai * bi;
        let ri = ai * br - ar * bi;
        let f = k.min(n - k) as f32 / n as f32;
        if f < band.0 || f > band.1 {
            return (0.0, 0.0);
        }
        let mag = (rr * rr + ri * ri).sqrt();
        if mag <= 1e-30 {
            return (0.0, 0.0);
        }
        let w = mag.powf(-beta);
        (rr * w, ri * w)
    };
    for k in 0..=n / 2 {
        let j = (n - k) % n;
        let (xkr, xki, xjr, xji) = (re[k], im[k], re[j], im[j]);
        let rk = weigh(k, xkr, xki, xjr, -xji);
        let rj = weigh(j, xjr, xji, xkr, -xki);
        re[k] = rk.0;
        im[k] = rk.1;
        re[j] = rj.0;
        im[j] = rj.1;
    }
    fft.inverse(&mut re, &mut im);
    re
}

fn corr_at(r: &[f32], lag: i64) -> f32 {
    let n = r.len() as i64;
    r[lag.rem_euclid(n) as usize]
}

/// Find the lag `L` with `b[n] ≈ g·a[n + L]` (see the module docs). `None` when either signal is
/// too short or silent, or no lag leaves enough overlap.
pub fn find_offset(a: &[f32], b: &[f32], sample_rate: u32, opts: &SyncOptions) -> Option<SyncResult> {
    let sr = sample_rate.max(1) as usize;
    let min_len = (sr / 10).max(64);
    if a.len() < min_len || b.len() < min_len {
        return None;
    }
    let energy = |x: &[f32]| x.iter().map(|&v| (v as f64) * (v as f64)).sum::<f64>();
    if energy(a) < 1e-12 || energy(b) < 1e-12 {
        return None;
    }
    // ---- coarse
    let d = (sr.div_ceil(opts.coarse_rate.max(500) as usize)).max((a.len() + b.len()).div_ceil(opts.max_coarse_samples.max(1 << 12))).max(1);
    let mut ca = a.to_vec();
    let mut cb = b.to_vec();
    normalise(&mut ca);
    normalise(&mut cb);
    let (ca, cb) = (decimate(&ca, d), decimate(&cb, d));
    let (la, lb) = (ca.len() as i64, cb.len() as i64);
    let n = ((la + lb) as usize).next_power_of_two();
    let rate_c = sr as f32 / d as f32;
    let band = ((40.0 / rate_c).min(0.05), if d > 1 { 0.40 } else { 0.5 });
    let r = gcc(&ca, &cb, n, opts.phat_beta, band);
    // valid lags: b[0..lb) against a[L..L+lb) must overlap by a minimum amount
    let min_overlap = ((rate_c as i64) / 2).min(la.min(lb) / 4).max(8);
    let max_lag_c = opts.max_lag.map(|m| m.abs() / d as i64 + 1);
    let lo = -(lb - min_overlap);
    let hi = la - min_overlap;
    if hi < lo {
        return None;
    }
    let mut best = (0i64, 0.0f32);
    let mut sum2 = 0.0f64;
    let mut count = 0usize;
    for l in lo..=hi {
        if max_lag_c.is_some_and(|m| l.abs() > m) {
            continue;
        }
        let v = corr_at(&r, l);
        sum2 += (v as f64) * (v as f64);
        count += 1;
        if v.abs() > best.1.abs() {
            best = (l, v);
        }
    }
    if count == 0 || best.1 == 0.0 {
        return None;
    }
    let rms = (sum2 / count as f64).sqrt().max(1e-30) as f32;
    let confidence = best.1.abs() / rms;
    let guard = ((rate_c * 0.05) as i64).max(2);
    let mut second = 0.0f32;
    for l in lo..=hi {
        if (l - best.0).abs() <= guard || max_lag_c.is_some_and(|m| l.abs() > m) {
            continue;
        }
        second = second.max(corr_at(&r, l).abs());
    }
    let distinct = if second > 0.0 { best.1.abs() / second } else { f32::INFINITY };
    let inverted = best.1 < 0.0;
    let coarse = best.0 * d as i64;
    // ---- refine at the full rate
    let margin = (2 * d + 4) as i64;
    let (fa, fb) = (a.len() as i64, b.len() as i64);
    let ov0 = (-coarse).max(0);
    let ov1 = fb.min(fa - coarse);
    if ov1 - ov0 < 16 {
        return Some(SyncResult { lag: coarse, lag_fine: coarse as f64, confidence, distinct, inverted });
    }
    let w = ((ov1 - ov0) as usize).min(opts.refine_window.max(256)) as i64;
    // the window of b with the most energy (both sides: a lag-shifted)
    let start = {
        let hop = (w / 4).max(1);
        let pre = |x: &[f32]| {
            let mut p = Vec::with_capacity(x.len() + 1);
            p.push(0.0f64);
            let mut s = 0.0;
            for &v in x {
                s += (v as f64) * (v as f64);
                p.push(s);
            }
            p
        };
        let (pa, pb) = (pre(a), pre(b));
        let mut s = ov0;
        let mut best_s = ov0;
        let mut best_e = -1.0f64;
        while s + w <= ov1 {
            let eb = pb[(s + w) as usize] - pb[s as usize];
            let ea = pa[(s + coarse + w) as usize] - pa[(s + coarse) as usize];
            let e = eb.min(ea);
            if e > best_e {
                best_e = e;
                best_s = s;
            }
            s += hop;
        }
        best_s
    };
    let bw: Vec<f32> = b[start as usize..(start + w) as usize].to_vec();
    let aw: Vec<f32> = (start + coarse - margin..start + coarse + w + margin).map(|i| if i >= 0 && i < fa { a[i as usize] } else { 0.0 }).collect();
    let mut aw = aw;
    let mut bw = bw;
    normalise(&mut aw);
    normalise(&mut bw);
    let n2 = (aw.len() + bw.len()).next_power_of_two();
    let r2 = gcc(&aw, &bw, n2, opts.phat_beta, (20.0 / sr as f32, 0.5));
    // r2[L'] = Σ aw[i + L']·bw[i]; L' = margin + δ. The highest peak of either sign sets the lag
    // and the polarity: when one recording's phase is turned (a band-limited scratch track), the
    // coarse peak and the opposite-signed lobe beside it can come out nearly equal.
    let mut bl = 0i64;
    let mut bv = 0.0f32;
    for l in 0..=2 * margin {
        let v = corr_at(&r2, l);
        if v.abs() > bv.abs() {
            bv = v;
            bl = l;
        }
    }
    let inverted = if bv == 0.0 { inverted } else { bv < 0.0 };
    let sign = if inverted { -1.0 } else { 1.0 };
    let (y0, y1, y2) = (corr_at(&r2, bl - 1) * sign, bv * sign, corr_at(&r2, bl + 1) * sign);
    let den = y0 - 2.0 * y1 + y2;
    let frac = if den.abs() > 1e-20 { (0.5 * (y0 - y2) / den).clamp(-0.5, 0.5) } else { 0.0 };
    let delta = bl - margin;
    let lag = coarse + delta;
    Some(SyncResult { lag, lag_fine: lag as f64 + frac as f64, confidence, distinct, inverted })
}

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

    /// Speech-like test signal: voiced syllables (harmonics of a gliding pitch under an envelope),
    /// noise bursts (consonants) and pauses.
    fn speechy(sr: f64, secs: f64, seed: u64) -> Vec<f32> {
        let n = (sr * secs) as usize;
        let mut rng = Rng::new(seed);
        let mut out = vec![0.0f32; n];
        let mut i = 0usize;
        while i < n {
            let len = ((0.08 + 0.25 * (rng.uniform() * 0.5 + 0.5) as f64) * sr) as usize;
            let kind = rng.uniform();
            let f0 = 110.0 + 120.0 * (rng.uniform() as f64 * 0.5 + 0.5);
            let glide = 1.0 + 0.3 * rng.uniform() as f64;
            let amp = 0.2 + 0.3 * (rng.uniform() * 0.5 + 0.5);
            for k in 0..len.min(n - i) {
                let t = k as f64 / sr;
                let env = (std::f64::consts::PI * k as f64 / len as f64).sin() as f32;
                let v = if kind > 0.3 {
                    let f = f0 * (1.0 + (glide - 1.0) * k as f64 / len as f64);
                    (1..8).map(|h| ((2.0 * std::f64::consts::PI * f * h as f64 * t).sin() / h as f64) as f32).sum::<f32>()
                } else if kind > -0.4 {
                    rng.uniform()
                } else {
                    0.0
                };
                out[i + k] = v * env * amp;
            }
            i += len + ((rng.uniform() * 0.5 + 0.5) * 0.15 * sr as f32) as usize;
        }
        out
    }

    /// `x` delayed by `delay` samples (fractional: windowed-sinc interpolation), scaled by `gain`,
    /// optionally coloured by a zero-phase low-pass (`[k, 1-2k, k]`, so the delay stays exact), with
    /// white noise `snr_db` below the signal.
    fn mic(x: &[f32], delay: f64, gain: f32, lowpass: Option<f32>, snr_db: f32, len: usize, seed: u64) -> Vec<f32> {
        let mut out = vec![0.0f32; len];
        let di = delay.floor() as i64;
        let fr = delay - di as f64;
        for (n, o) in out.iter_mut().enumerate() {
            let src = n as i64 - di;
            if fr == 0.0 {
                if src >= 0 && (src as usize) < x.len() {
                    *o = x[src as usize];
                }
            } else {
                let mut acc = 0.0f64;
                for k in -16i64..=16 {
                    let j = src - k;
                    if j < 0 || j as usize >= x.len() {
                        continue;
                    }
                    let t = k as f64 - fr;
                    let s = (std::f64::consts::PI * t).sin() / (std::f64::consts::PI * t);
                    let w = 0.5 + 0.5 * (std::f64::consts::PI * t / 17.0).cos();
                    acc += x[j as usize] as f64 * s * w;
                }
                *o = acc as f32;
            }
        }
        if let Some(k) = lowpass {
            let src = out.clone();
            for i in 1..len.saturating_sub(1) {
                out[i] = k * src[i - 1] + (1.0 - 2.0 * k) * src[i] + k * src[i + 1];
            }
        }
        let rms = crate::testutil::rms(&out) as f32;
        let nrms = rms * 10f32.powf(-snr_db / 20.0) * 3f32.sqrt();
        let mut rng = Rng::new(seed);
        for v in &mut out {
            *v = *v * gain + rng.uniform() * nrms * gain;
        }
        out
    }

    #[test]
    fn decimate_keeps_low_frequencies_and_removes_high_ones() {
        let sr = 48_000.0;
        let low = crate::testutil::sine(300.0, 1.0, sr, 48_000, 0.0);
        let high = crate::testutil::sine(7_000.0, 1.0, sr, 48_000, 0.0);
        let dl = decimate(&low, 6);
        let dh = decimate(&high, 6);
        assert_eq!(dl.len(), 8000);
        let rl = crate::testutil::rms(&dl[100..7900]);
        let rh = crate::testutil::rms(&dh[100..7900]);
        assert!((rl - std::f64::consts::FRAC_1_SQRT_2).abs() < 0.01, "{rl}");
        assert!(rh < 0.01, "{rh}");
    }

    #[test]
    fn decimate_does_not_plan_a_filter_for_empty_or_extreme_requests() {
        assert!(decimate(&[], usize::MAX).is_empty());
        let tiny = [1.0, -1.0];
        assert_eq!(decimate(&tiny, usize::MAX), decimate(&tiny, tiny.len()));
    }

    #[test]
    fn pure_delay_exact_both_signs() {
        let sr = 48_000;
        let s = speechy(sr as f64, 12.0, 1);
        for delay in [0i64, 1, 7, 12_345, 96_001, -4_321, -50_000] {
            // b = s shifted: b[n] = s[n + delay]
            let b: Vec<f32> = (0..400_000i64).map(|n| if n + delay >= 0 && ((n + delay) as usize) < s.len() { s[(n + delay) as usize] } else { 0.0 }).collect();
            let r = find_offset(&s, &b, sr, &SyncOptions::default()).unwrap();
            assert_eq!(r.lag, delay, "{r:?}");
            assert!(r.reliable(), "{r:?}");
            assert!(!r.inverted);
        }
    }

    /// Three microphones recording one talker: different gains (−20…+10 dB), noise (SNR 25, 10 and
    /// 3 dB), one coloured by a low-pass, fractional delays. Every offset within one sample.
    #[test]
    fn multi_mic_offsets_within_one_sample() {
        let sr = 48_000u32;
        let src = speechy(sr as f64, 30.0, 7);
        let len = 30 * sr as usize;
        // mic k records src delayed by d_k: mic_k[n] = src[n - d_k]
        let cases: [(f64, f32, Option<f32>, f32); 4] =
            [(0.0, 1.0, None, 40.0), (2_345.0, 0.1, None, 25.0), (-31_337.4, 3.0, Some(0.3), 10.0), (150_000.6, 0.5, None, 3.0)];
        let mics: Vec<Vec<f32>> = cases.iter().enumerate().map(|(i, c)| mic(&src, c.0, c.1, c.2, c.3, len, 100 + i as u64)).collect();
        let mut worst = 0.0f64;
        let mut worst_fine = 0.0f64;
        for (k, c) in cases.iter().enumerate().skip(1) {
            // b = mic_k: b[n] = src[n - d_k] = a[n - d_k + d_0] → lag = d_0 - d_k
            let expect = cases[0].0 - c.0;
            let r = find_offset(&mics[0], &mics[k], sr, &SyncOptions::default()).unwrap();
            let err = (r.lag as f64 - expect).abs();
            let err_fine = (r.lag_fine - expect).abs();
            worst = worst.max(err);
            worst_fine = worst_fine.max(err_fine);
            assert!(err <= 1.0, "mic {k}: lag {} vs {expect} ({r:?})", r.lag);
            assert!(err_fine < 0.75, "mic {k}: fine {} vs {expect}", r.lag_fine);
            assert!(r.reliable(), "{r:?}");
        }
        eprintln!("multi-mic worst error: {worst} samples (integer lag), {worst_fine:.3} samples (sub-sample estimate)");
    }

    /// A room: the far microphone hears the direct sound plus a strong reflection 23 ms later, at
    /// 0 dB SNR. The direct path wins.
    #[test]
    fn echo_and_heavy_noise() {
        let sr = 48_000u32;
        let src = speechy(sr as f64, 20.0, 21);
        let len = src.len();
        let near = mic(&src, 0.0, 1.0, None, 35.0, len, 1);
        let direct = mic(&src, 777.0, 1.0, None, 60.0, len, 2);
        let echo = mic(&src, 777.0 + 0.023 * sr as f64, 0.6, None, 60.0, len, 3);
        let mut rng = Rng::new(9);
        let room: Vec<f32> = direct.iter().zip(&echo).map(|(a, b)| a + b).collect();
        let nrms = crate::testutil::rms(&room) as f32 * 3f32.sqrt();
        let far: Vec<f32> = room.iter().map(|v| (v + rng.uniform() * nrms) * 0.3).collect();
        let r = find_offset(&near, &far, sr, &SyncOptions::default()).unwrap();
        assert!((r.lag + 777).abs() <= 1, "{r:?}");
        assert!(r.reliable(), "{r:?}");
    }

    /// Two 10-minute recordings (run with `--ignored --nocapture` in release for the timing).
    #[test]
    #[ignore]
    fn long_recordings_timing() {
        let sr = 48_000u32;
        let src = speechy(sr as f64, 600.0, 31);
        let a = mic(&src, 0.0, 1.0, None, 20.0, src.len(), 1);
        let b = mic(&src, -1_234_567.0, 0.5, None, 10.0, src.len() - 2_000_000, 2);
        let t = std::time::Instant::now();
        let r = find_offset(&a, &b, sr, &SyncOptions::default()).unwrap();
        eprintln!("10 min + 9.3 min at 48 kHz: {:?} in {:.2} s", r, t.elapsed().as_secs_f64());
        assert!((r.lag - 1_234_567).abs() <= 1);
    }

    #[test]
    fn inverted_polarity_is_found() {
        let sr = 48_000;
        let s = speechy(sr as f64, 8.0, 3);
        let b: Vec<f32> = (0..300_000usize).map(|n| if n + 1000 < s.len() { -0.5 * s[n + 1000] } else { 0.0 }).collect();
        let r = find_offset(&s, &b, sr, &SyncOptions::default()).unwrap();
        assert_eq!(r.lag, 1000);
        assert!(r.inverted);
    }

    #[test]
    fn unrelated_signals_are_not_reliable() {
        let sr = 48_000;
        let a = speechy(sr as f64, 10.0, 11);
        let b = speechy(sr as f64, 10.0, 12);
        let r = find_offset(&a, &b, sr, &SyncOptions::default()).unwrap();
        assert!(!r.reliable(), "{r:?}");
        assert!(find_offset(&a, &[0.0; 48_000], sr, &SyncOptions::default()).is_none());
        assert!(find_offset(&a[..100], &a, sr, &SyncOptions::default()).is_none());
    }

    #[test]
    fn max_lag_limits_the_search() {
        let sr = 48_000;
        let s = speechy(sr as f64, 10.0, 5);
        let b: Vec<f32> = s[48_000..].to_vec();
        let r = find_offset(&s, &b, sr, &SyncOptions { max_lag: Some(60_000), ..Default::default() }).unwrap();
        assert_eq!(r.lag, 48_000);
        let r = find_offset(&s, &b, sr, &SyncOptions { max_lag: Some(10_000), ..Default::default() }).unwrap();
        assert!(!r.reliable() || r.lag != 48_000);
    }

    /// A camera's scratch track: `x` through a 400 Hz high-pass and a 2.5 kHz low-pass, with
    /// echoes 60 and 110 ms later, much quieter, plus noise. The filters turn the phase, so
    /// next to the correlation peak with the clean recording sits a negative lobe almost as high.
    fn scratch_track(x: &[f32], sr: u32, seed: u64) -> Vec<f32> {
        use crate::biquad::{Biquad, Coeffs, FilterType};
        let q = std::f64::consts::FRAC_1_SQRT_2;
        let mut y = x.to_vec();
        Biquad::new().process(&Coeffs::design(FilterType::HighPass, sr as f64, 400.0, q, 0.0), &mut y);
        Biquad::new().process(&Coeffs::design(FilterType::LowPass, sr as f64, 2500.0, q, 0.0), &mut y);
        let (d1, d2) = ((0.060 * sr as f64) as usize, (0.110 * sr as f64) as usize);
        let at = |n: usize, d: usize| if n >= d { y[n - d] } else { 0.0 };
        let mut rng = Rng::new(seed);
        (0..y.len()).map(|n| (0.8 * y[n] + 0.5 * at(n, d1) + 0.4 * at(n, d2)) * 0.14 + 0.01 * rng.uniform()).collect()
    }

    /// At the coarse rate the scratch track's peak and the negative lobe beside it came out nearly
    /// equal, and the lobe won. The refine then looked only for a negative peak: the result said
    /// `inverted` and landed about 20 samples early. The full-rate peak now sets both; an inverted
    /// scratch track is still found inverted.
    #[test]
    fn a_band_limited_scratch_track_keeps_its_polarity() {
        let sr = 48_000u32;
        let delay = 112_560i64;
        for seed in [1, 3, 7] {
            let src = speechy(sr as f64, 24.0, seed);
            let scratch = scratch_track(&src, sr, 100 + seed);
            for sign in [1.0f32, -1.0] {
                // b[n] = scratch[n + delay]
                let b: Vec<f32> = (0..16 * sr as i64).map(|n| sign * scratch.get((n + delay) as usize).copied().unwrap_or(0.0)).collect();
                let r = find_offset(&src, &b, sr, &SyncOptions::default()).unwrap();
                assert_eq!(r.inverted, sign < 0.0, "seed {seed}, sign {sign}: {r:?}");
                // the filters delay the scratch track by a few samples
                assert!((r.lag - delay).abs() <= 4, "seed {seed}, sign {sign}: {r:?}");
                assert!(r.reliable(), "{r:?}");
            }
        }
    }
}