//! DM11: DM01 linear/cubic Delay and two-tap Chorus with independently selected
//! audio precision and output-storage policy. Positions and LFO remain f64.
use std::{hint::black_box, io::Write, time::Instant};
#[cfg(signal_f32)]
type Sample = f32;
#[cfg(not(signal_f32))]
type Sample = f64;
type Frame = [Sample; 2];
const LFO_SIZE: usize = 4096;
#[derive(Clone, PartialEq, Debug)]
struct State {
line: Vec,
write: usize,
phases: [f64; 2],
}
#[derive(Clone)]
struct Effect {
state: State,
lfo: Vec,
chorus: bool,
rate: f64,
}
impl Effect {
fn new(chorus: bool, rate: f64) -> Self {
Self {
state: State {
line: vec![[0.0; 2]; ((rate * if chorus {0.06} else {2.0}) as usize + 34).next_power_of_two()],
write: 0,
phases: [0.0, 0.5],
},
lfo: if chorus {(0..=LFO_SIZE).map(|i| (std::f64::consts::TAU * i as f64 / LFO_SIZE as f64).sin()).collect()} else {Vec::new()},
chorus,
rate,
}
}
#[inline(always)]
fn tap(&self, delay: f64) -> Frame {
let integer = delay.floor() as usize;
let u = (delay - integer as f64) as Sample;
let read = |d| self.state.line[self.state.write.wrapping_sub(d) & (self.state.line.len() - 1)];
let x1 = read(integer);
let x2 = read(integer + 1);
if M == 1 {
return std::array::from_fn(|c| x1[c] + u * (x2[c] - x1[c]));
}
let x0 = read(integer - 1);
let x3 = read(integer + 2);
std::array::from_fn(|c| {
let c1 = -x0[c] / 3.0 - x1[c] / 2.0 + x2[c] - x3[c] / 6.0;
let c2 = (x0[c] - 2.0 * x1[c] + x2[c]) / 2.0;
let c3 = (-x0[c] + 3.0 * x1[c] - 3.0 * x2[c] + x3[c]) / 6.0;
x1[c] + u * (c1 + u * (c2 + u * c3))
})
}
#[inline]
fn process_sample(&mut self, input: Frame) -> Frame {
let wet = if self.chorus {
let increment = 0.7 / self.rate;
let mut wet = [0.0; 2];
for (i, ratio) in [1.0, 0.83].iter().enumerate() {
let phase = self.state.phases[i];
let t = phase * LFO_SIZE as f64;
let j = t as usize;
let modulation = self.lfo[j] + (t - j as f64) * (self.lfo[j + 1] - self.lfo[j]);
self.state.phases[i] += increment * ratio;
if self.state.phases[i] >= 1.0 {self.state.phases[i] -= 1.0;}
let value = self.tap(self.rate * 0.020 + self.rate * 0.002 * modulation);
wet[i] += value[i];
}
wet
} else {self.tap(self.rate * 0.375 + 0.37)};
let gain: Sample = if self.chorus {0.0} else {0.6};
self.state.line[self.state.write] = std::array::from_fn(|c| input[c] + gain * wet[c]);
self.state.write = (self.state.write + 1) & (self.state.line.len() - 1);
std::array::from_fn(|c| 0.5 * input[c] + 0.5 * wet[c])
}
fn process_samples(&mut self, input: &[Frame], output: &mut [Frame]) {
for (x, y) in input.iter().zip(output) {*y = self.process_sample(*x);}
}
fn bytes(&self) -> usize {std::mem::size_of::() + self.state.line.capacity() * std::mem::size_of::() + self.lfo.capacity() * 8}
}
fn source(frames: usize, rate: usize) -> Vec {
let mut seed = 0x1879ab3de425u64;
(0..frames).map(|n| {
seed ^= seed << 13; seed ^= seed >> 7; seed ^= seed << 17;
let noise = (seed >> 11) as f64 / (1u64 << 53) as f64 - 0.5;
let t = n as f64 / rate as f64;
let envelope = 0.25 + 0.75 * (-5.0 * (t % 0.5)).exp();
std::array::from_fn(|c| {
let mut value = 0.0;
for (note, pan) in [(110.0,[1.0,0.4]),(164.813778,[0.4,1.0]),(220.0,[0.7,0.7])] {
for harmonic in 1..=12 {value += pan[c] * (std::f64::consts::TAU * note * harmonic as f64 * t).sin() / harmonic as f64;}
}
(value * 0.08 * envelope + noise * 0.015) as Sample
})
}).collect()
}
fn run(effect: &mut Effect, input: &[Frame], output: &mut [Frame], block: usize) {
for (i, x) in input.chunks(block).enumerate() {
let start = if REUSE {0} else {i * block};
let y = &mut output[start..start+x.len()];
if BYPASS {black_box(&mut *y).copy_from_slice(black_box(x));}
else {effect.process_samples(black_box(x), black_box(&mut *y));}
black_box(y);
}
}
fn statistics(output: &[Frame]) -> (u64, f64, f64) {
let mut hash = 0xcbf29ce484222325u64;
let mut peak = 0.0_f64;
let mut power = 0.0;
for frame in output {for x in frame {
let x = *x as f64;
assert!(x.is_finite());
hash = (hash ^ x.to_bits()).wrapping_mul(0x100000001b3);
peak = peak.max(x.abs()); power += x*x;
}}
(hash,peak,(power/(output.len()*2) as f64).sqrt())
}
fn mxcsr() -> u32 {
let mut value = 0u32;
// STMXCSR writes exactly four bytes into a live local u32.
unsafe {std::arch::asm!("stmxcsr [{ptr}]", ptr=in(reg) &mut value, options(nostack,preserves_flags));}
value
}
fn set_mxcsr(value: u32) {
// The value comes from STMXCSR; only the supported FTZ/DAZ flags are altered.
unsafe {std::arch::asm!("ldmxcsr [{ptr}]", ptr=in(reg) &value, options(nostack,preserves_flags));}
}
fn write_audio(path: &str, output: &[Frame]) {
let mut file = std::io::BufWriter::new(std::fs::File::create(path).unwrap());
for frame in output {for x in frame {file.write_all(&(*x as f64).to_le_bytes()).unwrap();}}
}
fn validate(rate: usize, chorus: bool) {
let input = source(rate*3+37, rate);
let mut reference = Effect::::new(chorus, rate as f64);
let mut expected = vec![[0.0;2];input.len()];
run::(&mut reference,&input,&mut expected,256);
for block in [1,7,32,127,256,257] {
let mut effect = Effect::::new(chorus,rate as f64);
let mut scratch = vec![[0.0;2];block];
let mut collected = Vec::with_capacity(input.len());
for x in input.chunks(block) {
effect.process_samples(x,&mut scratch[..x.len()]);
collected.extend_from_slice(&scratch[..x.len()]);
}
assert!(expected.iter().flatten().zip(collected.iter().flatten()).all(|(a,b)| a.to_bits()==b.to_bits()));
assert_eq!(reference.state,effect.state);
}
}
fn bench(args: &[String]) {
let case = &args[2];
let rate:usize=args[3].parse().unwrap();
let block:usize=args[4].parse().unwrap();
let frames=(rate as f64*args[5].parse::().unwrap()).round() as usize;
let burn_ns=(args[6].parse::().unwrap()*1e6) as u128;
let prepare=2*rate;
let input=source(prepare+frames,rate);
let mut prepare_output=vec![[0.0;2];if REUSE {block} else {prepare}];
let mut output=vec![[0.0;2];if REUSE {block} else {frames}];
let prototype=Effect::::new(case.contains("chorus"),rate as f64);
let begin=Instant::now(); let mut cycles=0;
loop {
let mut effect=prototype.clone();
run::(&mut effect,&input[..prepare],&mut prepare_output,block);
run::(&mut effect,&input[prepare..],&mut output,block);
cycles+=1;
if begin.elapsed().as_nanos()>=burn_ns {break;}
}
let burn_elapsed=begin.elapsed().as_nanos();
let mut effect=prototype.clone();
run::(&mut effect,&input[..prepare],&mut prepare_output,block);
let begin=Instant::now();
run::(&mut effect,&input[prepare..],&mut output,block);
let elapsed=begin.elapsed().as_nanos();
let observed=if REUSE {let n=frames%block;if n==0 {block} else {n}} else {frames};
let (checksum,peak,rms)=statistics(&output[..observed]);
println!("{{\"case_id\":\"{case}\",\"frames\":{frames},\"channels\":2,\"elapsed_ns\":{elapsed},\"ns_per_frame\":{},\"burn_in_ns\":{burn_elapsed},\"burn_in_cycles\":{cycles},\"checksum\":\"{checksum:016x}\",\"peak\":{peak},\"rms\":{rms},\"state_bytes\":{},\"latency_samples\":0,\"audio_bits\":{},\"control_bits\":64,\"observed_frames\":{observed},\"input_bytes\":{},\"output_bytes\":{},\"mxcsr\":{}}}",elapsed as f64/frames as f64,if BYPASS {0} else {effect.bytes()},std::mem::size_of::()*8,input.len()*std::mem::size_of::(),output.len()*std::mem::size_of::(),mxcsr());
}
fn dispatch(args: &[String]) {
match args[1].as_str() {
"render" => {
let rate:usize=args[3].parse().unwrap();
let frames=(rate as f64*args[4].parse::().unwrap()).round() as usize;
let input=source(frames,rate); let mut output=vec![[0.0;2];frames];
let mut effect=Effect::::new(args[2].contains("chorus"),rate as f64);
run::(&mut effect,&input,&mut output,256);
write_audio(&args[5],&output);
},
"bench" => match (args[2].contains("reuse"),args[2].contains("bypass")) {
(false,false)=>bench::(args),
(true,false)=>bench::(args),
(false,true)=>bench::(args),
(true,true)=>bench::(args),
},
_ => panic!("unknown command")
}
}
fn main() {
let args:Vec=std::env::args().collect();
let original=mxcsr();
set_mxcsr(original|0x8040);
if args[1]=="validate" {
for rate in [44100,48000,96000] {for chorus in [false,true] {validate::<1>(rate,chorus);validate::<2>(rate,chorus);}}
println!("{{\"partition_cases\":72,\"audio_bits\":{},\"output_and_state_equal\":true,\"mxcsr\":{}}}",std::mem::size_of::()*8,mxcsr());
} else if args[2].contains("lagrange3") {dispatch::<2>(&args);} else {dispatch::<1>(&args);}
set_mxcsr(original);
}