diff options
Diffstat (limited to 'rust/crates/audio/tests')
| -rw-r--r-- | rust/crates/audio/tests/collection.rs | 263 | ||||
| -rw-r--r-- | rust/crates/audio/tests/fixtures/sample.mp4 | bin | 0 -> 81284 bytes | |||
| -rw-r--r-- | rust/crates/audio/tests/fixtures/tone.wav | bin | 0 -> 88278 bytes | |||
| -rw-r--r-- | rust/crates/audio/tests/mix.rs | 183 |
4 files changed, 446 insertions, 0 deletions
diff --git a/rust/crates/audio/tests/collection.rs b/rust/crates/audio/tests/collection.rs new file mode 100644 index 00000000..6c1f8a9f --- /dev/null +++ b/rust/crates/audio/tests/collection.rs @@ -0,0 +1,263 @@ +use std::collections::BTreeMap; +use std::path::PathBuf; + +use audio::collect_audible_elements; +use scene::{ + AudioElement, BaseTimelineElement, Element, LibraryAudioElement, ParamValue, RetimeConfig, + SceneTracks, Track, UploadAudioElement, VideoElement, +}; +use time::MediaTime; + +fn seconds(value: f64) -> MediaTime { + MediaTime::from_seconds_f64(value).expect("finite seconds") +} + +fn base(id: &str, start: f64, duration: f64) -> BaseTimelineElement { + BaseTimelineElement { + id: id.to_string(), + name: id.to_string(), + duration: seconds(duration), + start_time: seconds(start), + trim_start: MediaTime::ZERO, + trim_end: MediaTime::ZERO, + source_duration: None, + animations: None, + params: BTreeMap::new(), + } +} + +fn upload_audio(id: &str, start: f64, duration: f64) -> Element { + Element::Audio(AudioElement::Upload(UploadAudioElement { + base: base(id, start, duration), + retime: None, + media_id: format!("media-{id}"), + })) +} + +fn library_audio(id: &str, start: f64, duration: f64) -> Element { + Element::Audio(AudioElement::Library(LibraryAudioElement { + base: base(id, start, duration), + retime: None, + source_url: format!("https://cdn.test/{id}.mp3"), + })) +} + +fn video(id: &str, start: f64, duration: f64) -> Element { + Element::Video(VideoElement { + base: base(id, start, duration), + media_id: format!("media-{id}"), + is_source_audio_enabled: None, + hidden: None, + retime: None, + effects: None, + masks: None, + }) +} + +fn main_track(elements: Vec<Element>) -> Track { + Track::Video { + id: "main".to_string(), + name: "main".to_string(), + elements, + muted: false, + hidden: false, + } +} + +fn audio_track(id: &str, muted: bool, elements: Vec<Element>) -> Track { + Track::Audio { + id: id.to_string(), + name: id.to_string(), + elements, + muted, + } +} + +fn tracks(main: Vec<Element>, audio: Vec<Track>) -> SceneTracks { + SceneTracks { + overlay: vec![], + main: main_track(main), + audio, + } +} + +fn resolve_any(key: &str) -> Option<PathBuf> { + Some(PathBuf::from(key)) +} + +fn full_range() -> (MediaTime, MediaTime) { + (MediaTime::ZERO, seconds(60.0)) +} + +#[test] +fn collects_upload_audio_and_video_with_source_audio() { + let scene = tracks( + vec![video("v1", 0.0, 2.0)], + vec![audio_track("a", false, vec![upload_audio("u1", 1.0, 1.0)])], + ); + let clips = collect_audible_elements(&scene, &resolve_any, full_range()); + assert_eq!(clips.len(), 2); + assert_eq!(clips[0].element_id, "v1"); + assert_eq!(clips[1].element_id, "u1"); + assert_eq!(clips[0].path, PathBuf::from("media-v1")); + assert_eq!(clips[1].start_time, seconds(1.0)); + assert_eq!(clips[1].duration, seconds(1.0)); +} + +#[test] +fn library_audio_resolves_by_source_url() { + let scene = tracks( + vec![], + vec![audio_track("a", false, vec![library_audio("lib", 0.0, 1.0)])], + ); + let clips = collect_audible_elements(&scene, &resolve_any, full_range()); + assert_eq!(clips.len(), 1); + assert_eq!(clips[0].path, PathBuf::from("https://cdn.test/lib.mp3")); +} + +#[test] +fn muted_track_excludes_its_elements() { + let scene = tracks( + vec![], + vec![ + audio_track("muted-track", true, vec![upload_audio("u1", 0.0, 1.0)]), + audio_track("live-track", false, vec![upload_audio("u2", 0.0, 1.0)]), + ], + ); + let clips = collect_audible_elements(&scene, &resolve_any, full_range()); + assert_eq!(clips.len(), 1); + assert_eq!(clips[0].element_id, "u2"); +} + +#[test] +fn muted_element_is_excluded() { + let mut element = match upload_audio("u1", 0.0, 1.0) { + Element::Audio(AudioElement::Upload(mut upload)) => { + upload + .base + .params + .insert("muted".to_string(), ParamValue::Bool(true)); + Element::Audio(AudioElement::Upload(upload)) + } + other => other, + }; + let scene = tracks(vec![], vec![audio_track("a", false, vec![element])]); + let clips = collect_audible_elements(&scene, &resolve_any, full_range()); + assert!(clips.is_empty()); + + element = match upload_audio("u2", 0.0, 1.0) { + Element::Audio(AudioElement::Upload(mut upload)) => { + upload + .base + .params + .insert("muted".to_string(), ParamValue::Bool(false)); + Element::Audio(AudioElement::Upload(upload)) + } + other => other, + }; + let scene = tracks(vec![], vec![audio_track("a", false, vec![element])]); + assert_eq!(collect_audible_elements(&scene, &resolve_any, full_range()).len(), 1); +} + +#[test] +fn hidden_video_is_excluded() { + let hidden = Element::Video(VideoElement { + hidden: Some(true), + ..match video("v1", 0.0, 2.0) { + Element::Video(v) => v, + _ => unreachable!(), + } + }); + let scene = tracks(vec![hidden], vec![]); + assert!(collect_audible_elements(&scene, &resolve_any, full_range()).is_empty()); +} + +#[test] +fn video_with_source_audio_disabled_is_excluded() { + let disabled = Element::Video(VideoElement { + is_source_audio_enabled: Some(false), + ..match video("v1", 0.0, 2.0) { + Element::Video(v) => v, + _ => unreachable!(), + } + }); + let enabled = Element::Video(VideoElement { + is_source_audio_enabled: Some(true), + ..match video("v2", 0.0, 2.0) { + Element::Video(v) => v, + _ => unreachable!(), + } + }); + let scene = tracks(vec![disabled, enabled], vec![]); + let clips = collect_audible_elements(&scene, &resolve_any, full_range()); + assert_eq!(clips.len(), 1); + assert_eq!(clips[0].element_id, "v2"); +} + +#[test] +fn range_overlap_trims_collection() { + let scene = tracks( + vec![video("v1", 2.0, 2.0), video("v2", 10.0, 2.0)], + vec![], + ); + let clips = collect_audible_elements(&scene, &resolve_any, (seconds(3.0), seconds(4.5))); + assert_eq!(clips.len(), 1); + assert_eq!(clips[0].element_id, "v1"); + + let clips = collect_audible_elements(&scene, &resolve_any, (seconds(4.0), seconds(10.0))); + assert!(clips.is_empty()); + + let clips = collect_audible_elements(&scene, &resolve_any, (seconds(4.0), seconds(10.5))); + assert_eq!(clips.len(), 1); + assert_eq!(clips[0].element_id, "v2"); +} + +#[test] +fn volume_param_is_decibels_with_zero_default() { + let quiet = match upload_audio("u1", 0.0, 1.0) { + Element::Audio(AudioElement::Upload(mut upload)) => { + upload + .base + .params + .insert("volume".to_string(), ParamValue::Number(-6.0)); + Element::Audio(AudioElement::Upload(upload)) + } + other => other, + }; + let plain = upload_audio("u2", 0.0, 1.0); + let scene = tracks(vec![], vec![audio_track("a", false, vec![quiet, plain])]); + let clips = collect_audible_elements(&scene, &resolve_any, full_range()); + assert_eq!(clips[0].volume_db, -6.0); + assert_eq!(clips[1].volume_db, 0.0); + assert!((clips[0].static_gain() - 0.5012).abs() < 0.001); + assert_eq!(clips[1].static_gain(), 1.0); +} + +#[test] +fn retime_and_trim_are_carried() { + let element = match upload_audio("u1", 0.0, 0.5) { + Element::Audio(AudioElement::Upload(mut upload)) => { + upload.base.trim_start = seconds(0.25); + upload.base.trim_end = seconds(0.25); + upload.retime = Some(RetimeConfig { + rate: 2.0, + maintain_pitch: None, + }); + Element::Audio(AudioElement::Upload(upload)) + } + other => other, + }; + let scene = tracks(vec![], vec![audio_track("a", false, vec![element])]); + let clips = collect_audible_elements(&scene, &resolve_any, full_range()); + assert_eq!(clips.len(), 1); + assert_eq!(clips[0].trim_start, seconds(0.25)); + assert_eq!(clips[0].effective_rate(), 2.0); + assert!(!clips[0].requires_maintain_pitch()); +} + +#[test] +fn unresolvable_media_is_excluded() { + let scene = tracks(vec![video("v1", 0.0, 1.0)], vec![]); + let clips = collect_audible_elements(&scene, &|_| None, full_range()); + assert!(clips.is_empty()); +} diff --git a/rust/crates/audio/tests/fixtures/sample.mp4 b/rust/crates/audio/tests/fixtures/sample.mp4 Binary files differnew file mode 100644 index 00000000..13c113e5 --- /dev/null +++ b/rust/crates/audio/tests/fixtures/sample.mp4 diff --git a/rust/crates/audio/tests/fixtures/tone.wav b/rust/crates/audio/tests/fixtures/tone.wav Binary files differnew file mode 100644 index 00000000..8d5f7886 --- /dev/null +++ b/rust/crates/audio/tests/fixtures/tone.wav 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)); +} |