// Copyright (C) 2026 Yusuke Oda // SPDX-License-Identifier: AGPL-3.0-only mod dynamics; use dynamics::{ Compressor, CompressorMethod, CompressorParameters, Limiter, LimiterMethod, LimiterParameters, StereoLink, }; use std::{ hint::black_box, io::{Read, Write}, time::Instant, }; fn calibrated_threshold(method: &str) -> f64 { match method { "peaklog" => -15.328613463789225, "peaklinear" => -15.160024959594011, "rmsiir" => -16.988765481859446, "rmswindow" => -17.010299954563379, "gainlinear" => -15.630353841930628, "decoupled" => -14.009402643889189, _ => panic!("uncalibrated method"), } } #[derive(Clone)] enum Processor { Bypass, Compressor(Compressor), Limiter(Limiter), } impl Processor { fn new(case: &str, rate: f64) -> Self { let part: Vec<_> = case.split('.').collect(); if part[0] == "bypass" { return Self::Bypass; } let link = match part[2] { "max" => StereoLink::Maximum, "after" => StereoLink::MaximumAfterDetector, "energy" => StereoLink::EnergyAverage, "independent" => StereoLink::Independent, _ => panic!("invalid link"), }; let mut out = match part[0] { "comp" => Self::Compressor(Compressor::new( match part[1] { "peaklog" => CompressorMethod::PeakLog, "peaklinear" => CompressorMethod::PeakLinear, "rmsiir" => CompressorMethod::RmsIir, "rmswindow" => CompressorMethod::RmsWindow, "gainlinear" => CompressorMethod::PeakLinearGain, "decoupled" => CompressorMethod::PeakLogDecoupled, _ => panic!("invalid compressor"), }, link, rate, 10.0, )), "limit" => Self::Limiter(Limiter::new( match part[1] { "instant" => LimiterMethod::Instant, "box" => LimiterMethod::MaxBox, "triangle" => LimiterMethod::MaxTriangle, "compensated" => LimiterMethod::MaxCompensated, _ => panic!("invalid limiter"), }, link, rate, part[3].parse().unwrap(), )), _ => panic!("invalid processor"), }; if part.get(3) == Some(&"matched") { if let Self::Compressor(ref mut processor) = out { processor.set_parameters(CompressorParameters { threshold_db: calibrated_threshold(part[1]), ..Default::default() }); } } out } fn reset(&mut self) { match self { Self::Bypass => {} Self::Compressor(p) => p.reset(), Self::Limiter(p) => p.reset(), } } fn process_samples(&mut self, input: &[[f64; 2]], output: &mut [[f64; 2]]) { match self { Self::Bypass => output.copy_from_slice(input), Self::Compressor(p) => p.process_samples(input, output), Self::Limiter(p) => p.process_samples(input, output), } } fn process_sample(&mut self, input: [f64; 2]) -> [f64; 2] { match self { Self::Bypass => input, Self::Compressor(p) => p.process_sample(input), Self::Limiter(p) => p.process_sample(input), } } fn gains(&self) -> [f64; 2] { match self { Self::Bypass => [1.0; 2], Self::Compressor(p) => p.gains(), Self::Limiter(p) => p.gains(), } } 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 set_parameters(&mut self, comp: CompressorParameters, lim: LimiterParameters) { match self { Self::Bypass => {} Self::Compressor(p) => p.set_parameters(comp), Self::Limiter(p) => p.set_parameters(lim), } } } fn signal(name: &str, rate: f64, length: usize) -> Vec<[f64; 2]> { let mut random = 0xd1a6_1c5e_2026_1105_u64; (0..length) .map(|n| { let t = n as f64 / rate; 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; match name { "bass" => { let pulse = (t * 2.0).fract(); let env = (-pulse * 5.0).exp(); let value = env * ((p * 55.0 * t).sin() + 0.4 * (p * 110.0 * t).sin() + 0.2 * (p * 165.0 * t).sin()); [value, value * 0.9] } "pad" => { let env = 0.5 + 0.4 * (p * 0.6 * t).sin(); let left = env * ((p * 220.0 * t).sin() + 0.45 * (p * 277.182631 * t).sin() + 0.3 * (p * 329.627557 * t).sin()); let right = env * ((p * 220.5 * t).sin() + 0.45 * (p * 277.682631 * t).sin() + 0.3 * (p * 330.127557 * t).sin()); [left, right] } "drums" => { let kick_time = (t * 2.0).fract() * 0.5; let snare_time = ((t + 0.25) * 2.0).fract() * 0.5; let kick = 2.2 * (-kick_time * 35.0).exp() * (p * (45.0 * kick_time + 2.0 * (1.0 - (-20.0 * kick_time).exp()))).sin(); let snare = 1.5 * (-snare_time * 65.0).exp() * noise; [kick + snare, kick + 0.7 * snare] } "silence" => [0.0; 2], _ => panic!("invalid signal"), } }) .collect() } fn process_blocks( processor: &mut Processor, input: &[[f64; 2]], output: &mut [[f64; 2]], buffer: usize, ) { for (x, y) in input.chunks(buffer).zip(output.chunks_mut(buffer)) { processor.process_samples(black_box(x), black_box(y)); } } fn bench(args: &[String]) { assert_eq!(args.len(), 5); let case = &args[0]; 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 = signal( case.rsplit('.').next().unwrap(), rate as f64, prepare + frames, ); let mut output = vec![[0.0; 2]; input.len()]; let mut processor = Processor::new(case, rate as f64); let burn_start = Instant::now(); let mut cycles = 0; loop { processor.reset(); process_blocks(&mut processor, &input, &mut output, buffer); black_box(&output); cycles += 1; if burn_start.elapsed().as_secs_f64() * 1000.0 >= burn_ms { break; } } let burn_ns = burn_start.elapsed().as_nanos(); processor.reset(); process_blocks( &mut processor, &input[..prepare], &mut output[..prepare], buffer, ); let start = Instant::now(); process_blocks( &mut processor, &input[prepare..], &mut output[prepare..], buffer, ); black_box(&output); let elapsed = start.elapsed().as_nanos(); let mut checksum = 0xcbf29ce484222325_u64; let mut peak = 0.0_f64; let mut square = 0.0; for x in output[prepare..].iter().flatten() { checksum = (checksum ^ x.to_bits()).wrapping_mul(0x100000001b3); peak = peak.max(x.abs()); square += x * x; } println!( "{{\"case_id\":\"{case}\",\"frames\":{frames},\"channels\":2,\"elapsed_ns\":{elapsed},\"ns_per_frame\":{},\"burn_in_ns\":{burn_ns},\"burn_in_cycles\":{cycles},\"checksum\":\"{checksum:016x}\",\"peak\":{peak},\"rms\":{},\"state_bytes\":{},\"latency_samples\":{}}}", elapsed as f64 / frames as f64, (square / (frames * 2) as f64).sqrt(), processor.state_bytes(), processor.latency_samples() ); } fn read_stereo(path: &str) -> Vec<[f64; 2]> { let mut bytes = Vec::new(); std::fs::File::open(path) .unwrap() .read_to_end(&mut bytes) .unwrap(); assert_eq!(bytes.len() % 16, 0); bytes .chunks_exact(16) .map(|b| { [ f64::from_le_bytes(b[..8].try_into().unwrap()), f64::from_le_bytes(b[8..].try_into().unwrap()), ] }) .collect() } fn write_stereo(path: &str, data: &[[f64; 2]]) { let mut f = std::io::BufWriter::new(std::fs::File::create(path).unwrap()); for frame in data { for value in frame { f.write_all(&value.to_le_bytes()).unwrap(); } } } fn apply_settings(processor: &mut Processor, n: &[f64]) { assert_eq!(n.len(), 8); processor.set_parameters( CompressorParameters { threshold_db: n[0], ratio: n[1], knee_db: n[2], attack_ms: n[3], release_ms: n[4], makeup_db: n[7], }, LimiterParameters { ceiling_db: n[5], input_gain_db: n[6], release_ms: n[4], }, ); } fn render(args: &[String]) { assert!( args.len() == 5 || args.len() == 13 || args.len() == 14, "render case rate input output gains [threshold ratio knee attack release ceiling drive makeup [events.csv]]" ); let case = &args[0]; let rate = args[1].parse().unwrap(); let input = read_stereo(&args[2]); let mut processor = Processor::new(case, rate); if args.len() >= 13 { let n: Vec = args[5..13].iter().map(|s| s.parse().unwrap()).collect(); apply_settings(&mut processor, &n); processor.reset(); } let events: Vec<(usize, Vec)> = if args.len() == 14 { std::fs::read_to_string(&args[13]) .unwrap() .lines() .filter(|line| !line.is_empty() && !line.starts_with('#')) .map(|line| { let values: Vec<_> = line.split(',').collect(); ( values[0].parse().unwrap(), values[1..].iter().map(|v| v.parse().unwrap()).collect(), ) }) .collect() } else { vec![] }; assert!(events.windows(2).all(|pair| pair[0].0 <= pair[1].0)); let mut event = 0; let mut output = Vec::with_capacity(input.len()); let mut gains = Vec::with_capacity(input.len()); for (n, x) in input.into_iter().enumerate() { while event < events.len() && events[event].0 == n { apply_settings(&mut processor, &events[event].1); event += 1; } output.push(processor.process_sample(x)); gains.push(processor.gains()); } write_stereo(&args[3], &output); write_stereo(&args[4], &gains); println!( "{{\"state_bytes\":{},\"latency_samples\":{}}}", processor.state_bytes(), processor.latency_samples() ); } fn main() { let args: Vec = std::env::args().skip(1).collect(); match args.first().map(String::as_str) { Some("bench") => bench(&args[1..]), Some("render") => render(&args[1..]), _ => panic!("commands: bench, render"), } }