[add] tests for loading ogg/wav files with various sampling rates and output formats.

Author: vmarcella

crates/lambda-rs-platform/assets/audio/slash_vorbis_stereo_48000.ogg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb635f26da26ae2dadd8560ed3e0451381b90e7b5abfbe3303ec33f27f340e43
+size 14370

crates/lambda-rs-platform/assets/audio/tone_f32_stereo_44100.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7241cee48cae37e67abcac3aa06fbf1c478828c896fc92d594605d9e44721476
+size 35336

crates/lambda-rs-platform/assets/audio/tone_s16_mono_44100.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5dfea227c9ae756cf4176f2a15ce702be6e1e3bc53985997e962c3fc3c5a3d1f
+size 8864

crates/lambda-rs-platform/assets/audio/tone_s16_stereo_44100.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fe4cb948618e2945b70edd203639092b134bcbd6d841d44488a0bb07c7a7af4
+size 17684

crates/lambda-rs-platform/assets/audio/tone_s24_mono_44100.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2f1da451b14d054360935d78127ebc29723b7aed12809f82f259a5870034eb5
+size 13274

crates/lambda-rs-platform/src/audio/symphonia/mod.rs

@@ -12,10 +12,11 @@ use std::{
 
 #[cfg(feature = "audio-decode-vorbis")]
 use symphonia::core::codecs::CODEC_TYPE_VORBIS;
-#[cfg(feature = "audio-decode-wav")]
-use symphonia::core::sample::SampleFormat;
 use symphonia::core::{
-  audio::SampleBuffer,
+  audio::{
+    AudioBufferRef,
+    SampleBuffer,
+  },
   codecs::{
     Decoder,
     DecoderOptions,
@@ -193,6 +194,7 @@ fn decode_track_to_interleaved_f32(
 
   let mut sample_rate: Option<u32> = None;
   let mut channel_count: Option<u16> = None;
+  let mut wav_sample_format_validated = false;
 
   loop {
     let packet = match format.next_packet() {
@@ -269,6 +271,15 @@ fn decode_track_to_interleaved_f32(
     }
 
     let frames = decoded.frames();
+    if frames == 0 {
+      continue;
+    }
+
+    if source_description == "WAV" && !wav_sample_format_validated {
+      validate_wav_decoded_sample_format(&decoded)?;
+      wav_sample_format_validated = true;
+    }
+
     let mut sample_buffer =
       SampleBuffer::<f32>::new(frames as u64, *decoded.spec());
     sample_buffer.copy_interleaved_ref(decoded);
@@ -299,6 +310,43 @@ fn decode_track_to_interleaved_f32(
   });
 }
 
+fn validate_wav_decoded_sample_format(
+  decoded: &AudioBufferRef<'_>,
+) -> Result<(), AudioDecodeError> {
+  match decoded {
+    AudioBufferRef::S16(_)
+    | AudioBufferRef::S24(_)
+    | AudioBufferRef::F32(_) => {
+      return Ok(());
+    }
+    other => {
+      return Err(AudioDecodeError::UnsupportedFormat {
+        details: format!(
+          "unsupported WAV decoded sample format: {}",
+          wav_decoded_sample_format_name(other)
+        ),
+      });
+    }
+  }
+}
+
+fn wav_decoded_sample_format_name(
+  decoded: &AudioBufferRef<'_>,
+) -> &'static str {
+  match decoded {
+    AudioBufferRef::U8(_) => "U8",
+    AudioBufferRef::U16(_) => "U16",
+    AudioBufferRef::U24(_) => "U24",
+    AudioBufferRef::U32(_) => "U32",
+    AudioBufferRef::S8(_) => "S8",
+    AudioBufferRef::S16(_) => "S16",
+    AudioBufferRef::S24(_) => "S24",
+    AudioBufferRef::S32(_) => "S32",
+    AudioBufferRef::F32(_) => "F32",
+    AudioBufferRef::F64(_) => "F64",
+  }
+}
+
 /// Decode WAV bytes into interleaved `f32` samples.
 #[cfg(feature = "audio-decode-wav")]
 pub fn decode_wav_bytes(
@@ -314,22 +362,6 @@ pub fn decode_wav_bytes(
     }
   };
 
-  let sample_format =
-    codec_params
-      .sample_format
-      .ok_or(AudioDecodeError::UnsupportedFormat {
-        details: "WAV sample format is unspecified".to_string(),
-      })?;
-
-  match sample_format {
-    SampleFormat::S16 | SampleFormat::S24 | SampleFormat::F32 => {}
-    other => {
-      return Err(AudioDecodeError::UnsupportedFormat {
-        details: format!("unsupported WAV sample format: {other:?}"),
-      });
-    }
-  }
-
   let mut decoder = symphonia::default::get_codecs()
     .make(&codec_params, &DecoderOptions::default())
     .map_err(|error| map_read_or_decode_error("WAV", error))?;
@@ -387,6 +419,36 @@ pub fn decode_ogg_vorbis_bytes(
 mod tests {
   use super::*;
 
+  #[cfg(feature = "audio-decode-wav")]
+  const TONE_S16_MONO_44100_WAV: &[u8] = include_bytes!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/assets/audio/tone_s16_mono_44100.wav"
+  ));
+
+  #[cfg(feature = "audio-decode-wav")]
+  const TONE_S16_STEREO_44100_WAV: &[u8] = include_bytes!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/assets/audio/tone_s16_stereo_44100.wav"
+  ));
+
+  #[cfg(feature = "audio-decode-wav")]
+  const TONE_S24_MONO_44100_WAV: &[u8] = include_bytes!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/assets/audio/tone_s24_mono_44100.wav"
+  ));
+
+  #[cfg(feature = "audio-decode-wav")]
+  const TONE_F32_STEREO_44100_WAV: &[u8] = include_bytes!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/assets/audio/tone_f32_stereo_44100.wav"
+  ));
+
+  #[cfg(feature = "audio-decode-vorbis")]
+  const SLASH_VORBIS_STEREO_48000_OGG: &[u8] = include_bytes!(concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/assets/audio/slash_vorbis_stereo_48000.ogg"
+  ));
+
   #[cfg(feature = "audio-decode-wav")]
   #[test]
   fn wav_decode_rejects_invalid_bytes() {
@@ -400,6 +462,50 @@ mod tests {
     return;
   }
 
+  #[cfg(feature = "audio-decode-wav")]
+  #[test]
+  fn wav_decode_s16_mono_fixture_decodes() {
+    let decoded =
+      decode_wav_bytes(TONE_S16_MONO_44100_WAV).expect("decode failed");
+    assert_eq!(decoded.sample_rate, 44100);
+    assert_eq!(decoded.channels, 1);
+    assert_eq!(decoded.samples.len(), 4410);
+    return;
+  }
+
+  #[cfg(feature = "audio-decode-wav")]
+  #[test]
+  fn wav_decode_s16_stereo_fixture_decodes() {
+    let decoded =
+      decode_wav_bytes(TONE_S16_STEREO_44100_WAV).expect("decode failed");
+    assert_eq!(decoded.sample_rate, 44100);
+    assert_eq!(decoded.channels, 2);
+    assert_eq!(decoded.samples.len(), 4410 * 2);
+    return;
+  }
+
+  #[cfg(feature = "audio-decode-wav")]
+  #[test]
+  fn wav_decode_s24_mono_fixture_decodes() {
+    let decoded =
+      decode_wav_bytes(TONE_S24_MONO_44100_WAV).expect("decode failed");
+    assert_eq!(decoded.sample_rate, 44100);
+    assert_eq!(decoded.channels, 1);
+    assert_eq!(decoded.samples.len(), 4410);
+    return;
+  }
+
+  #[cfg(feature = "audio-decode-wav")]
+  #[test]
+  fn wav_decode_f32_stereo_fixture_decodes() {
+    let decoded =
+      decode_wav_bytes(TONE_F32_STEREO_44100_WAV).expect("decode failed");
+    assert_eq!(decoded.sample_rate, 44100);
+    assert_eq!(decoded.channels, 2);
+    assert_eq!(decoded.samples.len(), 4410 * 2);
+    return;
+  }
+
   #[cfg(feature = "audio-decode-vorbis")]
   #[test]
   fn ogg_vorbis_decode_rejects_invalid_bytes() {
@@ -412,4 +518,15 @@ mod tests {
     ));
     return;
   }
