//! DM12: denormal tail control, derived from the fixed DM11 kernel. //! Delay is 125 ms + 0.37 sample; feedback is explicit, positions 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, feedback: Sample, } 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, feedback: 0.6, } } #[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.125 + 0.37)}; let gain: Sample = self.feedback; 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 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));} } #[cfg(signal_f32)] fn subnormal_level() -> Sample {Sample::from_bits(1 << 19)} #[cfg(not(signal_f32))] fn subnormal_level() -> Sample {Sample::from_bits(1 << 44)} fn fp_mode(on: bool) -> u32 { let previous = mxcsr(); set_mxcsr(if on {previous | 0x8040} else {previous & !0x8040}); previous } fn safe_statistics(output: &[Frame]) -> (u64, f64, f64, usize, usize) { let previous = fp_mode(false); let mut hash=0xcbf29ce484222325u64;let mut peak=0.0_f64;let mut nonzero=0;let mut subnormal=0; for frame in output {for &x in frame { let y=x as f64;assert!(y.is_finite());hash=(hash ^ y.to_bits()).wrapping_mul(0x100000001b3); peak=peak.max(y.abs());nonzero+=usize::from(x!=0.0);subnormal+=usize::from(x.is_subnormal()); }} let rms=if peak==0.0 {0.0} else {peak*(output.iter().flatten().map(|&x| ((x as f64)/peak).powi(2)).sum::()/(output.len()*2) as f64).sqrt()}; set_mxcsr(previous);(hash,peak,rms,nonzero,subnormal) } fn tail_audio(args: &[String]) { let case=&args[2];let rate:usize=args[3].parse().unwrap();let seconds:usize=args[4].parse().unwrap(); let block=rate/8;let frames=seconds*rate;let initial=source(rate,rate); let mut effect=Effect::::new(false,rate as f64);let mut input=vec![[0.0;2];block];let mut output=vec![[0.0;2];block]; let mut file=std::io::BufWriter::new(std::fs::File::create(&args[5]).unwrap()); writeln!(file,"start_frame,frames,peak_f64_bits,rms_f64_bits,nonzero,subnormal").unwrap(); for start in (0..frames).step_by(block) { let count=block.min(frames-start);input.fill([0.0;2]); if start()*8,mxcsr()); } fn tail_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=vec![[0.0;2];prepare+frames];let mut output=vec![[0.0;2];block]; let mut prototype=Effect::::new(false,rate as f64);prototype.feedback=0.999; let level:Sample=if case.contains("subnormal") {subnormal_level()} else if case.contains("normal") {1e-20} else {0.0}; prototype.state.line.fill([level,-level]); let begin=Instant::now();let mut cycles=0; loop { let mut effect=prototype.clone();run::(&mut effect,&input[..prepare],&mut 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 output,block); let active=mxcsr();let begin=Instant::now();run::(&mut effect,&input[prepare..],&mut output,block);let elapsed=begin.elapsed().as_nanos(); let observed=if frames%block==0 {block} else {frames%block};let (checksum,peak,rms,nonzero,subnormal)=safe_statistics(&output[..observed]); let previous=fp_mode(false);let initial_peak=level as f64;set_mxcsr(previous); 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},\"nonzero\":{nonzero},\"subnormal\":{subnormal},\"initial_history_peak\":{initial_peak},\"feedback\":0.999,\"mxcsr\":{active}}}",elapsed as f64/frames as f64,effect.bytes(),std::mem::size_of::()*8); } fn tail_compare(args: &[String]) { let rate:usize=args[3].parse().unwrap();let seconds:usize=args[4].parse().unwrap();let block=rate/8; fp_mode(false);let initial=source(rate,rate);let mut a=Effect::::new(false,rate as f64);let mut b=a.clone(); let mut input=vec![[0.0;2];block];let mut ya=vec![[0.0;2];block];let mut yb=ya.clone(); let mut max_difference=0.0_f64;let mut first_difference=None;let mut maximum_frame=0; for start in (0..rate*seconds).step_by(block) { let count=block.min(rate*seconds-start);input.fill([0.0;2]); if startmax_difference {max_difference=difference;maximum_frame=start+i;} }} } println!("{{\"max_abs_difference\":{max_difference},\"maximum_frame\":{maximum_frame},\"first_difference_frame\":{},\"rate\":{rate},\"seconds\":{seconds}}}",first_difference.map_or("null".to_string(),|x|x.to_string())); } fn main() { let args:Vec=std::env::args().collect();let original=fp_mode(!args[2].contains("-off")); match (args[1].as_str(),args[2].contains("lagrange3")) { ("compare",false)=>tail_compare::<1>(&args),("compare",true)=>tail_compare::<2>(&args), ("audio",false)=>tail_audio::<1>(&args),("audio",true)=>tail_audio::<2>(&args), ("bench",false)=>tail_bench::<1>(&args),("bench",true)=>tail_bench::<2>(&args),_=>panic!("invalid command") } set_mxcsr(original); }