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