f67d38b35cc5
special.rs
//! Special and stereo effects: Channel Mixer, Distortion, GuitarSuite, Mastering, Vocal
//! Enhancer, Stereo Expander, Binauralizer, Ambisonics Panner, Loudness Meter and Mute.
use super::multiband::soft_clip;
use super::time::Reverb;
use super::util::{DcBlock, DelayLine, OnePole, coef, lin_db};
use crate::biquad::{Biquad, Coeffs, FilterType};
use crate::loudness::LoudnessMeter;
use crate::{AudioEffect, ParamSpec, ParamValues, Smoothed, Unit, block_len, db_to_gain, flush32, param_plumbing};
use std::f32::consts::{FRAC_PI_2, PI};
const SM: f32 = 20.0;
const CHUNK: usize = 256;
fn sm(v: f32, sr: f32) -> Smoothed {
Smoothed::with_ms(v, sr, SM)
}
// ------------------------------------------------------------------------------ channel mixer
/// 2×2 channel matrix with per-output polarity inversion.
pub struct ChannelMixer {
pv: ParamValues,
g: [Smoothed; 4],
}
impl ChannelMixer {
pub const PARAMS: &'static [ParamSpec] = &[
ParamSpec::new("l_from_l", "Left - Left", -100.0, 100.0, 100.0, Unit::Percent),
ParamSpec::new("l_from_r", "Left - Right", -100.0, 100.0, 0.0, Unit::Percent),
ParamSpec::new("r_from_l", "Right - Left", -100.0, 100.0, 0.0, Unit::Percent),
ParamSpec::new("r_from_r", "Right - Right", -100.0, 100.0, 100.0, Unit::Percent),
ParamSpec::toggle("invert_l", "Invert Left", false),
ParamSpec::toggle("invert_r", "Invert Right", false),
];
pub fn new(sample_rate: f32, _channels: usize) -> Self {
let mut s =
ChannelMixer { pv: ParamValues::new(Self::PARAMS), g: [sm(1.0, sample_rate), sm(0.0, sample_rate), sm(0.0, sample_rate), sm(1.0, sample_rate)] };
s.apply_params(true);
s
}
fn apply_params(&mut self, snap: bool) {
let il = if self.pv.on("invert_l") { -1.0 } else { 1.0 };
let ir = if self.pv.on("invert_r") { -1.0 } else { 1.0 };
let v =
[il * self.pv.v("l_from_l") / 100.0, il * self.pv.v("l_from_r") / 100.0, ir * self.pv.v("r_from_l") / 100.0, ir * self.pv.v("r_from_r") / 100.0];
for (s, v) in self.g.iter_mut().zip(v) {
s.set(v);
if snap {
s.snap();
}
}
}
}
impl AudioEffect for ChannelMixer {
param_plumbing!("channel_mixer");
fn reset(&mut self) {
self.g.iter_mut().for_each(Smoothed::snap);
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
if channels.len() < 2 {
for i in 0..n {
let g: Vec4 = self.tick();
channels[0][i] *= g[0] + g[1];
}
return;
}
let (a, b) = channels.split_at_mut(1);
let (l, r) = (&mut a[0], &mut b[0]);
for i in 0..n {
let g = self.tick();
let (x, y) = (l[i], r[i]);
l[i] = g[0] * x + g[1] * y;
r[i] = g[2] * x + g[3] * y;
}
}
}
type Vec4 = [f32; 4];
impl ChannelMixer {
#[inline]
fn tick(&mut self) -> Vec4 {
[self.g[0].tick(), self.g[1].tick(), self.g[2].tick(), self.g[3].tick()]
}
}
// --------------------------------------------------------------------------------- distortion
pub const DIST_CURVES: &[&str] = &["Soft Clip", "Hard Clip", "Tube", "Foldback"];
/// Memoryless transfer curves (unity small-signal slope).
#[inline]
pub fn shape(kind: usize, v: f32) -> f32 {
match kind {
0 => v.tanh(),
1 => v.clamp(-1.0, 1.0),
2 => {
if v >= 0.0 {
v.tanh()
} else {
(1.6 * v).tanh() / 1.6
}
}
_ => v.sin(),
}
}
/// Waveshaping distortion: drive, curve, asymmetry (bias, DC-blocked), tone low-pass, output,
/// dry/wet mix.
pub struct Distortion {
pv: ParamValues,
sr: f32,
dc: Vec<DcBlock>,
lp: Vec<OnePole>,
drive: Smoothed,
bias: Smoothed,
out: Smoothed,
mix: Smoothed,
}
impl Distortion {
pub const PARAMS: &'static [ParamSpec] = &[
ParamSpec::new("drive", "Drive", 0.0, 48.0, 12.0, Unit::Decibels),
ParamSpec::choice("curve", "Curve", DIST_CURVES, 0),
ParamSpec::new("symmetry", "Asymmetry", -100.0, 100.0, 0.0, Unit::Percent),
ParamSpec::log("tone", "Tone", 500.0, 20000.0, 20000.0, Unit::Hertz),
ParamSpec::new("output", "Output Gain", -48.0, 12.0, 0.0, Unit::Decibels),
ParamSpec::new("mix", "Mix", 0.0, 100.0, 100.0, Unit::Percent),
];
pub fn new(sample_rate: f32, channels: usize) -> Self {
let ch = channels.max(1);
let mut s = Distortion {
pv: ParamValues::new(Self::PARAMS),
sr: sample_rate,
dc: vec![DcBlock::default(); ch],
lp: vec![OnePole::default(); ch],
drive: sm(1.0, sample_rate),
bias: sm(0.0, sample_rate),
out: sm(1.0, sample_rate),
mix: sm(1.0, sample_rate),
};
s.apply_params(true);
s
}
fn apply_params(&mut self, snap: bool) {
self.drive.set(db_to_gain(self.pv.v("drive")));
self.bias.set(0.5 * self.pv.v("symmetry") / 100.0);
self.out.set(db_to_gain(self.pv.v("output")));
self.mix.set(self.pv.v("mix") / 100.0);
if snap {
for s in [&mut self.drive, &mut self.bias, &mut self.out, &mut self.mix] {
s.snap();
}
}
}
}
impl AudioEffect for Distortion {
param_plumbing!("distortion");
fn reset(&mut self) {
self.dc.iter_mut().for_each(DcBlock::reset);
self.lp.iter_mut().for_each(OnePole::reset);
for s in [&mut self.drive, &mut self.bias, &mut self.out, &mut self.mix] {
s.snap();
}
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
let nch = channels.len().min(self.dc.len());
let kind = self.pv.idx("curve");
let tone = self.pv.v("tone");
let a = OnePole::alpha(tone, self.sr);
let r = DcBlock::r(self.sr);
for i in 0..n {
let (d, b, o, m) = (self.drive.tick(), self.bias.tick(), self.out.tick(), self.mix.tick());
for ch in 0..nch {
let x = channels[ch][i];
let mut y = shape(kind, d * x + b) - shape(kind, b);
y = self.dc[ch].tick(r, y);
if tone < 19999.0 {
y = self.lp[ch].lp(a, y);
}
channels[ch][i] = x + m * (y * o - x);
}
}
}
}
// -------------------------------------------------------------------------------- GuitarSuite
pub const GS_AMPS: &[&str] = &["None", "Clean Combo", "British Stack", "Tweed", "Modern High Gain"];
pub const GS_FILTERS: &[&str] = &["None", "Low Pass", "High Pass", "Band Pass"];
pub const GS_DIST: &[&str] = &["Soft", "Hard", "Fuzz"];
/// Guitar chain: compressor → distortion → amplifier/cabinet voicing → filter, with mix and
/// output gain.
pub struct GuitarSuite {
pv: ParamValues,
sr: f32,
env: f32,
cab: [Coeffs; 4],
filt: Coeffs,
st: Vec<[Biquad; 5]>,
dc: Vec<DcBlock>,
mix: Smoothed,
out: Smoothed,
drive: Smoothed,
}
impl GuitarSuite {
pub const PARAMS: &'static [ParamSpec] = &[
ParamSpec::new("compressor", "Compressor", 0.0, 100.0, 30.0, Unit::Percent),
ParamSpec::new("distortion", "Distortion", 0.0, 100.0, 40.0, Unit::Percent),
ParamSpec::choice("dist_type", "Distortion Type", GS_DIST, 0),
ParamSpec::choice("amp", "Amplifier", GS_AMPS, 1),
ParamSpec::choice("filter", "Filter", GS_FILTERS, 0),
ParamSpec::log("filter_freq", "Filter Frequency", 100.0, 10000.0, 2000.0, Unit::Hertz),
ParamSpec::new("filter_res", "Filter Resonance", 0.0, 100.0, 20.0, Unit::Percent),
ParamSpec::new("mix", "Mix", 0.0, 100.0, 100.0, Unit::Percent),
ParamSpec::new("output", "Output Gain", -24.0, 12.0, 0.0, Unit::Decibels),
];
pub fn new(sample_rate: f32, channels: usize) -> Self {
let ch = channels.max(1);
let mut s = GuitarSuite {
pv: ParamValues::new(Self::PARAMS),
sr: sample_rate,
env: 0.0,
cab: [Coeffs::IDENTITY; 4],
filt: Coeffs::IDENTITY,
st: vec![[Biquad::new(); 5]; ch],
dc: vec![DcBlock::default(); ch],
mix: sm(1.0, sample_rate),
out: sm(1.0, sample_rate),
drive: sm(1.0, sample_rate),
};
s.apply_params(true);
s
}
fn apply_params(&mut self, snap: bool) {
let sr = self.sr as f64;
let d = |k, f, q, g| Coeffs::design(k, sr, f, q, g);
use FilterType::*;
self.cab = match self.pv.idx("amp") {
0 => [Coeffs::IDENTITY; 4],
1 => [d(HighPass, 70.0, 0.7, 0.0), d(Peaking, 400.0, 0.8, -2.0), d(Peaking, 2500.0, 1.0, 3.0), d(LowPass, 6000.0, 0.8, 0.0)],
2 => [d(HighPass, 90.0, 0.7, 0.0), d(Peaking, 800.0, 0.7, 4.0), d(Peaking, 3000.0, 1.2, 2.0), d(LowPass, 4500.0, 0.9, 0.0)],
3 => [d(HighPass, 60.0, 0.7, 0.0), d(LowShelf, 200.0, 0.7, 3.0), d(Peaking, 1200.0, 0.8, 2.0), d(LowPass, 4000.0, 0.7, 0.0)],
_ => [d(HighPass, 100.0, 0.8, 0.0), d(Peaking, 500.0, 1.0, -5.0), d(Peaking, 2000.0, 0.8, 5.0), d(LowPass, 5000.0, 1.0, 0.0)],
};
let q = 0.5 + 7.5 * self.pv.v("filter_res") / 100.0;
let f = self.pv.v("filter_freq") as f64;
self.filt = match self.pv.idx("filter") {
1 => d(LowPass, f, q as f64, 0.0),
2 => d(HighPass, f, q as f64, 0.0),
3 => d(BandPass, f, q as f64, 0.0),
_ => Coeffs::IDENTITY,
};
self.mix.set(self.pv.v("mix") / 100.0);
self.out.set(db_to_gain(self.pv.v("output")));
self.drive.set(db_to_gain(36.0 * self.pv.v("distortion") / 100.0));
if snap {
self.mix.snap();
self.out.snap();
self.drive.snap();
}
}
}
impl AudioEffect for GuitarSuite {
param_plumbing!("guitar_suite");
fn reset(&mut self) {
self.env = 0.0;
self.st.iter_mut().for_each(|s| s.iter_mut().for_each(Biquad::reset));
self.dc.iter_mut().for_each(DcBlock::reset);
self.mix.snap();
self.out.snap();
self.drive.snap();
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
let nch = channels.len().min(self.st.len());
let comp = self.pv.v("compressor") / 100.0;
let (thr, ratio) = (-6.0 - 30.0 * comp, 1.0 + 7.0 * comp);
let (att, rel) = (coef(5.0, self.sr), coef(120.0, self.sr));
let kind = match self.pv.idx("dist_type") {
0 => 0,
1 => 1,
_ => 2,
};
let r = DcBlock::r(self.sr);
for i in 0..n {
let (mix, out, drive) = (self.mix.tick(), self.out.tick(), self.drive.tick());
let peak = channels[..nch].iter().fold(0.0f32, |a, c| a.max(c[i].abs()));
let l = lin_db(peak);
let target = if comp > 0.0 && l > thr { (thr + (l - thr) / ratio) - l } else { 0.0 };
let c = if target < self.env { att } else { rel };
self.env = c * self.env + (1.0 - c) * target;
if !(1e-7..=f32::MAX).contains(&self.env.abs()) {
self.env = 0.0;
}
let g = db_to_gain(self.env);
// Distortion level compensation keeps the output near the input level.
let comp_out = 1.0 / drive.sqrt();
for ch in 0..nch {
let x = channels[ch][i];
let v = x * g * drive;
let mut y = match kind {
0 => v.tanh(),
1 => v.clamp(-1.0, 1.0),
_ => (v + 0.3).tanh() - 0.3f32.tanh() + 0.5 * (2.0 * v).tanh(),
} * comp_out;
y = self.dc[ch].tick(r, y);
let st = &mut self.st[ch];
let mut yd = y as f64;
for (k, c) in self.cab.iter().enumerate() {
yd = st[k].tick(c, yd);
}
yd = st[4].tick(&self.filt, yd);
channels[ch][i] = x + mix * (yd as f32 * out - x);
}
}
}
}
// --------------------------------------------------------------------------------- mastering
pub const EXCITER_MODES: &[&str] = &["Retro", "Tape", "Tube"];
/// Mastering chain: three-band EQ → reverb → exciter → widener → loudness maximiser → output.
/// At its defaults it is transparent.
pub struct Mastering {
pv: ParamValues,
sr: f32,
eq: [Coeffs; 3],
st: Vec<[Biquad; 3]>,
rev: Reverb,
scratch: [[f32; CHUNK]; 2],
hp: Vec<OnePole>,
lim_env: f32,
rev_amt: Smoothed,
exc: Smoothed,
width: Smoothed,
boost: Smoothed,
out: Smoothed,
}
impl Mastering {
pub const PARAMS: &'static [ParamSpec] = &[
ParamSpec::new("eq_low", "Low Shelf Gain", -12.0, 12.0, 0.0, Unit::Decibels),
ParamSpec::log("eq_mid_freq", "Peak Frequency", 100.0, 10000.0, 1000.0, Unit::Hertz),
ParamSpec::new("eq_mid", "Peak Gain", -12.0, 12.0, 0.0, Unit::Decibels),
ParamSpec::new("eq_high", "High Shelf Gain", -12.0, 12.0, 0.0, Unit::Decibels),
ParamSpec::new("reverb", "Reverb Amount", 0.0, 100.0, 0.0, Unit::Percent),
ParamSpec::new("exciter", "Exciter Amount", 0.0, 100.0, 0.0, Unit::Percent),
ParamSpec::choice("exciter_mode", "Exciter Mode", EXCITER_MODES, 1),
ParamSpec::new("widener", "Widener", 0.0, 200.0, 100.0, Unit::Percent),
ParamSpec::new("loudness", "Loudness Maximizer", 0.0, 100.0, 0.0, Unit::Percent),
ParamSpec::new("output", "Output Gain", -24.0, 12.0, 0.0, Unit::Decibels),
];
pub fn new(sample_rate: f32, channels: usize) -> Self {
let ch = channels.max(1);
let mut rev = Reverb::new(sample_rate, 2);
rev.set_param("mix", 100.0);
rev.set_param("decay", 1.4);
rev.set_param("size", 40.0);
rev.reset();
let mut s = Mastering {
pv: ParamValues::new(Self::PARAMS),
sr: sample_rate,
eq: [Coeffs::IDENTITY; 3],
st: vec![[Biquad::new(); 3]; ch],
rev,
scratch: [[0.0; CHUNK]; 2],
hp: vec![OnePole::default(); ch],
lim_env: 0.0,
rev_amt: sm(0.0, sample_rate),
exc: sm(0.0, sample_rate),
width: sm(1.0, sample_rate),
boost: sm(1.0, sample_rate),
out: sm(1.0, sample_rate),
};
s.apply_params(true);
s
}
fn apply_params(&mut self, snap: bool) {
let sr = self.sr as f64;
let q = std::f64::consts::FRAC_1_SQRT_2;
self.eq = [
Coeffs::design(FilterType::LowShelf, sr, 100.0, q, self.pv.v("eq_low") as f64),
Coeffs::design(FilterType::Peaking, sr, self.pv.v("eq_mid_freq") as f64, 1.0, self.pv.v("eq_mid") as f64),
Coeffs::design(FilterType::HighShelf, sr, 8000.0, q, self.pv.v("eq_high") as f64),
];
self.rev_amt.set(0.4 * self.pv.v("reverb") / 100.0);
self.exc.set(0.6 * self.pv.v("exciter") / 100.0);
self.width.set(self.pv.v("widener") / 100.0);
self.boost.set(db_to_gain(12.0 * self.pv.v("loudness") / 100.0));
self.out.set(db_to_gain(self.pv.v("output")));
if snap {
for s in [&mut self.rev_amt, &mut self.exc, &mut self.width, &mut self.boost, &mut self.out] {
s.snap();
}
}
}
}
impl AudioEffect for Mastering {
param_plumbing!("mastering");
fn response_db(&self, freq: f64) -> Option<f64> {
Some(self.eq.iter().map(|c| c.magnitude_db(freq, self.sr as f64)).sum::<f64>() + self.pv.v("output") as f64)
}
fn reset(&mut self) {
self.st.iter_mut().for_each(|s| s.iter_mut().for_each(Biquad::reset));
self.rev.reset();
self.hp.iter_mut().for_each(OnePole::reset);
self.lim_env = 0.0;
for s in [&mut self.rev_amt, &mut self.exc, &mut self.width, &mut self.boost, &mut self.out] {
s.snap();
}
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
let nch = channels.len().min(self.st.len());
if nch == 0 {
return;
}
let loud = self.pv.v("loudness") > 0.0;
let use_rev = self.pv.v("reverb") > 0.0;
let mode = self.pv.idx("exciter_mode");
let ahp = OnePole::alpha(3000.0, self.sr);
let ceiling = db_to_gain(-0.3);
let rel = coef(60.0, self.sr);
let mut start = 0;
while start < n {
let len = (n - start).min(CHUNK);
// EQ in place.
for ch in 0..nch {
for v in channels[ch][start..start + len].iter_mut() {
let mut y = *v as f64;
for (k, c) in self.eq.iter().enumerate() {
y = self.st[ch][k].tick(c, y);
}
*v = y as f32;
}
}
if use_rev {
for i in 0..len {
self.scratch[0][i] = channels[0][start + i];
self.scratch[1][i] = channels[nch.min(2) - 1][start + i];
}
let [a, b] = &mut self.scratch;
self.rev.process(&mut [&mut a[..len], &mut b[..len]]);
}
for i in 0..len {
let (ra, ex, w, boost, out) = (self.rev_amt.tick(), self.exc.tick(), self.width.tick(), self.boost.tick(), self.out.tick());
let mut y = [0.0f32; 2];
for ch in 0..nch.min(2) {
let mut v = channels[ch][start + i];
if use_rev {
v += ra * self.scratch[ch][i];
}
if ex > 0.0 {
let h = self.hp[ch].hp(ahp, v);
let s = match mode {
0 => (3.0 * h).clamp(-1.0, 1.0) / 3.0,
1 => (3.0 * h).tanh() / 3.0,
_ => ((3.0 * h + 0.2).tanh() - 0.2f32.tanh()) / 3.0,
};
v += ex * (s - h * 0.5) * 2.0;
}
y[ch] = v;
}
if nch >= 2 {
let (m, s) = (0.5 * (y[0] + y[1]), 0.5 * (y[0] - y[1]) * w);
y = [m + s, m - s];
}
if loud {
for v in y.iter_mut().take(nch.min(2)) {
*v *= boost;
}
let peak = y[..nch.min(2)].iter().fold(0.0f32, |a, v| a.max(v.abs()));
let target = (lin_db(ceiling) - lin_db(peak)).min(0.0);
if target < self.lim_env {
// An inf input sample gives -inf, which the release would never leave.
self.lim_env = if target.is_finite() { target } else { 0.0 };
} else {
self.lim_env = rel * self.lim_env + (1.0 - rel) * target;
}
let g = db_to_gain(self.lim_env);
for v in y.iter_mut().take(nch.min(2)) {
*v = soft_clip(*v * g, ceiling);
}
}
for ch in 0..nch.min(2) {
channels[ch][start + i] = y[ch] * out;
}
}
start += len;
}
}
}
// ---------------------------------------------------------------------------- vocal enhancer
pub const VOCAL_MODES: &[&str] = &["Male", "Female", "Music"];
/// Fixed voicings: Male / Female (rumble cut, de-mud, presence and air, gentle 2:1
/// compression) or Music (carves the vocal presence range so a voice sits on top).
pub struct VocalEnhancer {
pv: ParamValues,
sr: f32,
eq: [Coeffs; 4],
st: Vec<[Biquad; 4]>,
env: f32,
}
impl VocalEnhancer {
pub const PARAMS: &'static [ParamSpec] = &[ParamSpec::choice("mode", "Mode", VOCAL_MODES, 0)];
pub fn new(sample_rate: f32, channels: usize) -> Self {
let mut s = VocalEnhancer {
pv: ParamValues::new(Self::PARAMS),
sr: sample_rate,
eq: [Coeffs::IDENTITY; 4],
st: vec![[Biquad::new(); 4]; channels.max(1)],
env: 0.0,
};
s.apply_params(true);
s
}
fn apply_params(&mut self, _snap: bool) {
let sr = self.sr as f64;
let d = |k, f, q, g| Coeffs::design(k, sr, f, q, g);
use FilterType::*;
self.eq = match self.pv.idx("mode") {
0 => [d(HighPass, 80.0, 0.707, 0.0), d(Peaking, 250.0, 1.0, -3.0), d(Peaking, 3000.0, 1.0, 3.0), d(HighShelf, 10000.0, 0.707, 1.5)],
1 => [d(HighPass, 120.0, 0.707, 0.0), d(Peaking, 400.0, 1.0, -2.0), d(Peaking, 5000.0, 1.0, 3.0), d(HighShelf, 10000.0, 0.707, 2.0)],
_ => [d(HighPass, 40.0, 0.707, 0.0), d(Peaking, 1500.0, 0.7, -4.0), d(Peaking, 3500.0, 1.0, -2.0), Coeffs::IDENTITY],
};
}
}
impl AudioEffect for VocalEnhancer {
param_plumbing!("vocal_enhancer");
fn response_db(&self, freq: f64) -> Option<f64> {
Some(self.eq.iter().map(|c| c.magnitude_db(freq, self.sr as f64)).sum())
}
fn reset(&mut self) {
self.st.iter_mut().for_each(|s| s.iter_mut().for_each(Biquad::reset));
self.env = 0.0;
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
let nch = channels.len().min(self.st.len());
let voice = self.pv.idx("mode") < 2;
let (att, rel) = (coef(5.0, self.sr), coef(150.0, self.sr));
for i in 0..n {
for ch in 0..nch {
let mut y = channels[ch][i] as f64;
for (k, c) in self.eq.iter().enumerate() {
y = self.st[ch][k].tick(c, y);
}
channels[ch][i] = y as f32;
}
if voice {
let peak = channels[..nch].iter().fold(0.0f32, |a, c| a.max(c[i].abs()));
let l = lin_db(peak);
let target = if l > -18.0 { (-18.0 + (l + 18.0) / 2.0) - l } else { 0.0 };
let c = if target < self.env { att } else { rel };
self.env = c * self.env + (1.0 - c) * target;
if !(1e-7..=f32::MAX).contains(&self.env.abs()) {
self.env = 0.0;
}
let g = db_to_gain(self.env);
for ch in channels[..nch].iter_mut() {
ch[i] *= g;
}
}
}
}
}
// --------------------------------------------------------------------------- stereo expander
/// Mid/side: the side signal is scaled by Stereo Expand and the centre (mid) signal is panned.
pub struct StereoExpander {
pv: ParamValues,
gl: Smoothed,
gr: Smoothed,
side: Smoothed,
}
impl StereoExpander {
pub const PARAMS: &'static [ParamSpec] = &[
ParamSpec::new("center_pan", "Center Channel Pan", -100.0, 100.0, 0.0, Unit::Pan),
ParamSpec::new("expand", "Stereo Expand", 0.0, 300.0, 100.0, Unit::Percent),
];
pub fn new(sample_rate: f32, _channels: usize) -> Self {
let mut s = StereoExpander { pv: ParamValues::new(Self::PARAMS), gl: sm(1.0, sample_rate), gr: sm(1.0, sample_rate), side: sm(1.0, sample_rate) };
s.apply_params(true);
s
}
fn apply_params(&mut self, snap: bool) {
let p = self.pv.v("center_pan") / 100.0;
self.gl.set((1.0 - p).min(1.0));
self.gr.set((1.0 + p).min(1.0));
self.side.set(self.pv.v("expand") / 100.0);
if snap {
for s in [&mut self.gl, &mut self.gr, &mut self.side] {
s.snap();
}
}
}
}
impl AudioEffect for StereoExpander {
param_plumbing!("stereo_expander");
fn reset(&mut self) {
for s in [&mut self.gl, &mut self.gr, &mut self.side] {
s.snap();
}
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
if channels.len() < 2 {
return;
}
let (a, b) = channels.split_at_mut(1);
let (l, r) = (&mut a[0], &mut b[0]);
for i in 0..n {
let (gl, gr, w) = (self.gl.tick(), self.gr.tick(), self.side.tick());
let (m, s) = (0.5 * (l[i] + r[i]), 0.5 * (l[i] - r[i]) * w);
l[i] = m * gl + s;
r[i] = m * gr - s;
}
}
}
// ------------------------------------------------------------------------------ binauralizer
const SPEED_OF_SOUND: f32 = 343.0;
/// Head-shadow filter (one-pole/one-zero spherical-head model, Brown & Duda 1998):
/// H(s) = (1 + α s / 2ω₀) / (1 + s / 2ω₀), ω₀ = c / a, α from the angle of incidence.
#[derive(Clone, Copy, Debug, Default)]
struct Shadow {
b0: f32,
b1: f32,
a1: f32,
x1: f32,
y1: f32,
}
impl Shadow {
fn design(incidence_deg: f32, radius: f32, sr: f32) -> Shadow {
let alpha = 1.05 + 0.95 * (incidence_deg / 150.0 * PI).cos();
let w0 = SPEED_OF_SOUND / radius;
let k = 2.0 * sr;
let t = k / (2.0 * w0);
let a0 = 1.0 + t;
Shadow { b0: (1.0 + alpha * t) / a0, b1: (1.0 - alpha * t) / a0, a1: (1.0 - t) / a0, x1: 0.0, y1: 0.0 }
}
#[inline]
fn tick(&mut self, x: f32) -> f32 {
let y = self.b0 * x + self.b1 * self.x1 - self.a1 * self.y1;
self.x1 = x;
self.y1 = flush32(y);
y
}
fn set_coeffs(&mut self, o: &Shadow) {
self.b0 = o.b0;
self.b1 = o.b1;
self.a1 = o.a1;
}
}
/// Renders the stereo input as two virtual loudspeakers at ±`angle` heard through a spherical
/// head model (Woodworth interaural time difference + head-shadow filtering), for headphones.
pub struct Binauralizer {
pv: ParamValues,
sr: f32,
lines: [DelayLine; 2],
/// near-L, far-L→R, near-R, far-R→L
sh: [Shadow; 4],
itd: Smoothed,
mix: Smoothed,
}
impl Binauralizer {
pub const PARAMS: &'static [ParamSpec] = &[
ParamSpec::new("angle", "Speaker Angle", 0.0, 90.0, 30.0, Unit::None),
ParamSpec::new("head_size", "Head Size", 12.0, 24.0, 17.5, Unit::None),
ParamSpec::new("mix", "Mix", 0.0, 100.0, 100.0, Unit::Percent),
];
pub fn new(sample_rate: f32, _channels: usize) -> Self {
let max = (0.002 * sample_rate) as usize + 4;
let mut s = Binauralizer {
pv: ParamValues::new(Self::PARAMS),
sr: sample_rate,
lines: [DelayLine::new(max), DelayLine::new(max)],
sh: [Shadow::default(); 4],
itd: sm(0.0, sample_rate),
mix: sm(1.0, sample_rate),
};
s.apply_params(true);
s
}
fn apply_params(&mut self, snap: bool) {
let theta = self.pv.v("angle");
let a = self.pv.v("head_size") * 0.01 / 2.0;
// Ears at ±90°: near ear sees the source at 90° − θ off its axis, the far ear 90° + θ.
let near = Shadow::design(90.0 - theta, a, self.sr);
let far = Shadow::design(90.0 + theta, a, self.sr);
for (k, s) in self.sh.iter_mut().enumerate() {
s.set_coeffs(if k % 2 == 0 { &near } else { &far });
}
let th = theta.to_radians();
self.itd.set(a / SPEED_OF_SOUND * (th + th.sin()) * self.sr);
self.mix.set(self.pv.v("mix") / 100.0);
if snap {
self.itd.snap();
self.mix.snap();
}
}
}
impl AudioEffect for Binauralizer {
param_plumbing!("binauralizer");
fn reset(&mut self) {
self.lines.iter_mut().for_each(DelayLine::reset);
for s in &mut self.sh {
s.x1 = 0.0;
s.y1 = 0.0;
}
self.itd.snap();
self.mix.snap();
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
if channels.len() < 2 {
return;
}
let (a, b) = channels.split_at_mut(1);
let (l, r) = (&mut a[0], &mut b[0]);
for i in 0..n {
let (itd, mix) = (self.itd.tick(), self.mix.tick());
let (xl, xr) = (l[i], r[i]);
self.lines[0].push(xl);
self.lines[1].push(xr);
let near_l = self.sh[0].tick(xl);
let far_l = self.sh[1].tick(self.lines[0].read(itd));
let near_r = self.sh[2].tick(xr);
let far_r = self.sh[3].tick(self.lines[1].read(itd));
let (bl, br) = (0.5 * (near_l + far_r), 0.5 * (near_r + far_l));
l[i] = xl + mix * (bl - xl);
r[i] = xr + mix * (br - xr);
}
}
}
// ------------------------------------------------------------------------- ambisonics panner
/// Rotates the sound field (pan / tilt / roll) of a stereo source pair placed at ±30° and
/// re-renders it to stereo with constant-power panning; sources turned behind the listener
/// are attenuated, raised/lowered sources slightly softened. Identity at 0/0/0.
pub struct AmbisonicsPanner {
pv: ParamValues,
/// out L ← in L, out L ← in R, out R ← in L, out R ← in R
m: [Smoothed; 4],
}
impl AmbisonicsPanner {
pub const PARAMS: &'static [ParamSpec] = &[
ParamSpec::new("pan", "Pan", -180.0, 180.0, 0.0, Unit::None),
ParamSpec::new("tilt", "Tilt", -90.0, 90.0, 0.0, Unit::None),
ParamSpec::new("roll", "Roll", -180.0, 180.0, 0.0, Unit::None),
];
pub fn new(sample_rate: f32, _channels: usize) -> Self {
let mut s = AmbisonicsPanner {
pv: ParamValues::new(Self::PARAMS),
m: [sm(1.0, sample_rate), sm(0.0, sample_rate), sm(0.0, sample_rate), sm(1.0, sample_rate)],
};
s.apply_params(true);
s
}
/// (left gain, right gain) for a source at azimuth `az` (degrees, + = left) after rotation.
pub fn source_gains(az: f32, pan: f32, tilt: f32, roll: f32) -> (f32, f32) {
let (az, el) = (az.to_radians(), 0.0f32);
// x forward, y left, z up
let mut v = [el.cos() * az.cos(), el.cos() * az.sin(), el.sin()];
let rot = |v: [f32; 3], axis: usize, ang: f32| -> [f32; 3] {
let (s, c) = ang.to_radians().sin_cos();
let [x, y, z] = v;
match axis {
0 => [x, c * y - s * z, s * y + c * z],
1 => [c * x + s * z, y, -s * x + c * z],
_ => [c * x - s * y, s * x + c * y, z],
}
};
v = rot(v, 0, roll);
v = rot(v, 1, tilt);
v = rot(v, 2, pan);
let p = (v[1] / 30f32.to_radians().sin()).clamp(-1.0, 1.0);
// constant power: p = 1 → all left, −1 → all right
let a = (1.0 - p) * 0.5 * FRAC_PI_2;
let (mut gl, mut gr) = (a.cos(), a.sin());
let att = (1.0 - 0.3 * (-v[0]).max(0.0)) * (1.0 - 0.2 * v[2].abs());
gl *= att;
gr *= att;
(gl, gr)
}
fn apply_params(&mut self, snap: bool) {
let (pan, tilt, roll) = (self.pv.v("pan"), self.pv.v("tilt"), self.pv.v("roll"));
let (ll, rl) = Self::source_gains(30.0, pan, tilt, roll);
let (lr, rr) = Self::source_gains(-30.0, pan, tilt, roll);
let clean = |v: f32| {
if v.abs() < 1e-6 {
0.0
} else if (v - 1.0).abs() < 1e-6 {
1.0
} else {
v
}
};
for (s, v) in self.m.iter_mut().zip([ll, lr, rl, rr]) {
s.set(clean(v));
if snap {
s.snap();
}
}
}
}
impl AudioEffect for AmbisonicsPanner {
param_plumbing!("ambisonics_panner");
fn reset(&mut self) {
self.m.iter_mut().for_each(Smoothed::snap);
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
if channels.len() < 2 {
return;
}
let (a, b) = channels.split_at_mut(1);
let (l, r) = (&mut a[0], &mut b[0]);
for i in 0..n {
let g = [self.m[0].tick(), self.m[1].tick(), self.m[2].tick(), self.m[3].tick()];
let (x, y) = (l[i], r[i]);
l[i] = g[0] * x + g[1] * y;
r[i] = g[2] * x + g[3] * y;
}
}
}
// ------------------------------------------------------------------------------- loudness meter
/// Pass-through effect that measures BS.1770 loudness (momentary, short-term, integrated,
/// range, true peak) of the signal at its insert point.
pub struct LoudnessMeterFx {
pv: ParamValues,
meter: LoudnessMeter,
}
impl LoudnessMeterFx {
pub const PARAMS: &'static [ParamSpec] = &[ParamSpec::new("target", "Target Loudness", -36.0, -5.0, -23.0, Unit::None)];
pub fn new(sample_rate: f32, channels: usize) -> Self {
LoudnessMeterFx { pv: ParamValues::new(Self::PARAMS), meter: LoudnessMeter::new(sample_rate as f64, channels.clamp(1, 2)) }
}
fn apply_params(&mut self, _snap: bool) {}
/// The running meter.
pub fn meter(&self) -> &LoudnessMeter {
&self.meter
}
}
impl AudioEffect for LoudnessMeterFx {
param_plumbing!("loudness_meter");
fn reset(&mut self) {
self.meter.reset();
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
let nch = self.meter.channels().min(channels.len());
if nch == 0 || n == 0 {
return;
}
if nch == 1 {
self.meter.process(&[&channels[0][..n]]);
} else {
self.meter.process(&[&channels[0][..n], &channels[1][..n]]);
}
}
}
// ----------------------------------------------------------------------------------- mute
/// Mute with a 5 ms ramp (keyframe it to silence passages without clicks).
pub struct Mute {
pv: ParamValues,
g: Smoothed,
}
impl Mute {
pub const PARAMS: &'static [ParamSpec] = &[ParamSpec::toggle("mute", "Mute", false)];
pub fn new(sample_rate: f32, _channels: usize) -> Self {
let mut s = Mute { pv: ParamValues::new(Self::PARAMS), g: Smoothed::with_ms(1.0, sample_rate, 5.0) };
s.apply_params(true);
s
}
fn apply_params(&mut self, snap: bool) {
self.g.set(if self.pv.on("mute") { 0.0 } else { 1.0 });
if snap {
self.g.snap();
}
}
}
impl AudioEffect for Mute {
param_plumbing!("mute");
fn reset(&mut self) {
self.g.snap();
}
fn process(&mut self, channels: &mut [&mut [f32]]) {
let n = block_len(channels);
for i in 0..n {
let g = self.g.tick();
for ch in channels.iter_mut() {
ch[i] *= g;
}
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.