Add WAV file looping support for standalone mode

VeldtJumper · VeldtJumper · commit 3f6b41b761e2 · 2026-04-01T02:57:54.000-05:00
- New --wav flag: loops any .wav file through the filter
- Supports 16/24/32-bit int and float WAV formats
- Auto-resamples to output device sample rate
- Mono WAV duplicates to all output channels
- Updated run.sh and run.bat with usage examples
diff --git a/plugin/Cargo.lock b/plugin/Cargo.lock
diff --git a/plugin/Cargo.toml b/plugin/Cargo.toml
@@ -20,12 +20,16 @@ required-features = ["standalone"]
 
 [features]
 default = []
-standalone = ["cpal"]
+standalone = ["cpal", "hound"]
 
 [dependencies.cpal]
 version = "0.15"
 optional = true
 
+[dependencies.hound]
+version = "3.5"
+optional = true
+
 [profile.release]
 lto = true
 strip = true
diff --git a/plugin/src/standalone.rs b/plugin/src/standalone.rs
@@ -1,16 +1,16 @@
-//! Standalone test harness: generates a test tone, runs it through the biquad LPF,
-//! and outputs to system audio. The Compose UI connects via TCP on localhost:9847
-//! exactly as it would with the DAW-hosted plugin.
+//! Standalone test harness: generates a test tone or loops a WAV file,
+//! runs it through the biquad LPF, and outputs to system audio.
+//! The Compose UI connects via TCP on localhost:9847.
 //!
 //! Usage:
 //!   cargo run --features standalone --bin compose-vst-standalone
 //!   cargo run --features standalone --bin compose-vst-standalone -- --tone noise
-//!   cargo run --features standalone --bin compose-vst-standalone -- --freq 440 --tone sine
+//!   cargo run --features standalone --bin compose-vst-standalone -- --tone sine --freq 440
+//!   cargo run --features standalone --bin compose-vst-standalone -- --wav sample.wav
 
 #[cfg(not(feature = "standalone"))]
 compile_error!("Build with --features standalone");
 
-// Include shared modules directly (can't link against cdylib)
 #[path = "filter.rs"]
 mod filter;
 #[path = "ipc_standalone.rs"]
@@ -51,6 +51,56 @@ fn main() {
         }
     }
 
+    /// Load a WAV file into interleaved f32 samples, resampled to target_sr if needed.
+    /// Returns (samples, channels).
+    fn load_wav(path: &str, target_sr: f32) -> (Vec<f32>, usize) {
+        let reader = hound::WavReader::open(path)
+            .unwrap_or_else(|e| panic!("Failed to open WAV file '{}': {}", path, e));
+
+        let spec = reader.spec();
+        let wav_sr = spec.sample_rate as f32;
+        let wav_channels = spec.channels as usize;
+
+        println!("  WAV: {}Hz, {} channels, {:?} {}bit",
+            spec.sample_rate, spec.channels, spec.sample_format, spec.bits_per_sample);
+
+        // Read all samples as f32
+        let raw_samples: Vec<f32> = match spec.sample_format {
+            hound::SampleFormat::Int => {
+                let max_val = (1u32 << (spec.bits_per_sample - 1)) as f32;
+                reader.into_samples::<i32>()
+                    .map(|s| s.unwrap() as f32 / max_val)
+                    .collect()
+            }
+            hound::SampleFormat::Float => {
+                reader.into_samples::<f32>()
+                    .map(|s| s.unwrap())
+                    .collect()
+            }
+        };
+
+        let num_frames = raw_samples.len() / wav_channels;
+        println!("  Duration: {:.2}s ({} frames)", num_frames as f32 / wav_sr, num_frames);
+
+        // Simple nearest-neighbor resample if sample rates differ
+        if (wav_sr - target_sr).abs() > 1.0 {
+            println!("  Resampling {}Hz → {}Hz", wav_sr, target_sr);
+            let ratio = wav_sr as f64 / target_sr as f64;
+            let new_frames = (num_frames as f64 / ratio) as usize;
+            let mut resampled = Vec::with_capacity(new_frames * wav_channels);
+
+            for i in 0..new_frames {
+                let src_frame = ((i as f64 * ratio) as usize).min(num_frames - 1);
+                for ch in 0..wav_channels {
+                    resampled.push(raw_samples[src_frame * wav_channels + ch]);
+                }
+            }
+            (resampled, wav_channels)
+        } else {
+            (raw_samples, wav_channels)
+        }
+    }
+
     fn parse_arg_str(args: &[String], flag: &str) -> Option<String> {
         args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).cloned())
     }
