use super::table::{BARK_BANDS, LOUDNESS_SCALE, PITCH_POWER_SCALE};
use super::*;
use crate::types::{RATE_8K, Utterance};
fn utterance(start_window: usize, fine_delay: i32) -> Utterance {
Utterance {
start_window,
end_window: 0,
coarse_delay: fine_delay,
fine_delay,
confidence: 1.0,
split_frame: None,
}
}
fn tone_pcm(amplitude: f32) -> Vec<i16> {
(0..8000)
.map(|n| (amplitude * (std::f32::consts::TAU * 440.0 * n as f32 / 8000.0).sin()) as i16)
.collect()
}
#[test]
fn bark_table_covers_all_128_bins_and_42_bands() {
assert_eq!(BARK_BANDS.len(), NUM_BANDS);
let total: usize = BARK_BANDS.iter().map(|row| row.bins).sum();
assert_eq!(total, 128, "group counts must sum to 128 (spec 03, 3.3)");
assert!(
BARK_BANDS
.windows(2)
.all(|w| w[0].bark_centre < w[1].bark_centre)
);
assert!(BARK_BANDS.iter().all(|row| row.threshold > 0.0));
}
#[test]
fn bark_warping_of_a_flat_spectrum_scales_by_group_and_factor() {
let power = [10_000.0f64; NUM_POWER_BINS];
let density = warp_to_bark(&power, RATE_8K);
for (band, row) in BARK_BANDS.iter().enumerate() {
let expected = 10_000.0 * row.bins as f64 * f64::from(row.correction) * PITCH_POWER_SCALE;
assert!(
(f64::from(density[band]) - expected).abs() <= expected * 1e-6,
"band {band}"
);
}
}
#[test]
fn bark_warping_groups_from_bin_0() {
let mut power = [0.0f64; NUM_POWER_BINS];
power[0] = 1000.0;
let density = warp_to_bark(&power, RATE_8K);
let expected = 1000.0 * f64::from(BARK_BANDS[0].correction) * PITCH_POWER_SCALE;
assert!((f64::from(density[0]) - expected).abs() <= expected * 1e-6);
assert!(density[1..].iter().all(|&d| d == 0.0));
}
#[test]
fn loudness_follows_the_zwicker_power_law() {
let band = 12;
assert!(BARK_BANDS[band].bark_centre >= 4.0);
let threshold = f64::from(BARK_BANDS[band].threshold);
for p in [3.0f32, 10.0, 1e3, 1e6] {
assert!(f64::from(p) > threshold, "p = {p} must stay above t[b]");
let expected = LOUDNESS_SCALE
* (threshold / 0.5).powf(0.23)
* ((0.5 + 0.5 * f64::from(p) / threshold).powf(0.23) - 1.0);
let loudness = f64::from(zwicker_loudness(p, band, RATE_8K));
assert!(
(loudness - expected).abs() <= expected.abs() * 1e-6,
"p = {p}"
);
}
assert_eq!(
zwicker_loudness(BARK_BANDS[band].threshold, band, RATE_8K),
0.0
);
assert_eq!(
zwicker_loudness(0.5 * BARK_BANDS[band].threshold, band, RATE_8K),
0.0
);
assert!(zwicker_loudness(2.0, band, RATE_8K) > zwicker_loudness(1.0, band, RATE_8K));
}
#[test]
fn loudness_applies_the_low_bark_correction_below_4_bark() {
let band = 4;
let bark = f64::from(BARK_BANDS[band].bark_centre);
assert!(bark < 4.0);
let threshold = f64::from(BARK_BANDS[band].threshold);
let p = 1e10f32;
let h = (6.0 / (bark + 2.0)).powf(0.15);
let expected = LOUDNESS_SCALE
* (threshold / 0.5).powf(0.23 * h)
* ((0.5 + 0.5 * f64::from(p) / threshold).powf(0.23 * h) - 1.0);
assert!((f64::from(zwicker_loudness(p, band, RATE_8K)) - expected).abs() <= expected * 1e-6);
let band = 0;
let threshold = f64::from(BARK_BANDS[band].threshold);
let h = 2.0f64.powf(0.15);
let expected = LOUDNESS_SCALE
* (threshold / 0.5).powf(0.23 * h)
* ((0.5 + 0.5 * f64::from(p) / threshold).powf(0.23 * h) - 1.0);
assert!((f64::from(zwicker_loudness(p, band, RATE_8K)) - expected).abs() <= expected * 1e-6);
}
#[test]
fn audible_power_applies_the_threshold_and_excludes_band_0() {
let mut density = [0.0f32; NUM_BANDS];
density[0] = 1e30; let factor = 100.0;
let mut expected = 0.0f64;
for band in 1..NUM_BANDS {
density[band] = if band % 2 == 0 {
(factor * f64::from(BARK_BANDS[band].threshold) * 0.5) as f32 } else {
(factor * f64::from(BARK_BANDS[band].threshold) * 2.0) as f32 };
if band % 2 == 1 {
expected += f64::from(density[band]);
}
}
assert!((audible_power(&density, factor, RATE_8K) - expected).abs() <= expected * 1e-6);
}
#[test]
fn silence_flag_uses_factor_100_and_power_1e7() {
let band = 20;
let mut density = [0.0f32; NUM_BANDS];
density[band] = (100.0 * f64::from(BARK_BANDS[band].threshold)) as f32;
assert!(audible_power(&density, SILENCE_FLAG_FACTOR, RATE_8K) < SILENCE_FLAG_POWER);
density[band] = (100.0 * f64::from(BARK_BANDS[band].threshold) + SILENCE_FLAG_POWER) as f32;
assert!(audible_power(&density, SILENCE_FLAG_FACTOR, RATE_8K) > SILENCE_FLAG_POWER);
}
#[test]
fn local_scale_clamps_to_the_spec_bounds() {
let (_, high) = local_scale(1e9, 0.0, 1.0, 0);
assert_eq!(high, SCALE_MAX);
let (_, low) = local_scale(0.0, 1e9, 1.0, 0);
assert_eq!(low, SCALE_MIN);
let (unclamped, clamped) = local_scale(10_000.0, 10_000.0, 1.0, 0);
assert!((unclamped - 1.0).abs() < 1e-9);
assert_eq!(clamped, unclamped);
}
#[test]
fn local_scale_smooths_and_stores_the_unclamped_value() {
let (unclamped, clamped) = local_scale(0.0, 1e9, 100.0, 7);
let raw = SCALE_OFFSET / (1e9 + SCALE_OFFSET);
assert!((unclamped - (0.2 * 100.0 + 0.8 * raw)).abs() < 1e-12);
assert!(unclamped > SCALE_MAX, "the unclamped value exceeds the cap");
assert_eq!(clamped, SCALE_MAX);
}
#[test]
fn compensation_factors_are_reciprocal_when_roles_swap() {
for (avg_ref, avg_deg) in [(1.0, 4.0), (123.0, 7.0), (0.0, 0.0), (1e6, 1.0)] {
let forward = compensation_factor(avg_ref, avg_deg);
let inverse = compensation_factor(avg_deg, avg_ref);
assert!(
(forward * inverse - 1.0).abs() < 1e-12,
"ref {avg_ref}, deg {avg_deg}"
);
}
assert_eq!(compensation_factor(42.0, 42.0), 1.0);
assert_eq!(compensation_factor(0.0, 1e9), COMPENSATION_MAX);
assert_eq!(compensation_factor(1e9, 0.0), COMPENSATION_MIN);
}
#[test]
fn governing_delay_uses_the_last_utterance_before_the_frame() {
let utterances = [
utterance(0, 100),
utterance(80, 300), utterance(200, -50), ];
assert_eq!(governing_delay(2400, &utterances, RATE_8K), 100);
assert_eq!(governing_delay(2600, &utterances, RATE_8K), 300);
assert_eq!(governing_delay(7000, &utterances, RATE_8K), -50);
assert_eq!(governing_delay(2400, &[], RATE_8K), 0);
}
#[test]
fn frame_range_skips_the_silent_margins() {
let signal = SignalBuffer::from_pcm(&tone_pcm(1000.0)).unwrap();
let range = frame_range(&signal, signal.nominal_len);
assert_eq!(range.skip_start, 0);
assert_eq!(range.skip_end, 2557);
assert_eq!(range.start, 0);
assert_eq!(range.stop, 61);
}
#[test]
fn frame_range_of_a_silent_signal_reaches_the_skip_caps() {
let signal = SignalBuffer::from_pcm(&vec![0i16; 8000]).unwrap();
let range = frame_range(&signal, signal.nominal_len);
assert_eq!(range.skip_start, signal.nominal_len / 2);
assert_eq!(range.skip_end, signal.nominal_len / 2);
let model = run_frame_loop(&signal, &signal, &[]);
assert!(model.frame_range.stop < model.frame_range.start);
assert!(model.pitch_ref.iter().all(|&p| p == 0.0));
assert!(model.silence_flags.iter().all(|&silent| silent));
}
#[test]
fn identical_signals_pass_compensation_and_scaling_unchanged() {
let signal = SignalBuffer::from_pcm(&tone_pcm(3000.0)).unwrap();
let model = run_frame_loop(&signal, &signal, &[utterance(0, 0)]);
assert!(!model.silence_flags.iter().any(|&silent| silent));
assert_eq!(model.pitch_ref, model.pitch_deg);
assert_eq!(model.loudness_ref, model.loudness_deg);
let first = model.frame_range.start;
assert!(model.audible_ref[first] > 1e7);
assert!(model.loudness_ref_at(first, 13) > 0.0);
assert_eq!(model.frame_count(), model.frame_range.stop + 1);
}
#[test]
fn out_of_range_degraded_frames_get_zero_spectra() {
let signal = SignalBuffer::from_pcm(&tone_pcm(3000.0)).unwrap();
let model = run_frame_loop(&signal, &signal, &[utterance(0, 20_000)]);
for frame in model.frame_range.start..=model.frame_range.stop {
for band in 0..NUM_BANDS {
assert_eq!(model.pitch_deg_at(frame, band), 0.0);
assert_eq!(model.loudness_deg_at(frame, band), 0.0);
}
}
assert!(model.pitch_ref.iter().any(|&p| p > 0.0));
}