audiowaveform 0.1.0

data/crates/audiowaveform/tests/formats.rs

@@ -0,0 +1,223 @@
+#![cfg(feature = "decode")]
+
+mod support;
+
+use std::io::Cursor;
+
+use audiowaveform::{
+    AudioFormat, Error, GenerateOptions, decode_audio_from_path, generate_waveform_from_path,
+    generate_waveform_from_reader,
+};
+use support::fixture_path;
+#[cfg(feature = "format-m4a")]
+use support::read_fixture;
+
+#[test]
+fn format_features_control_decoding() {
+    for (fixture, enabled, feature, sample_rate, channels) in [
+        (
+            "formats/stereo.aac",
+            cfg!(feature = "format-aac"),
+            "format-aac",
+            48_000,
+            2,
+        ),
+        (
+            "formats/stereo.m4a",
+            cfg!(feature = "format-m4a"),
+            "format-m4a",
+            48_000,
+            2,
+        ),
+        (
+            "formats/mono.m4a",
+            cfg!(feature = "format-m4a"),
+            "format-m4a",
+            44_100,
+            1,
+        ),
+        (
+            "formats/alac.m4a",
+            cfg!(feature = "format-m4a"),
+            "format-m4a",
+            48_000,
+            2,
+        ),
+        (
+            "formats/fragmented.mp4",
+            cfg!(feature = "format-m4a"),
+            "format-m4a",
+            48_000,
+            2,
+        ),
+        (
+            "formats/video-first.mp4",
+            cfg!(feature = "format-m4a"),
+            "format-m4a",
+            48_000,
+            2,
+        ),
+        (
+            "formats/stereo.aiff",
+            cfg!(feature = "format-aiff"),
+            "format-aiff",
+            48_000,
+            2,
+        ),
+        (
+            "formats/stereo.caf",
+            cfg!(feature = "format-caf"),
+            "format-caf",
+            48_000,
+            2,
+        ),
+        (
+            "formats/pcm.caf",
+            cfg!(feature = "format-caf"),
+            "format-caf",
+            48_000,
+            2,
+        ),
+        (
+            "formats/stereo.webm",
+            cfg!(feature = "format-mkv"),
+            "format-mkv",
+            48_000,
+            2,
+        ),
+        (
+            "formats/stereo.mka",
+            cfg!(feature = "format-mkv"),
+            "format-mkv",
+            48_000,
+            2,
+        ),
+        (
+            "formats/stereo.mp2",
+            cfg!(feature = "format-mp2"),
+            "format-mp2",
+            48_000,
+            2,
+        ),
+        (
+            "formats/silence.mp1",
+            cfg!(feature = "format-mp1"),
+            "format-mp1",
+            44_100,
+            1,
+        ),
+        (
+            "test_file_stereo.mp3",
+            cfg!(feature = "format-mp3"),
+            "format-mp3",
+            16_000,
+            2,
+        ),
+        (
+            "test_file_stereo.flac",
+            cfg!(feature = "format-flac"),
+            "format-flac",
+            16_000,
+            2,
+        ),
+        (
+            "formats/flac.ogg",
+            cfg!(feature = "format-ogg"),
+            "format-ogg",
+            48_000,
+            2,
+        ),
+        (
+            "test_file_stereo.oga",
+            cfg!(feature = "format-ogg"),
+            "format-ogg",
+            16_000,
+            2,
+        ),
+        (
+            "formats/stereo.wav",
+            cfg!(feature = "format-wav"),
+            "format-wav",
+            48_000,
+            2,
+        ),
+        (
+            "formats/adpcm.wav",
+            cfg!(feature = "format-wav"),
+            "format-wav",
+            48_000,
+            2,
+        ),
+    ] {
+        let result = decode_audio_from_path(fixture_path(fixture));
+        if !enabled {
+            assert!(
+                matches!(result, Err(Error::FeatureDisabled { feature: actual }) if actual == feature),
+                "{fixture}: {result:?}"
+            );
+            continue;
+        }
+        let pcm = result.unwrap_or_else(|error| panic!("{fixture}: {error}"));
+        assert_eq!(pcm.sample_rate(), sample_rate, "{fixture}");
+        assert_eq!(pcm.channels(), channels, "{fixture}");
+        assert!(pcm.frame_count() > 0, "{fixture}");
+        if fixture.starts_with("formats/") {
+            assert!(
+                (pcm.duration_seconds() - 0.25).abs() < 0.1,
+                "{fixture}: {}",
+                pcm.duration_seconds()
+            );
+        }
+        if !fixture.ends_with("silence.mp1") {
+            assert!(pcm.samples().iter().any(|sample| *sample != 0), "{fixture}");
+        }
+        let waveform =
+            generate_waveform_from_path(fixture_path(fixture), &GenerateOptions::default())
+                .expect("generate");
+        assert!(!waveform.is_empty(), "{fixture}");
+    }
+}
+
+#[cfg(feature = "format-m4a")]
+#[test]
+fn m4a_decoding_selects_audio_and_supports_probing_without_a_filename() {
+    let options = GenerateOptions::default();
+    let audio = generate_waveform_from_path(fixture_path("formats/stereo.m4a"), &options).unwrap();
+    let video =
+        generate_waveform_from_path(fixture_path("formats/video-first.mp4"), &options).unwrap();
+    assert_eq!(audio, video);
+    let probed = generate_waveform_from_reader(
+        Cursor::new(read_fixture("formats/stereo.m4a")),
+        None,
+        &options,
+    )
+    .unwrap();
+    assert_eq!(audio, probed);
+    assert!(
+        !generate_waveform_from_path(fixture_path("formats/short.m4a"), &options)
+            .unwrap()
+            .is_empty()
+    );
+    let error = decode_audio_from_path(fixture_path("formats/video-only.mp4")).unwrap_err();
+    assert!(error.to_string().contains("no supported audio track"));
+}
+
+#[test]
+fn corrupt_enabled_formats_return_errors() {
+    for format in [
+        AudioFormat::Aac,
+        AudioFormat::Mp4,
+        AudioFormat::Wav,
+        AudioFormat::Mp3,
+        AudioFormat::Mkv,
+    ] {
+        if format.ensure_enabled().is_ok() {
+            let result = generate_waveform_from_reader(
+                Cursor::new(b"not an audio file".to_vec()),
+                Some(format),
+                &GenerateOptions::default(),
+            );
+            assert!(result.is_err(), "{format:?}");
+        }
+    }
+}

