use crate::dsp::{ALIGNMENT_CURVE, apply_filter_curve};
use crate::types::SignalBuffer;
pub fn normalize_levels(reference: &mut SignalBuffer, degraded: &mut SignalBuffer) {
let n_max = reference.nominal_len.max(degraded.nominal_len);
let divisor =
(n_max - 2 * reference.rate.margin_samples() + reference.rate.padding_samples()) as f64;
normalize_one(reference, divisor);
normalize_one(degraded, divisor);
}
pub(crate) fn normalize_one(buffer: &mut SignalBuffer, divisor: f64) {
let mut scratch = buffer.samples.clone();
apply_filter_curve(&mut scratch, &ALIGNMENT_CURVE, buffer.rate);
let interval_start = buffer.rate.margin_samples();
let interval_end = buffer.nominal_len - interval_start + buffer.rate.padding_samples();
let sum_squares: f64 = scratch[interval_start..interval_end]
.iter()
.map(|&sample| f64::from(sample * sample))
.sum();
let mean_power = (sum_squares / divisor) as f32;
let scale = (1e7f64 / f64::from(mean_power)).sqrt() as f32;
for sample in buffer.samples[..buffer.nominal_len].iter_mut() {
*sample *= scale;
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::SAMPLE_RATE_HZ;
fn sine_buffer(amplitude: f32, freq: f32, len: usize) -> SignalBuffer {
let mut pcm = vec![0i16; len];
for (i, sample) in pcm.iter_mut().enumerate() {
let phase = std::f32::consts::TAU * freq * i as f32 / SAMPLE_RATE_HZ as f32;
*sample = (amplitude * phase.sin()).round() as i16;
}
SignalBuffer::from_pcm(&pcm).unwrap()
}
fn filtered_mean_power(buffer: &SignalBuffer, n_max: usize) -> f64 {
let mut scratch = buffer.samples.clone();
apply_filter_curve(&mut scratch, &ALIGNMENT_CURVE, buffer.rate);
let interval_start = buffer.rate.margin_samples();
let interval_end = buffer.nominal_len - interval_start + buffer.rate.padding_samples();
let sum: f64 = scratch[interval_start..interval_end]
.iter()
.map(|&sample| f64::from(sample * sample))
.sum();
let divisor = n_max - 2 * interval_start + buffer.rate.padding_samples();
sum / divisor as f64
}
#[test]
fn normalization_hits_the_1e7_target_power() {
let mut reference = sine_buffer(1500.0, 440.0, 4000);
let mut degraded = sine_buffer(3000.0, 880.0, 5000);
let n_max = reference.nominal_len.max(degraded.nominal_len);
normalize_levels(&mut reference, &mut degraded);
for buffer in [&reference, °raded] {
let power = filtered_mean_power(buffer, n_max);
assert!(
(power - 1e7).abs() / 1e7 < 1e-3,
"calibrated mean power {power} off the 1e7 target"
);
}
}
#[test]
fn normalization_leaves_the_padding_zero() {
let mut reference = sine_buffer(1500.0, 440.0, 4000);
let mut degraded = sine_buffer(3000.0, 880.0, 4000);
normalize_levels(&mut reference, &mut degraded);
for buffer in [&reference, °raded] {
assert!(
buffer.samples[..buffer.rate.margin_samples()]
.iter()
.all(|&s| s == 0.0)
);
assert!(
buffer.samples[buffer.nominal_len..]
.iter()
.all(|&s| s == 0.0)
);
}
}
#[test]
fn normalization_uses_the_shared_nmax_divisor() {
let signal = |len| sine_buffer(1500.0, 440.0, len);
let probe = signal(4000).rate.margin_samples() + 2; let mut reference_a = signal(4000);
let mut degraded_a = signal(4000);
normalize_levels(&mut reference_a, &mut degraded_a);
let scale_a = reference_a.samples[probe];
let mut reference_b = signal(4000);
let mut degraded_b = signal(8000);
normalize_levels(&mut reference_b, &mut degraded_b);
let scale_b = reference_b.samples[probe];
assert!(scale_b > scale_a, "{scale_b} should exceed {scale_a}");
}
}