// Copyright (C) 2026 Yusuke Oda // SPDX-License-Identifier: AGPL-3.0-only mod compressor_f64; mod compressor_f32; mod limiter_f64; mod limiter_f32; mod limiter_mixed; use std::{hint::black_box, io::{Read,Write}, time::Instant}; fn input_signal(rate:usize,frames:usize)->Vec<[f64;2]>{ let mut random=0xd1a6_1c5e_2026_1105_u64; (0..frames).map(|n|{ let t=n as f64/rate as f64;let p=std::f64::consts::TAU; random=random.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407); let noise=(random>>11)as f64/(1_u64<<53)as f64*2.0-1.0; let envelope=0.5+0.4*(p*0.6*t).sin();let hit=(t*2.0).fract()*0.5; let transient=1.5*(-hit*65.0).exp()*noise; let left=envelope*((p*220.0*t).sin()+0.45*(p*277.182631*t).sin()+0.3*(p*329.627557*t).sin())+transient; let right=envelope*((p*220.5*t).sin()+0.45*(p*277.682631*t).sin()+0.3*(p*330.127557*t).sin())+0.7*transient; // Identical real input values in both numerical-type experiments. [(left as f32)as f64,(right as f32)as f64] }).collect() } macro_rules! implementation { ($module:ident,$float:ty,$comp:ident,$limit:ident,$label:expr)=>{ mod $module { use super::*;use crate::$comp as c;use crate::$limit as l; #[derive(Clone,Debug)] pub(super) enum Processor{Bypass,Compressor(c::Compressor),Limiter(l::Limiter)} impl Processor{ pub(super) fn new(method:&str,rate:usize)->Self{match method{ "bypass"=>Self::Bypass, "decoupled"=>Self::Compressor(c::Compressor::new(c::CompressorMethod::PeakLogDecoupled,c::StereoLink::Maximum,rate as $float,10.0)), "rmsafter"=>Self::Compressor(c::Compressor::new(c::CompressorMethod::RmsIir,c::StereoLink::MaximumAfterDetector,rate as $float,10.0)), "box"=>Self::Limiter(l::Limiter::new(l::LimiterMethod::MaxBox,l::StereoLink::Maximum,rate as $float,5.0)), "invbox"=>Self::Limiter(l::Limiter::new(l::LimiterMethod::InverseBox,l::StereoLink::Maximum,rate as $float,5.0)), _=>panic!("invalid method")}} fn reset(&mut self){match self{Self::Bypass=>{},Self::Compressor(p)=>p.reset(),Self::Limiter(p)=>p.reset()}} pub(super) fn process_samples(&mut self,x:&[[$float;2]],y:&mut[[$float;2]]){match self{Self::Bypass=>y.copy_from_slice(x),Self::Compressor(p)=>p.process_samples(x,y),Self::Limiter(p)=>p.process_samples(x,y)}} pub(super) fn set_parameters(&mut self,p:[f64;8]){match self{ Self::Bypass=>{},Self::Compressor(q)=>q.set_parameters(c::CompressorParameters{threshold_db:p[0]as $float,ratio:p[1]as $float,knee_db:p[2]as $float,attack_ms:p[3]as $float,release_ms:p[4]as $float,makeup_db:p[7]as $float}), Self::Limiter(q)=>q.set_parameters(l::LimiterParameters{ceiling_db:p[5]as $float,input_gain_db:p[6]as $float,release_ms:p[4]as $float})}} pub(super) fn gains(&self)->[$float;2]{match self{Self::Bypass=>[1.0;2],Self::Compressor(p)=>p.gains(),Self::Limiter(p)=>p.gains()}} fn controls_json(&self)->String{match self{ Self::Bypass=>"null".to_string(), Self::Compressor(p)=>{let v=p.effective_parameters();format!("{{\"threshold_db\":{},\"ratio\":{},\"knee_db\":{},\"attack_ms\":{},\"release_ms\":{},\"makeup_db\":{},\"attack_coefficient\":{},\"release_coefficient\":{},\"rms_coefficient\":{}}}",v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8])}, Self::Limiter(p)=>{let v=p.effective_parameters();format!("{{\"ceiling_linear\":{},\"input_gain_linear\":{},\"release_coefficient\":{}}}",v[0],v[1],v[2])}}} fn state_bytes(&self)->usize{match self{Self::Bypass=>0,Self::Compressor(p)=>p.state_bytes(),Self::Limiter(p)=>p.state_bytes()}} fn latency_samples(&self)->usize{match self{Self::Bypass=>0,Self::Compressor(p)=>p.latency_samples(),Self::Limiter(p)=>p.latency_samples()}} } fn process_blocks(p:&mut Processor,x:&[[$float;2]],y:&mut[[$float;2]],buffer:usize,reuse:bool){ if reuse{for chunk in x.chunks(buffer){p.process_samples(black_box(chunk),black_box(&mut y[..chunk.len()]));black_box(&y[..chunk.len()]);}} else{for(chunk,out)in x.chunks(buffer).zip(y.chunks_mut(buffer)){p.process_samples(black_box(chunk),black_box(out));black_box(out);}} } pub fn bench(args:&[String]){ assert_eq!(args.len(),5);let case=&args[0];let parts:Vec<_>=case.split('.').collect();let reuse=parts[1]=="reuse";let rate:usize=args[1].parse().unwrap();let buffer:usize=args[2].parse().unwrap();let seconds:f64=args[3].parse().unwrap();let burn_ms:f64=args[4].parse().unwrap();assert!(buffer>0&&rate>=44100&&seconds>0.0&&burn_ms>=10.0); let frames=(rate as f64*seconds).round()as usize;let prepare=rate*2;let input:Vec<[$float;2]>=input_signal(rate,prepare+frames).into_iter().map(|x|[x[0]as $float,x[1]as $float]).collect();let mut output=vec![[0.0;2];if reuse{buffer}else{input.len()}];let mut p=Processor::new(parts[2],rate); let burn=Instant::now();let mut cycles=0;loop{p.reset();process_blocks(&mut p,&input,&mut output,buffer,reuse);black_box(&output);cycles+=1;if burn.elapsed().as_secs_f64()*1000.0>=burn_ms{break;}} let burn_ns=burn.elapsed().as_nanos();p.reset();process_blocks(&mut p,&input[..prepare],if reuse{&mut output}else{&mut output[..prepare]},buffer,reuse); let start=Instant::now();process_blocks(&mut p,&input[prepare..],if reuse{&mut output}else{&mut output[prepare..]},buffer,reuse);black_box(&output);let elapsed=start.elapsed().as_nanos(); let last=if frames%buffer==0{buffer}else{frames%buffer};let observed=if reuse{&output[..last]}else{&output[prepare..]};let(mut hash,mut peak,mut square)=(0xcbf29ce484222325_u64,0.0_f64,0.0_f64); for v in observed.iter().flatten(){hash=(hash^v.to_bits()as u64).wrapping_mul(0x100000001b3);peak=peak.max((*v as f64).abs());square+=(*v as f64)*(*v as f64);} println!("{{\"case_id\":\"{case}\",\"frames\":{frames},\"channels\":2,\"elapsed_ns\":{elapsed},\"ns_per_frame\":{},\"burn_in_ns\":{burn_ns},\"burn_in_cycles\":{cycles},\"checksum\":\"{hash:016x}\",\"peak\":{peak},\"rms\":{},\"state_bytes\":{},\"latency_samples\":{},\"observed_frames\":{},\"output_buffer_frames\":{},\"scalar_bytes\":{},\"effective_controls\":{}}}",elapsed as f64/frames as f64,(square/(observed.len()*2)as f64).sqrt(),p.state_bytes(),p.latency_samples(),observed.len(),output.len(),size_of::<$float>(),p.controls_json()); } pub fn check()->Vec{ let mut rows=Vec::new(); for rate in [44100,48000,96000]{let input:Vec<[$float;2]>=input_signal(rate,rate*6+7).into_iter().map(|x|[x[0]as $float,x[1]as $float]).collect(); for method in ["bypass","decoupled","rmsafter","box","invbox"]{ let mut reference=Processor::new(method,rate);let mut expected=vec![[0.0;2];input.len()];reference.process_samples(&input,&mut expected);let state=format!("{reference:?}"); for buffer in [32,256]{let mut p=Processor::new(method,rate);let mut work=vec![[0.0;2];buffer];let mut seen=Vec::with_capacity(input.len());for x in input.chunks(buffer){p.process_samples(x,&mut work[..x.len()]);seen.extend_from_slice(&work[..x.len()]);} assert!(seen.iter().flatten().zip(expected.iter().flatten()).all(|(a,b)|a.to_bits()==b.to_bits()));assert_eq!(format!("{p:?}"),state);rows.push(format!("{{\"precision\":\"{}\",\"method\":\"{method}\",\"rate\":{rate},\"buffer\":{buffer},\"frames\":{},\"audio_bits_equal\":true,\"final_state_equal\":true}}",$label,input.len())); } } }rows } pub fn render(args:&[String]){ assert!(args.len()==6||args.len()==7);let method=&args[0];let rate:usize=args[1].parse().unwrap();let mut bytes=Vec::new();std::fs::File::open(&args[2]).unwrap().read_to_end(&mut bytes).unwrap();assert_eq!(bytes.len()%16,0);let input:Vec<[$float;2]>=bytes.chunks_exact(16).map(|b|[(f64::from_le_bytes(b[..8].try_into().unwrap())as f32)as $float,(f64::from_le_bytes(b[8..].try_into().unwrap())as f32)as $float]).collect();let mut p=Processor::new(method,rate);let mut out=std::io::BufWriter::new(std::fs::File::create(&args[3]).unwrap());let mut gain=std::io::BufWriter::new(std::fs::File::create(&args[4]).unwrap()); let params:Vec=args[5].split(',').map(|s|s.parse().unwrap()).collect();p.set_parameters(params.try_into().unwrap());let mut events:Vec<(usize,[f64;8])>=Vec::new();if args.len()==7{for line in std::fs::read_to_string(&args[6]).unwrap().lines(){let v:Vec=line.split(',').map(|s|s.parse().unwrap()).collect();events.push((v[0]as usize,v[1..].try_into().unwrap()));}}let mut at=0; for(n,x)in input.iter().enumerate(){while at()); } } }} implementation!(wide,f64,compressor_f64,limiter_f64,"f64"); implementation!(narrow,f32,compressor_f32,limiter_f32,"f32"); implementation!(mixed,f32,compressor_f32,limiter_mixed,"f32-sum64"); fn long_check(){ let rate=48000_usize;let seconds=600_usize;let frames=rate*seconds;let mut results=Vec::new(); for method in ["box","invbox"]{for policy in ["f32","f32-sum64"]{ let(mut a,mut b,mut c)=(wide::Processor::new(method,rate),narrow::Processor::new(method,rate),mixed::Processor::new(method,rate)); let(mut x64,mut x32,mut y64,mut y32)=(vec![[0.0_f64;2];256],vec![[0.0_f32;2];256],vec![[0.0_f64;2];256],vec![[0.0_f32;2];256]); let ceiling=10_f64.powf(-1.0/20.0);let(mut max_error,mut sum_error,mut peak64,mut peak32)=(0.0_f64,0.0_f64,0.0_f64,0.0_f64);let mut worst=0;let mut peak_frame=0;let mut windows=Vec::new();let(mut window_error,mut window_peak)=(0.0_f64,0.0_f64);let mut random=0xd1a6_1c5e_2026_1105_u64; let mut history=std::collections::VecDeque::<[f64;6]>::with_capacity(513);let mut before=Vec::new();let mut after=Vec::new(); for start in(0..frames).step_by(256){let count=(frames-start).min(256); for n in 0..count{let t=(start+n)as f64/rate as f64;random=random.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);let noise=(random>>11)as f64/(1_u64<<53)as f64*2.0-1.0;let amp=if(t as usize)%2==0{4.0}else{0.1};let p=std::f64::consts::TAU;x32[n]=[(amp*((p*73.17*t).sin()+0.2*noise))as f32,(amp*((p*83.39*t).sin()+0.3*noise))as f32];x64[n]=[x32[n][0]as f64,x32[n][1]as f64];} a.process_samples(&x64[..count],&mut y64[..count]);if policy=="f32"{b.process_samples(&x32[..count],&mut y32[..count]);}else{c.process_samples(&x32[..count],&mut y32[..count]);} for n in 0..count{let sample=[x64[n][0],x64[n][1],y64[n][0],y64[n][1],y32[n][0]as f64,y32[n][1]as f64];if history.len()==513{history.pop_front();}history.push_back(sample);let mut new_worst=false; for ch in 0..2{assert!(y64[n][ch].is_finite()&&y32[n][ch].is_finite());let error=(y64[n][ch]-y32[n][ch]as f64).abs();sum_error+=error*error;if error>max_error{max_error=error;worst=start+n;new_worst=true;}peak64=peak64.max(y64[n][ch].abs());if(y32[n][ch]as f64).abs()>peak32{peak32=(y32[n][ch]as f64).abs();peak_frame=start+n;}window_error=window_error.max(error);window_peak=window_peak.max((y32[n][ch]as f64).abs());} if new_worst{before=history.iter().copied().collect();after.clear();}else if after.len()<512{after.push(sample);} if(start+n+1)%rate==0{windows.push(format!("{{\"second\":{},\"maximum_absolute_error\":{window_error},\"peak_f32\":{window_peak}}}",(start+n+1)/rate));window_error=0.0;window_peak=0.0;} } } let window_start=worst.saturating_sub(before.len()-1);before.extend(after); results.push(format!("{{\"method\":\"{method}\",\"policy\":\"{policy}\",\"rate\":{rate},\"frames\":{frames},\"seconds\":{seconds},\"maximum_absolute_error\":{max_error},\"rms_error\":{},\"worst_frame\":{worst},\"peak_frame\":{peak_frame},\"sample_ceiling\":{ceiling},\"peak_f64\":{peak64},\"peak_f32\":{peak32},\"relative_ceiling_excess_f64\":{},\"relative_ceiling_excess_f32\":{},\"one_second_windows\":[{}],\"worst_window_start_frame\":{window_start},\"worst_window_columns\":[\"input_L\",\"input_R\",\"reference_L\",\"reference_R\",\"candidate_L\",\"candidate_R\"],\"worst_window\":{:?}}}",(sum_error/(frames*2)as f64).sqrt(),peak64/ceiling-1.0,peak32/ceiling-1.0,windows.join(","),before)); }}println!("{{\"cases\":[{}]}}",results.join(",")); } fn main(){let args:Vec=std::env::args().skip(1).collect();match args[0].as_str(){ "bench"=>if args[1].starts_with("f64."){wide::bench(&args[1..])}else if args[1].starts_with("mixed."){mixed::bench(&args[1..])}else{narrow::bench(&args[1..])}, "long-check"=>long_check(), "check"=>{let mut rows=wide::check();rows.extend(narrow::check());rows.extend(mixed::check());println!("{{\"cases\":[{}]}}",rows.join(","));}, "render"=>if args[1]=="f64"{wide::render(&args[2..])}else if args[1]=="mixed"{mixed::render(&args[2..])}else{narrow::render(&args[2..])}, _=>panic!("invalid command")}}