+
+  #[cfg(feature = "audio-decode-vorbis")]
+  #[test]
+  fn ogg_vorbis_decode_fixture_decodes() {
+    let decoded = decode_ogg_vorbis_bytes(SLASH_VORBIS_STEREO_48000_OGG)
+      .expect("decode failed");
+    assert_eq!(decoded.sample_rate, 48000);
+    assert_eq!(decoded.channels, 2);
+    assert!(!decoded.samples.is_empty());
+    return;
+  }
 }

crates/lambda-rs/examples/sound_buffer_load.rs

@@ -0,0 +1,88 @@
+#![allow(clippy::needless_return)]
+
+use std::path::{
+  Path,
+  PathBuf,
+};
+
+use lambda::audio::{
+  AudioError,
+  SoundBuffer,
+};
+
+fn main() {
+  let path = match parse_path_argument() {
+    Ok(path) => path,
+    Err(message) => {
+      eprintln!("{message}");
+      std::process::exit(2);
+    }
+  };
+
+  let buffer = match load_sound_buffer(&path) {
+    Ok(buffer) => buffer,
+    Err(error) => {
+      eprintln!("failed to load sound buffer: {error}");
+      std::process::exit(1);
+    }
+  };
+
+  println!("path: {}", path.display());
+  println!("sample_rate: {}", buffer.sample_rate());
+  println!("channels: {}", buffer.channels());
+  println!("duration_seconds: {:.3}", buffer.duration_seconds());
+  return;
+}
+
+fn parse_path_argument() -> Result<PathBuf, String> {
+  let mut args = std::env::args_os();
+  let program_name = args
+    .next()
+    .and_then(|value| value.into_string().ok())
+    .unwrap_or_else(|| "sound_buffer_load".to_string());
+
+  let path = args.next().ok_or_else(|| {
+    return format!("usage: {program_name} <path-to-wav-or-ogg>");
+  })?;
+
+  return Ok(PathBuf::from(path));
+}
+
+fn load_sound_buffer(path: &Path) -> Result<SoundBuffer, AudioError> {
+  let extension = path
+    .extension()
+    .and_then(|value| value.to_str())
+    .map(|value| value.to_ascii_lowercase())
+    .unwrap_or_else(|| "".to_string());
+
+  match extension.as_str() {
+    #[cfg(feature = "audio-sound-buffer-wav")]
+    "wav" => {
+      return SoundBuffer::from_wav_file(path);
+    }
+    #[cfg(not(feature = "audio-sound-buffer-wav"))]
+    "wav" => {
+      return Err(AudioError::UnsupportedFormat {
+        details: "WAV support is disabled (enable `audio-sound-buffer-wav`)"
+          .to_string(),
+      });
+    }
+    #[cfg(feature = "audio-sound-buffer-vorbis")]
+    "ogg" | "oga" => {
+      return SoundBuffer::from_ogg_file(path);
+    }
+    #[cfg(not(feature = "audio-sound-buffer-vorbis"))]
+    "ogg" | "oga" => {
+      return Err(AudioError::UnsupportedFormat {
+        details:
+          "OGG Vorbis support is disabled (enable `audio-sound-buffer-vorbis`)"
+            .to_string(),
+      });
+    }
+    _ => {
+      return Err(AudioError::UnsupportedFormat {
+        details: format!("unsupported file extension: {extension:?}"),
+      });
+    }
+  }
+}