@@ -60,16 +110,18 @@ fn main() {
 
     let args: Vec<String> = std::env::args().collect();
     let tone_freq = parse_arg_f32(&args, "--freq").unwrap_or(440.0);
-    let use_noise = matches!(
-        parse_arg_str(&args, "--tone").as_deref(),
-        Some("noise") | Some("white-noise")
-    );
-    let use_sweep = parse_arg_str(&args, "--tone").as_deref() == Some("sweep");
+    let wav_path = parse_arg_str(&args, "--wav");
+    let tone_str = parse_arg_str(&args, "--tone");
+    let use_noise = matches!(tone_str.as_deref(), Some("noise") | Some("white-noise"));
+    let use_sweep = tone_str.as_deref() == Some("sweep");
+    let use_wav = wav_path.is_some();
 
     println!("╔══════════════════════════════════════════╗");
     println!("║   Compose VST - Standalone Test Mode     ║");
     println!("╠══════════════════════════════════════════╣");
-    if use_noise {
+    if use_wav {
+        println!("║  Source: WAV file (looping)               ║");
+    } else if use_noise {
         println!("║  Tone: white noise                       ║");
     } else if use_sweep {
         println!("║  Tone: sweep 20Hz-20kHz                  ║");
@@ -103,6 +155,12 @@ fn main() {
     let channels = config.channels() as usize;
     println!("Sample rate: {}Hz, Channels: {}", sample_rate, channels);
 
+    // Load WAV if specified
+    let wav_data: Option<(Vec<f32>, usize)> = wav_path.as_ref().map(|p| {
+        println!("Loading WAV: {}", p);
+        load_wav(p, sample_rate)
+    });
+
     let state_audio = state.clone();
     let mut phase: f64 = 0.0;
     let mut sweep_freq: f64 = 20.0;
@@ -111,6 +169,12 @@ fn main() {
     let mut sample_count: u64 = 0;
     let send_interval = (sample_rate as u64 / 30).max(1);
 
+    // WAV playback state
+    let mut wav_pos: usize = 0;
+    let wav_samples = wav_data.as_ref().map(|(s, _)| s.clone());
+    let wav_channels = wav_data.as_ref().map(|(_, c)| *c).unwrap_or(1);
+    let wav_total_frames = wav_samples.as_ref().map(|s| s.len() / wav_channels).unwrap_or(0);
+
     let stream = device.build_output_stream(
         &config.into(),
         move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
@@ -121,30 +185,46 @@ fn main() {
                 f.set_params(cutoff, resonance);
             }
 
+            let num_filters = filters.len();
+
             for frame in data.chunks_mut(channels) {
-                let raw = if use_noise {
-                    rng_state ^= rng_state << 13;
-                    rng_state ^= rng_state >> 17;
-                    rng_state ^= rng_state << 5;
-                    (rng_state as f32 / u32::MAX as f32 * 2.0 - 1.0) * 0.3
-                } else if use_sweep {
-                    let s = (phase * 2.0 * std::f64::consts::PI).sin() as f32 * 0.3;
-                    phase += sweep_freq / sample_rate as f64;
-                    if phase >= 1.0 { phase -= 1.0; }
-                    sweep_freq = 20.0 * (20000.0_f64 / 20.0).powf(
-                        (sample_count as f64 % (sample_rate as f64 * 5.0)) / (sample_rate as f64 * 5.0)
-                    );
-                    s
+                if let Some(ref wav) = wav_samples {
+                    // WAV looping playback
+                    for (ch, sample) in frame.iter_mut().enumerate() {
+                        // Map output channel to WAV channel (mono WAV → duplicate to all channels)
+                        let wav_ch = if ch < wav_channels { ch } else { ch % wav_channels };
+                        let raw = wav[wav_pos * wav_channels + wav_ch];
+                        *sample = filters[ch % num_filters].process(raw);
+                    }
+                    wav_pos += 1;
+                    if wav_pos >= wav_total_frames {
+                        wav_pos = 0; // loop
+                    }
                 } else {
-                    let s = (phase * 2.0 * std::f64::consts::PI).sin() as f32 * 0.3;
-                    phase += tone_freq as f64 / sample_rate as f64;
-                    if phase >= 1.0 { phase -= 1.0; }
-                    s
-                };
-
-                let num_filters = filters.len();
-                for (ch, sample) in frame.iter_mut().enumerate() {
-                    *sample = filters[ch % num_filters].process(raw);
+                    // Generated tone
+                    let raw = if use_noise {
+                        rng_state ^= rng_state << 13;
+                        rng_state ^= rng_state >> 17;
+                        rng_state ^= rng_state << 5;
+                        (rng_state as f32 / u32::MAX as f32 * 2.0 - 1.0) * 0.3
+                    } else if use_sweep {
+                        let s = (phase * 2.0 * std::f64::consts::PI).sin() as f32 * 0.3;
+                        phase += sweep_freq / sample_rate as f64;
+                        if phase >= 1.0 { phase -= 1.0; }
+                        sweep_freq = 20.0 * (20000.0_f64 / 20.0).powf(
+                            (sample_count as f64 % (sample_rate as f64 * 5.0)) / (sample_rate as f64 * 5.0)
+                        );
+                        s
+                    } else {
+                        let s = (phase * 2.0 * std::f64::consts::PI).sin() as f32 * 0.3;
+                        phase += tone_freq as f64 / sample_rate as f64;
+                        if phase >= 1.0 { phase -= 1.0; }
+                        s
+                    };
+
+                    for (ch, sample) in frame.iter_mut().enumerate() {
+                        *sample = filters[ch % num_filters].process(raw);
+                    }
                 }
                 sample_count += 1;
             }
diff --git a/run.bat b/run.bat
@@ -1,6 +1,10 @@
 @echo off
 REM Launch Compose VST standalone (Rust audio + Compose UI)
-REM Usage: run.bat [--tone sine|noise|sweep] [--freq 440]
+REM Usage:
+REM   run.bat                              default 440Hz sine
+REM   run.bat --tone noise                 white noise
+REM   run.bat --tone sweep                 frequency sweep
+REM   run.bat --wav sample.wav             loop a WAV file
 REM Close this window to shut everything down.
 
 setlocal
@@ -25,5 +29,4 @@ echo.
 echo ✅ Both running. Close this window to stop.
 echo.
 
-REM Wait for user to close — on window close, child processes terminate
 pause >nul
diff --git a/run.sh b/run.sh
@@ -1,6 +1,11 @@
 #!/usr/bin/env bash
 # Launch Compose VST standalone (Rust audio + Compose UI)
-# Usage: ./run.sh [--tone sine|noise|sweep] [--freq 440]
+# Usage:
+#   ./run.sh                              # default 440Hz sine
+#   ./run.sh --tone noise                 # white noise
+#   ./run.sh --tone sweep                 # frequency sweep
+#   ./run.sh --wav sample.wav             # loop a WAV file
+#   ./run.sh --wav sample.wav --freq 440  # (--freq ignored with --wav)
 # Press Ctrl+C or close the terminal to shut everything down.
 
 set -e
@@ -10,7 +15,6 @@ RUST_ARGS=("$@")
 cleanup() {
     echo ""
     echo "Shutting down..."
-    # Kill child processes
     [[ -n "$RUST_PID" ]] && kill "$RUST_PID" 2>/dev/null
     [[ -n "$UI_PID" ]] && kill "$UI_PID" 2>/dev/null
     wait 2>/dev/null
