diff options
Diffstat (limited to 'rust/crates/audio/tests/mix.rs')
| -rw-r--r-- | rust/crates/audio/tests/mix.rs | 183 |
1 files changed, 183 insertions, 0 deletions
diff --git a/rust/crates/audio/tests/mix.rs b/rust/crates/audio/tests/mix.rs new file mode 100644 index 00000000..6d0ed0d1 --- /dev/null +++ b/rust/crates/audio/tests/mix.rs @@ -0,0 +1,183 @@ +use std::path::PathBuf; + +use audio::{ + AudibleClip, Error, apply_mastering, extract_rms_buckets, mix_range, render_export_buffer, +}; +use media::Decoder; +use scene::RetimeConfig; +use time::MediaTime; + +const TONE_WAV: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/tone.wav"); + +fn seconds(value: f64) -> MediaTime { + MediaTime::from_seconds_f64(value).expect("finite seconds") +} + +fn tone_clip(id: &str, start: f64, duration: f64) -> AudibleClip { + AudibleClip { + element_id: id.to_string(), + path: PathBuf::from(TONE_WAV), + start_time: seconds(start), + duration: seconds(duration), + trim_start: MediaTime::ZERO, + trim_end: MediaTime::ZERO, + volume_db: 0.0, + retime: None, + animations: None, + } +} + +fn decode_tone(start: f64, end: f64) -> (Vec<f32>, u32, usize) { + let mut decoder = Decoder::open(TONE_WAV).expect("open tone.wav"); + let stream = decoder.info().audio_streams.first().cloned().expect("audio stream"); + let decoded = decoder + .decode_audio_range(stream.index, seconds(start), seconds(end)) + .expect("decode tone"); + (decoded.samples, decoded.sample_rate, decoded.channels as usize) +} + +#[test] +fn two_overlapping_tones_sum() { + let clip_a = tone_clip("a", 0.0, 1.0); + let clip_b = tone_clip("b", 0.0, 1.0); + let single = mix_range(&[clip_a.clone()], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap(); + let doubled = mix_range(&[clip_a, clip_b], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap(); + assert_eq!(single.len(), doubled.len()); + for (one, two) in single.iter().zip(doubled.iter()) { + assert!((two - 2.0 * one).abs() < 1e-6, "{two} != 2 * {one}"); + } +} + +#[test] +fn volume_param_scales_samples() { + let full = tone_clip("full", 0.0, 1.0); + let mut half = tone_clip("half", 0.0, 1.0); + half.volume_db = -6.020599913279624; + let full_mix = mix_range(&[full], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap(); + let half_mix = mix_range(&[half], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap(); + for (f, h) in full_mix.iter().zip(half_mix.iter()) { + assert!((h - f * 0.5).abs() < 1e-3, "{h} != 0.5 * {f}"); + } +} + +#[test] +fn retime_2x_consumes_source_twice_as_fast() { + let normal = tone_clip("normal", 0.0, 1.0); + let mut fast = tone_clip("fast", 0.0, 0.5); + fast.retime = Some(RetimeConfig { + rate: 2.0, + maintain_pitch: None, + }); + let normal_mix = mix_range(&[normal], (seconds(0.0), seconds(1.0)), 44100, 2).unwrap(); + let fast_mix = mix_range(&[fast], (seconds(0.0), seconds(0.5)), 44100, 2).unwrap(); + let frames = fast_mix.len() / 2; + for i in 0..frames { + for channel in 0..2 { + let expected = normal_mix[2 * i * 2 + channel]; + let actual = fast_mix[i * 2 + channel]; + assert!((actual - expected).abs() < 1e-6, "frame {i}: {actual} != {expected}"); + } + } +} + +#[test] +fn trim_start_offsets_source() { + let mut clip = tone_clip("trimmed", 0.0, 0.5); + clip.trim_start = seconds(0.5); + let mix = mix_range(&[clip], (seconds(0.0), seconds(0.5)), 44100, 2).unwrap(); + let (decoded, _rate, channels) = decode_tone(0.5, 1.0); + assert_eq!(channels, 1); + let frames = mix.len() / 2; + for i in 0..frames { + for channel in 0..2 { + let actual = mix[i * 2 + channel]; + assert!((actual - decoded[i]).abs() < 1e-6, "frame {i}: {actual} != {}", decoded[i]); + } + } +} + +#[test] +fn rms_buckets_of_tone_match_hand_computed() { + let (samples, rate, channels) = decode_tone(0.0, 1.0); + let peak = samples.iter().fold(0.0_f32, |p, s| p.max(s.abs())); + let expected_rms = peak / 2.0_f32.sqrt(); + let buckets = extract_rms_buckets(&samples, channels, rate, 10); + assert_eq!(buckets.len(), 10); + for bucket in &buckets { + let relative = (bucket - expected_rms).abs() / expected_rms; + assert!(relative < 0.05, "bucket {bucket} vs expected {expected_rms}"); + } +} + +#[test] +fn mastering_limits_peaks_on_hot_input() { + let frames = 4096; + let mut samples = vec![1.5_f32; frames * 2]; + apply_mastering(&mut samples, 2, 44100); + let peak = samples.iter().fold(0.0_f32, |p, s| p.max(s.abs())); + assert!(peak <= 0.98, "peak was {peak}"); + assert!(peak > 0.9, "limiter over-attenuated: peak {peak}"); +} + +#[test] +fn mastering_leaves_quiet_input_untouched() { + let mut samples: Vec<f32> = (0..1000).map(|i| (i as f32 / 1000.0) * 0.5).collect(); + let original = samples.clone(); + apply_mastering(&mut samples, 1, 44100); + assert_eq!(samples, original); +} + +#[test] +fn maintain_pitch_true_returns_typed_error() { + let mut clip = tone_clip("pitched", 0.0, 0.5); + clip.retime = Some(RetimeConfig { + rate: 2.0, + maintain_pitch: Some(true), + }); + let result = mix_range(&[clip], (seconds(0.0), seconds(1.0)), 44100, 2); + match result { + Err(Error::MaintainPitchUnsupported { element_id, rate }) => { + assert_eq!(element_id, "pitched"); + assert_eq!(rate, 2.0); + } + other => panic!("expected MaintainPitchUnsupported, got {other:?}"), + } +} + +#[test] +fn maintain_pitch_at_unity_rate_is_allowed() { + let mut clip = tone_clip("unity", 0.0, 0.5); + clip.retime = Some(RetimeConfig { + rate: 1.0, + maintain_pitch: Some(true), + }); + assert!(mix_range(&[clip], (seconds(0.0), seconds(0.5)), 44100, 2).is_ok()); +} + +#[test] +fn render_export_buffer_mixes_and_masters() { + let clip = tone_clip("a", 0.0, 1.0); + let buffer = render_export_buffer(&[clip], seconds(1.0), 44100, 2).unwrap(); + assert_eq!(buffer.len(), 44100 * 2); + let peak = buffer.iter().fold(0.0_f32, |p, s| p.max(s.abs())); + assert!(peak > 0.05, "peak was {peak}"); + assert!(render_export_buffer(&[], seconds(1.0), 44100, 2).unwrap().is_empty()); +} + +#[test] +fn range_render_only_covers_requested_window() { + let clip = tone_clip("a", 1.0, 1.0); + let buffer = mix_range(&[clip], (seconds(0.0), seconds(2.0)), 44100, 2).unwrap(); + let first_half = &buffer[..44100 * 2]; + assert!(first_half.iter().all(|s| *s == 0.0)); + let second_peak = buffer[44100 * 2..].iter().fold(0.0_f32, |p, s| p.max(s.abs())); + assert!(second_peak > 0.05); +} + +#[test] +fn undecodable_clip_contributes_silence() { + let mut clip = tone_clip("missing", 0.0, 1.0); + clip.path = PathBuf::from("/nonexistent/nope.wav"); + let buffer = mix_range(&[clip], (seconds(0.0), seconds(0.5)), 44100, 2).unwrap(); + assert!(buffer.iter().all(|s| *s == 0.0)); +} |