crates/lambda-rs/src/audio/buffer.rs

@@ -131,4 +131,60 @@ mod tests {
     assert_eq!(buffer.duration_seconds(), 1.0);
     return;
   }
+
+  #[cfg(feature = "audio-sound-buffer-wav")]
+  #[test]
+  fn from_wav_bytes_decodes_fixture() {
+    let bytes = include_bytes!(concat!(
+      env!("CARGO_MANIFEST_DIR"),
+      "/../lambda-rs-platform/assets/audio/tone_s16_mono_44100.wav"
+    ));
+
+    let buffer = SoundBuffer::from_wav_bytes(bytes).expect("decode failed");
+    assert_eq!(buffer.sample_rate(), 44100);
+    assert_eq!(buffer.channels(), 1);
+    assert!(buffer.duration_seconds() > 0.0);
+    return;
+  }
+
+  #[cfg(feature = "audio-sound-buffer-wav")]
+  #[test]
+  fn from_wav_file_decodes_fixture() {
+    let path = Path::new(env!("CARGO_MANIFEST_DIR"))
+      .join("../lambda-rs-platform/assets/audio/tone_s16_mono_44100.wav");
+
+    let buffer = SoundBuffer::from_wav_file(&path).expect("decode failed");
+    assert_eq!(buffer.sample_rate(), 44100);
+    assert_eq!(buffer.channels(), 1);
+    assert!(buffer.duration_seconds() > 0.0);
+    return;
+  }
+
+  #[cfg(feature = "audio-sound-buffer-vorbis")]
+  #[test]
+  fn from_ogg_bytes_decodes_fixture() {
+    let bytes = include_bytes!(concat!(
+      env!("CARGO_MANIFEST_DIR"),
+      "/../lambda-rs-platform/assets/audio/slash_vorbis_stereo_48000.ogg"
+    ));
+
+    let buffer = SoundBuffer::from_ogg_bytes(bytes).expect("decode failed");
+    assert_eq!(buffer.sample_rate(), 48000);
+    assert_eq!(buffer.channels(), 2);
+    assert!(buffer.duration_seconds() > 0.0);
+    return;
+  }
+
+  #[cfg(feature = "audio-sound-buffer-vorbis")]
+  #[test]
+  fn from_ogg_file_decodes_fixture() {
+    let path = Path::new(env!("CARGO_MANIFEST_DIR"))
+      .join("../lambda-rs-platform/assets/audio/slash_vorbis_stereo_48000.ogg");
+
+    let buffer = SoundBuffer::from_ogg_file(&path).expect("decode failed");
+    assert_eq!(buffer.sample_rate(), 48000);
+    assert_eq!(buffer.channels(), 2);
+    assert!(buffer.duration_seconds() > 0.0);
+    return;
+  }
 }