audiowaveform 0.1.0

data/crates/audiowaveform/tests/render.rs

@@ -0,0 +1,263 @@
+mod support;
+
+use audiowaveform::{
+    AmplitudeScale, Color, ColorScheme, RenderOptions, RenderStyle, ScaleSpec, WaveformColors,
+    render_waveform,
+};
+#[cfg(feature = "format-wav")]
+use audiowaveform::{GenerateOptions, generate_waveform_from_path};
+
+use self::support::{assert_png_image_matches_fixture, load_waveform};
+
+#[test]
+fn renders_default_waveform_image_fixture() {
+    let waveform = load_waveform("test_file_stereo_8bit_64spp_wav.dat")
+        .resample(ScaleSpec::SamplesPerPixel(128))
+        .expect("resample waveform");
+    let image = render_waveform(&waveform, &RenderOptions::default()).expect("render image");
+
+    assert_png_image_matches_fixture(&image, "test_file_stereo_dat_128spp.png");
+}
+
+#[test]
+fn renders_waveform_images_with_custom_render_options() {
+    let waveform = load_waveform("test_file_stereo_8bit_64spp_wav.dat")
+        .resample(ScaleSpec::SamplesPerPixel(128))
+        .expect("resample waveform");
+    let two_channel = load_waveform("test_file_2channel_8bit_64spp_wav.dat")
+        .resample(ScaleSpec::SamplesPerPixel(128))
+        .expect("resample two-channel waveform");
+
+    let cases = [
+        (
+            "test_file_stereo_dat_128spp_no_axis_labels.png",
+            RenderOptions {
+                axis_labels: false,
+                ..RenderOptions::default()
+            },
+            &waveform,
+        ),
+        (
+            "test_file_stereo_dat_128spp_scale_1.5.png",
+            RenderOptions {
+                amplitude_scale: AmplitudeScale::Fixed(1.5),
+                ..RenderOptions::default()
+            },
+            &waveform,
+        ),
+        (
+            "test_file_stereo_dat_128spp_scale_auto.png",
+            RenderOptions {
+                amplitude_scale: AmplitudeScale::Auto,
+                ..RenderOptions::default()
+            },
+            &waveform,
+        ),
+        (
+            "test_file_stereo_dat_128spp_offset.png",
+            RenderOptions {
+                start_time: 0.5,
+                ..RenderOptions::default()
+            },
+            &waveform,
+        ),
+        (
+            "test_file_stereo_dat_128spp_square_bars.png",
+            RenderOptions {
+                style: RenderStyle::Bars {
+                    width: 8,
+                    gap: 4,
+                    style: audiowaveform::BarStyle::Square,
+                },
+                ..RenderOptions::default()
+            },
+            &waveform,
+        ),
+        (
+            "test_file_stereo_dat_128spp_rounded_bars.png",
+            RenderOptions {
+                style: RenderStyle::Bars {
+                    width: 8,
+                    gap: 4,
+                    style: audiowaveform::BarStyle::Rounded,
+                },
+                ..RenderOptions::default()
+            },
+            &waveform,
+        ),
+        (
+            "test_file_stereo_dat_128spp_square_bars_offset.png",
+            RenderOptions {
+                start_time: 0.5,
+                style: RenderStyle::Bars {
+                    width: 8,
+                    gap: 4,
+                    style: audiowaveform::BarStyle::Square,
+                },
+                ..RenderOptions::default()
+            },
+            &waveform,
+        ),
+        (
+            "test_file_2channel_8bit_64spp_wav.png",
+            RenderOptions::default(),
+            &two_channel,
+        ),
+        (
+            "test_file_2channel_8bit_64spp_wav_bars.png",
+            RenderOptions {
+                style: RenderStyle::Bars {
+                    width: 8,
+                    gap: 4,
+                    style: audiowaveform::BarStyle::Square,
+                },
+                ..RenderOptions::default()
+            },
+            &two_channel,
+        ),
+    ];
+
+    for (fixture, options, source) in cases {
+        let image = render_waveform(source, &options).expect("render image");
+        assert_png_image_matches_fixture(&image, fixture);
+    }
+}
+
+#[test]
+fn renders_waveforms_with_custom_colors() {
+    let waveform = load_waveform("test_file_stereo_8bit_64spp_wav.dat")
+        .resample(ScaleSpec::SamplesPerPixel(128))
+        .expect("resample waveform");
+    let audition = render_waveform(
+        &waveform,
+        &RenderOptions {
+            colors: ColorScheme::Audition.palette(),
+            ..RenderOptions::default()
+        },
+    )
+    .expect("render audition waveform");
+    assert_png_image_matches_fixture(&audition, "test_file_stereo_dat_128spp_audition.png");
+
+    let custom = render_waveform(
+        &waveform,
+        &RenderOptions {
+            colors: WaveformColors {
+                border: Color::opaque(255, 0, 0),
+                background: Color::rgba(0, 255, 0, 128),
+                waveform: vec![Color::opaque(0, 0, 255)],
+                axis_label: Color::opaque(255, 255, 255),
+            },
+            ..RenderOptions::default()
+        },
+    )
+    .expect("render custom waveform");
+    assert_png_image_matches_fixture(&custom, "test_file_stereo_dat_128spp_colors.png");
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn renders_audio_pipeline_waveform_images() {
+    let stereo = generate_waveform_from_path(
+        support::fixture_path("test_file_stereo.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(128),
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate stereo waveform");
+    let stereo_image = render_waveform(&stereo, &RenderOptions::default()).expect("render stereo");
+    assert_png_image_matches_fixture(&stereo_image, "test_file_stereo_wav_128spp.png");
+
+    let split = generate_waveform_from_path(
+        support::fixture_path("test_file_stereo.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::SamplesPerPixel(128),
+            split_channels: true,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate split waveform");
+    let split_image = render_waveform(
+        &split,
+        &RenderOptions {
+            colors: WaveformColors {
+                border: Color::opaque(255, 0, 0),
+                background: Color::rgba(0, 255, 0, 128),
+                waveform: vec![Color::opaque(0, 0, 255), Color::opaque(0, 0, 128)],
+                axis_label: Color::opaque(255, 255, 255),
+            },
+            ..RenderOptions::default()
+        },
+    )
+    .expect("render split waveform");
+    assert_png_image_matches_fixture(&split_image, "test_file_stereo_wav_split_channels.png");
+}
+
+#[cfg(all(feature = "format-wav", feature = "format-mp3"))]
+#[test]
+fn renders_fit_width_waveform_images_from_audio() {
+    let wav = generate_waveform_from_path(
+        support::fixture_path("test_file_stereo.wav"),
+        &GenerateOptions {
+            scale: ScaleSpec::FitWidth {
+                width_pixels: 500,
+                time_range: None,
+            },
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate fit-width wav");
+    let wav_image = render_waveform(
+        &wav,
+        &RenderOptions {
+            width: 500,
+            height: 150,
+            ..RenderOptions::default()
+        },
+    )
+    .expect("render fit-width wav");
+    assert_png_image_matches_fixture(&wav_image, "test_file_stereo_wav_500.png");
+
+    let mp3 = generate_waveform_from_path(
+        support::fixture_path("test_file_stereo.mp3"),
+        &GenerateOptions {
+            scale: ScaleSpec::FitWidth {
+                width_pixels: 500,
+                time_range: None,
+            },
+            split_channels: false,
+            amplitude_scale: None,
+        },
+    )
+    .expect("generate fit-width mp3");
+    let mp3_image = render_waveform(
+        &mp3,
+        &RenderOptions {
+            width: 500,
+            height: 150,
+            ..RenderOptions::default()
+        },
+    )
+    .expect("render fit-width mp3");
+    assert_png_image_matches_fixture(&mp3_image, "test_file_stereo_mp3_500.png");
+}
+
+#[test]
+fn renders_reference_images_for_amplitude_scale_fixtures() {
+    let single = load_waveform("test_file_image_amplitude_scale_1channel.dat")
+        .resample(ScaleSpec::SamplesPerPixel(64))
+        .expect("resample single");
+    let single_image = render_waveform(&single, &RenderOptions::default()).expect("render single");
+    assert_png_image_matches_fixture(
+        &single_image,
+        "test_file_image_amplitude_scale_1channel.png",
+    );
+
+    let dual = load_waveform("test_file_image_amplitude_scale_2channel.dat")
+        .resample(ScaleSpec::SamplesPerPixel(64))
+        .expect("resample dual");
+    let dual_image = render_waveform(&dual, &RenderOptions::default()).expect("render dual");
+    assert_png_image_matches_fixture(&dual_image, "test_file_image_amplitude_scale_2channel.png");
+}

data/crates/audiowaveform/tests/support/mod.rs

@@ -0,0 +1,125 @@
+#![allow(dead_code)]
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+use audiowaveform::Waveform;
+#[cfg(feature = "wav-output")]
+use hound::WavReader;
+use image::{RgbaImage, load_from_memory};
+use tempfile::{Builder, NamedTempFile};
+
+pub fn fixture_path(name: &str) -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../fixtures")
+        .join(name)
+}
+
+pub fn read_fixture(name: &str) -> Vec<u8> {
+    fs::read(fixture_path(name)).expect("fixture bytes")
+}
+
+pub fn load_waveform(name: &str) -> Waveform {
+    Waveform::load_from_path(fixture_path(name), None).expect("load waveform fixture")
+}
+
+pub fn named_temp_file(suffix: &str) -> NamedTempFile {
+    Builder::new()
+        .suffix(suffix)
+        .tempfile()
+        .expect("create temp file")
+}
+
+pub fn assert_bytes_eq(actual: &[u8], fixture: &str) {
+    assert_eq!(actual, read_fixture(fixture), "fixture mismatch: {fixture}");
+}
+
+pub fn assert_file_bytes_eq(actual: impl AsRef<Path>, fixture: &str) {
+    let actual = fs::read(actual).expect("read output file");
+    assert_bytes_eq(&actual, fixture);
+}
+
+#[cfg(feature = "wav-output")]
+pub fn assert_wav_file_matches_fixture(
+    actual: impl AsRef<Path>,
+    fixture: &str,
+    sample_tolerance: i16,
+) {
+    let actual = WavReader::open(actual).expect("open actual wav");
+    let expected = WavReader::open(fixture_path(fixture)).expect("open expected wav");
+    assert_wav_eq(actual, expected, fixture, sample_tolerance);
+}
+
+pub fn assert_png_bytes_match_fixture(actual: &[u8], fixture: &str) {
+    let actual = load_from_memory(actual)
+        .expect("decode actual png")
+        .into_rgba8();
+    assert_png_image_matches_fixture(&actual, fixture);
+}
+
+pub fn assert_png_file_matches_fixture(actual: impl AsRef<Path>, fixture: &str) {
+    let actual = image::open(actual).expect("open actual png").into_rgba8();
+    assert_png_image_matches_fixture(&actual, fixture);
+}
+
+pub fn assert_png_image_matches_fixture(actual: &RgbaImage, fixture: &str) {
+    let expected = image::open(fixture_path(fixture))
+        .expect("open expected png")
+        .into_rgba8();
+    assert_eq!(
+        actual.dimensions(),
+        expected.dimensions(),
+        "png dimensions mismatch for {fixture}"
+    );
+    assert_eq!(
+        actual.as_raw(),
+        expected.as_raw(),
+        "png pixels mismatch for {fixture}"
+    );
+}
+
+#[cfg(feature = "wav-output")]
+fn assert_wav_eq<R1: std::io::Read, R2: std::io::Read>(
+    mut actual: WavReader<R1>,
+    mut expected: WavReader<R2>,
+    fixture: &str,
+    sample_tolerance: i16,
+) {
+    assert_eq!(
+        actual.spec(),
+        expected.spec(),
+        "wav spec mismatch for {fixture}"
+    );
+    assert_eq!(
+        actual.duration(),
+        expected.duration(),
+        "wav duration mismatch for {fixture}"
+    );
+
+    let actual_samples = actual
+        .samples::<i16>()
+        .collect::<Result<Vec<_>, _>>()
+        .expect("read actual wav samples");
+    let expected_samples = expected
+        .samples::<i16>()
+        .collect::<Result<Vec<_>, _>>()
+        .expect("read expected wav samples");
+
+    assert_eq!(
+        actual_samples.len(),
+        expected_samples.len(),
+        "wav sample count mismatch for {fixture}"
+    );
+
+    for (index, (actual, expected)) in actual_samples
+        .iter()
+        .zip(expected_samples.iter())
+        .enumerate()
+    {
+        let difference = i32::from(*actual) - i32::from(*expected);
+        assert!(
+            difference.abs() <= i32::from(sample_tolerance),
+            "wav sample mismatch for {fixture} at index {index}: actual={actual}, expected={expected}, tolerance={sample_tolerance}"
+        );
+    }
+}

data/crates/audiowaveform/tests/wav.rs

@@ -0,0 +1,54 @@
+#![cfg(feature = "wav-output")]
+
+mod support;
+
+use std::io::Cursor;
+
+use audiowaveform::{PcmAudio, write_pcm_as_wav};
+
+#[cfg(feature = "format-mp3")]
+use self::support::{assert_wav_file_matches_fixture, fixture_path, named_temp_file};
+
+#[test]
+fn writes_empty_wav_header_for_empty_pcm() {
+    let pcm = PcmAudio::new(44_100, 1, Vec::new()).expect("pcm");
+    let mut wav = Vec::new();
+    write_pcm_as_wav(&pcm, &mut wav).expect("write wav");
+
+    assert_eq!(wav.len(), 44);
+}
+
+#[test]
+fn writes_expected_pcm_wav_structure() {
+    let pcm = PcmAudio::new(44_100, 1, vec![0; 1024]).expect("pcm");
+    let mut wav = Vec::new();
+    write_pcm_as_wav(&pcm, &mut wav).expect("write wav");
+
+    assert_eq!(wav.len(), 44 + 1024 * 2);
+
+    let mut reader = hound::WavReader::new(Cursor::new(wav)).expect("open wav");
+    assert_eq!(reader.spec().channels, 1);
+    assert_eq!(reader.spec().sample_rate, 44_100);
+    assert_eq!(reader.spec().bits_per_sample, 16);
+    assert_eq!(reader.duration(), 1024);
+    assert!(
+        reader
+            .samples::<i16>()
+            .all(|sample| sample.expect("sample") == 0)
+    );
+}
+
+#[cfg(feature = "format-mp3")]
+#[test]
+fn transcodes_audio_to_expected_wav_fixture() {
+    let output = named_temp_file(".wav");
+    audiowaveform::transcode_audio_path_to_wav_path(
+        fixture_path("test_file_mono.mp3"),
+        output.path(),
+    )
+    .expect("transcode wav");
+
+    // MP3 decode can differ by a least-significant bit across platforms, so
+    // compare the decoded PCM stream semantically instead of byte-for-byte.
+    assert_wav_file_matches_fixture(output.path(), "test_file_mono_converted.wav", 1);
+}

data/crates/audiowaveform/tests/waveform_io.rs

@@ -0,0 +1,255 @@
+mod support;
+
+use audiowaveform::{Waveform, WaveformFormat};
+use byteorder::{LittleEndian, WriteBytesExt};
+
+use self::support::{assert_bytes_eq, fixture_path, load_waveform, named_temp_file};
+
+#[test]
+fn round_trips_binary_waveform_fixture() {
+    let fixture = fixture_path("test_file_stereo_8bit_64spp_wav.dat");
+    let waveform = Waveform::load_from_path(&fixture, None).expect("load waveform");
+
+    assert_eq!(waveform.sample_rate(), 16_000);
+    assert_eq!(waveform.samples_per_pixel(), 64);
+    assert_eq!(waveform.channels(), 1);
+    assert_eq!(waveform.storage_bits(), 8);
+    assert_eq!(waveform.len(), 1774);
+
+    let mut output = Vec::new();
+    waveform
+        .write_to_writer(&mut output, WaveformFormat::Dat, None)
+        .expect("write dat");
+
+    assert_bytes_eq(&output, "test_file_stereo_8bit_64spp_wav.dat");
+}
+
+#[test]
+fn emits_expected_json_and_text_fixture_bytes() {
+    let fixture = fixture_path("test_file_stereo_8bit_64spp_wav.dat");
+    let waveform = Waveform::load_from_path(&fixture, None).expect("load waveform");
+
+    let mut json = Vec::new();
+    waveform
+        .write_to_writer(&mut json, WaveformFormat::Json, Some(8))
+        .expect("write json");
+    assert_bytes_eq(&json, "test_file_stereo_8bit_64spp_wav.json");
+
+    let mut txt = Vec::new();
+    waveform
+        .write_to_writer(&mut txt, WaveformFormat::Txt, Some(8))
+        .expect("write txt");
+    assert_bytes_eq(&txt, "test_file_stereo_8bit_64spp_wav.txt");
+}
+
+#[test]
+fn loads_version1_and_version2_waveform_fixtures() {
+    let cases = [
+        (
+            "test_file_stereo_8bit_64spp_wav.dat",
+            8_u8,
+            1_u16,
+            1774_usize,
+        ),
+        (
+            "test_file_stereo_8bit_64spp_wav_v2.dat",
+            8_u8,
+            1_u16,
+            1774_usize,
+        ),
+        (
+            "test_file_stereo_16bit_64spp_wav.dat",
+            16_u8,
+            1_u16,
+            1774_usize,
+        ),
+        (
+            "test_file_stereo_16bit_64spp_wav_v2.dat",
+            16_u8,
+            1_u16,
+            1774_usize,
+        ),
+        ("07023003_8bit_64spp_2channel.dat", 8_u8, 2_u16, 513_usize),
+    ];
+
+    for (fixture, bits, channels, length) in cases {
+        let waveform = load_waveform(fixture);
+        let sample_rate = if fixture == "07023003_8bit_64spp_2channel.dat" {
+            44_100
+        } else {
+            16_000
+        };
+        assert_eq!(waveform.sample_rate(), sample_rate, "{fixture}");
+        assert_eq!(waveform.samples_per_pixel(), 64, "{fixture}");
+        assert_eq!(waveform.storage_bits(), bits, "{fixture}");
+        assert_eq!(waveform.channels(), channels, "{fixture}");
+        let expected_length = if fixture == "07023003_8bit_64spp_2channel.dat" {
+            10_438
+        } else {
+            length
+        };
+        assert_eq!(waveform.len(), expected_length, "{fixture}");
+    }
+}
+
+#[test]
+fn loads_zero_length_waveform_fixture() {
+    let waveform = load_waveform("zero_length.dat");
+    assert_eq!(waveform.sample_rate(), 16_000);
+    assert_eq!(waveform.samples_per_pixel(), 64);
+    assert!(waveform.is_empty());
+}
+
+#[test]
+fn loads_truncated_waveform_fixture_using_available_points() {
+    let waveform = load_waveform("size_mismatch.dat");
+    assert_eq!(waveform.sample_rate(), 16_000);
+    assert_eq!(waveform.samples_per_pixel(), 64);
+    assert_eq!(waveform.channels(), 1);
+    assert_eq!(waveform.storage_bits(), 8);
+    assert_eq!(waveform.len(), 1_800);
+}
+
+#[test]
+fn rejects_invalid_waveform_fixtures() {
+    let cases = [
+        ("version3.dat", "Cannot load data file version: 3"),
+        (
+            "sample_rate_too_low.dat",
+            "Invalid sample rate: minimum 1 Hz",
+        ),
+        (
+            "samples_per_pixel_too_low.dat",
+            "Invalid samples per pixel: minimum 2",
+        ),
+        (
+            "too_many_channels.dat",
+            "Invalid channels: must be between 1 and 24",
+        ),
+        (
+            "not_enough_channels.dat",
+            "Invalid channels: must be between 1 and 24",
+        ),
+    ];
+
+    for (fixture, expected) in cases {
+        let error = Waveform::load_from_path(fixture_path(fixture), None).expect_err("invalid dat");
+        assert!(error.to_string().contains(expected), "{fixture}: {}", error);
+    }
+}
+
+#[test]
+fn rejects_dat_channel_counts_that_do_not_fit_the_internal_type() {
+    let mut dat = Vec::new();
+    dat.write_i32::<LittleEndian>(2).expect("version");
+    dat.write_u32::<LittleEndian>(0).expect("flags");
+    dat.write_u32::<LittleEndian>(44_100).expect("sample rate");
+    dat.write_u32::<LittleEndian>(256)
+        .expect("samples per pixel");
+    dat.write_u32::<LittleEndian>(0).expect("length");
+    dat.write_i32::<LittleEndian>(65_537).expect("channels");
+
+    let error = Waveform::load_from_reader(dat.as_slice(), WaveformFormat::Dat)
+        .expect_err("out-of-range channel count");
+    assert_eq!(
+        error.to_string(),
+        "Invalid channels: must be between 1 and 24"
+    );
+}
+
+#[test]
+fn rejects_invalid_json_waveform_payloads() {
+    let error = Waveform::load_from_reader(
+        br#"{"version":2,"channels":1,"sample_rate":44100,"samples_per_pixel":256,"bits":8,"length":2,"data":[1,2,3]}"#
+            .as_slice(),
+        WaveformFormat::Json,
+    )
+    .expect_err("json length mismatch");
+    assert_eq!(
+        error.to_string(),
+        "Length mismatch: expected 4 values, found 3"
+    );
+
+    let error = Waveform::load_from_reader(
+        br#"{"version":2,"channels":1,"sample_rate":44100,"samples_per_pixel":256,"bits":8,"length":1,"data":[999,0]}"#
+            .as_slice(),
+        WaveformFormat::Json,
+    )
+    .expect_err("json range mismatch");
+    assert_eq!(error.to_string(), "Data value out of range: 999");
+
+    let overflowing_length = format!(
+        r#"{{"version":2,"channels":1,"sample_rate":44100,"samples_per_pixel":256,"bits":8,"length":{},"data":[]}}"#,
+        usize::MAX
+    );
+    let error = Waveform::load_from_reader(overflowing_length.as_bytes(), WaveformFormat::Json)
+        .expect_err("overflowing json length");
+    assert_eq!(error.to_string(), "Waveform length is too large");
+}
+
+#[test]
+fn saves_empty_waveform_as_header_only_dat_file() {
+    let waveform = Waveform::new(44_100, 256, 1).expect("new waveform");
+    let mut dat = Vec::new();
+    waveform
+        .write_to_writer(&mut dat, WaveformFormat::Dat, None)
+        .expect("write dat");
+    assert_eq!(dat.len(), 20);
+}
+
+#[test]
+fn writes_expected_text_and_json_for_two_channel_waveforms() {
+    let waveform = load_waveform("07023003_8bit_64spp_2channel.dat");
+
+    let mut json = Vec::new();
+    waveform
+        .write_to_writer(&mut json, WaveformFormat::Json, Some(8))
+        .expect("write json");
+    assert_bytes_eq(&json, "07023003_8bit_64spp_2channel.json");
+
+    let mut txt = Vec::new();
+    waveform
+        .write_to_writer(&mut txt, WaveformFormat::Txt, Some(8))
+        .expect("write txt");
+    assert_bytes_eq(&txt, "07023003_8bit_64spp_2channel.txt");
+}
+
+#[test]
+fn saves_waveform_to_path_and_reloads_it() {
+    let waveform = load_waveform("test_file_stereo_8bit_64spp_wav.dat");
+    let file = named_temp_file(".dat");
+    waveform
+        .save_to_path(file.path(), Some(WaveformFormat::Dat))
+        .expect("save waveform");
+
+    let reloaded =
+        Waveform::load_from_path(file.path(), Some(WaveformFormat::Dat)).expect("reload waveform");
+    assert_eq!(reloaded, waveform);
+}
+
+#[test]
+fn rejects_invalid_storage_bits_and_txt_loading() {
+    let waveform = load_waveform("test_file_stereo_8bit_64spp_wav.dat");
+
+    let error = waveform
+        .write_to_writer(Vec::new(), WaveformFormat::Dat, Some(10))
+        .expect_err("invalid bits");
+    assert_eq!(error.to_string(), "Invalid bits: must be either 8 or 16");
+
+    let error = Waveform::load_from_reader(b"-1,1\n".as_slice(), WaveformFormat::Txt)
+        .expect_err("txt input unsupported");
+    assert_eq!(error.to_string(), "Unsupported format: txt");
+}
+
+#[test]
+fn rescales_waveforms_to_a_coarser_scale() {
+    let waveform = load_waveform("test_file_stereo_8bit_64spp_wav.dat");
+    let resampled = waveform
+        .resample(audiowaveform::ScaleSpec::SamplesPerPixel(128))
+        .expect("resample");
+
+    assert_eq!(resampled.sample_rate(), 16_000);
+    assert_eq!(resampled.samples_per_pixel(), 128);
+    assert_eq!(resampled.channels(), 1);
+    assert_eq!(resampled.len(), 887);
+}