data/crates/audiowaveform/tests/generate.rs

@@ -0,0 +1,233 @@
+mod support;
+
+#[cfg(feature = "format-wav")]
+use std::io::Cursor;
+
+use audiowaveform::{
+    GenerateOptions, ScaleSpec, WaveformFormat, decode_audio_from_path, generate_waveform_from_path,
+};
+
+#[cfg(feature = "format-wav")]
+use self::support::read_fixture;
+use self::support::{assert_bytes_eq, fixture_path};
+#[cfg(feature = "format-wav")]
+use audiowaveform::{RawAudioConfig, RawSampleFormat, generate_waveform_from_raw_reader};
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn generates_expected_binary_waveform_from_wav() {
+    let waveform = generate_waveform_from_path(
+        fixture_path("test_file_stereo.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(64),
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate waveform");
+
+    let mut output = Vec::new();
+    waveform
+        .write_to_writer(&mut output, WaveformFormat::Dat, Some(8))
+        .expect("write dat");
+
+    assert_bytes_eq(&output, "test_file_stereo_8bit_64spp_wav.dat");
+}
+
+#[test]
+fn decodes_supported_audio_inputs_with_expected_metadata() {
+    let cases = [
+        ("test_file_stereo.wav", 16_000, 2, 113_519_usize),
+        ("test_file_mono_float32.wav", 16_000, 1, 115_190_usize),
+        ("test_file_stereo.mp3", 16_000, 2, 113_519_usize),
+        ("test_file_stereo.flac", 16_000, 2, 113_519_usize),
+        ("test_file_stereo.oga", 16_000, 2, 113_792_usize),
+    ];
+
+    for (fixture, sample_rate, channels, frames) in cases {
+        if audiowaveform::AudioFormat::from_path(fixture)
+            .unwrap()
+            .ensure_enabled()
+            .is_err()
+        {
+            continue;
+        }
+        let pcm = decode_audio_from_path(fixture_path(fixture)).expect("decode audio");
+        assert_eq!(pcm.sample_rate(), sample_rate, "{fixture}");
+        assert_eq!(pcm.channels(), channels, "{fixture}");
+        assert_eq!(pcm.frame_count(), frames, "{fixture}");
+    }
+}
+
+#[test]
+fn generates_expected_waveform_bytes_from_supported_audio_inputs() {
+    let cases = [
+        (
+            "test_file_stereo.wav",
+            "test_file_stereo_8bit_64spp_wav.dat",
+            "test_file_stereo_8bit_64spp_wav.json",
+        ),
+        (
+            "test_file_stereo.mp3",
+            "test_file_stereo_8bit_64spp_mp3.dat",
+            "test_file_stereo_8bit_64spp_mp3.json",
+        ),
+        (
+            "test_file_stereo.flac",
+            "test_file_stereo_8bit_64spp_flac.dat",
+            "test_file_stereo_8bit_64spp_flac.json",
+        ),
+        (
+            "test_file_stereo.oga",
+            "test_file_stereo_8bit_64spp_oga.dat",
+            "test_file_stereo_8bit_64spp_oga.json",
+        ),
+    ];
+
+    for (input, dat_fixture, json_fixture) in cases {
+        if audiowaveform::AudioFormat::from_path(input)
+            .unwrap()
+            .ensure_enabled()
+            .is_err()
+        {
+            continue;
+        }
+        let waveform = generate_waveform_from_path(
+            fixture_path(input),
+            &GenerateOptions {
+                scale: ScaleSpec::SamplesPerPixel(64),
+                split_channels: false,
+                amplitude_scale: None,
+            },
+        )
+        .expect("generate waveform");
+
+        let mut dat = Vec::new();
+        waveform
+            .write_to_writer(&mut dat, WaveformFormat::Dat, Some(8))
+            .expect("write dat");
+        assert_bytes_eq(&dat, dat_fixture);
+
+        let mut json = Vec::new();
+        waveform
+            .write_to_writer(&mut json, WaveformFormat::Json, Some(8))
+            .expect("write json");
+        assert_bytes_eq(&json, json_fixture);
+    }
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn generates_expected_waveform_from_float_wav_audio() {
+    let waveform = generate_waveform_from_path(
+        fixture_path("test_file_mono_float32.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(64),
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate waveform");
+
+    let mut dat = Vec::new();
+    waveform
+        .write_to_writer(&mut dat, WaveformFormat::Dat, Some(8))
+        .expect("write dat");
+    assert_bytes_eq(&dat, "test_file_mono_float32_8bit_64spp.dat");
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn generates_expected_waveform_from_raw_audio() {
+    let raw = read_fixture("test_file_mono.raw");
+    let raw_config = RawAudioConfig::new(16_000, 1, RawSampleFormat::S16Le).expect("raw config");
+    let options = GenerateOptions {
+        scale: ScaleSpec::SamplesPerPixel(64),
+        split_channels: false,
+        amplitude_scale: None,
+    };
+
+    let waveform_from_raw =
+        generate_waveform_from_raw_reader(Cursor::new(raw), &raw_config, &options)
+            .expect("generate waveform from raw");
+    let waveform_from_wav =
+        generate_waveform_from_path(fixture_path("test_file_mono.wav"), &options)
+            .expect("generate waveform from wav");
+
+    assert_eq!(waveform_from_raw, waveform_from_wav);
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn generates_expected_split_channel_and_auto_scaled_waveforms() {
+    let split = generate_waveform_from_path(
+        fixture_path("test_file_stereo.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(64),
+            split_channels: true,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate split channels");
+    let mut split_dat = Vec::new();
+    split
+        .write_to_writer(&mut split_dat, WaveformFormat::Dat, Some(8))
+        .expect("write split dat");
+    assert_bytes_eq(&split_dat, "test_file_2channel_8bit_64spp_wav.dat");
+
+    let auto = generate_waveform_from_path(
+        fixture_path("test_file_stereo.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(64),
+            split_channels: false,
+            amplitude_scale: Some(audiowaveform::AmplitudeScale::Auto),
+        },
+    )
+    .expect("generate auto-scaled waveform");
+    let mut auto_dat = Vec::new();
+    auto.write_to_writer(&mut auto_dat, WaveformFormat::Dat, Some(8))
+        .expect("write auto dat");
+    assert_bytes_eq(&auto_dat, "test_file_stereo_8bit_64spp_wav_auto_scale.dat");
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn reader_based_generation_matches_path_based_generation() {
+    let bytes = read_fixture("test_file_stereo.wav");
+    let from_reader = audiowaveform::generate_waveform_from_reader(
+        Cursor::new(bytes),
+        Some(audiowaveform::AudioFormat::Wav),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(64),
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate from reader");
+    let from_path = generate_waveform_from_path(
+        fixture_path("test_file_stereo.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(64),
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate from path");
+
+    assert_eq!(from_reader, from_path);
+}
+
+#[test]
+fn rejects_opus_generation_until_supported() {
+    let error = generate_waveform_from_path(
+        fixture_path("test_file_stereo.opus"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(64),
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect_err("opus should be unsupported");
+
+    assert_eq!(error.to_string(), "Unsupported format: opus");
+}