//! 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); }