audiowaveform 0.1.0

data/crates/audiowaveform-cli/tests/cli.rs

@@ -0,0 +1,483 @@
+mod support;
+
+use assert_cmd::Command;
+#[cfg(feature = "format-wav")]
+use audiowaveform::Waveform;
+use predicates::prelude::*;
+
+#[cfg(all(feature = "format-mp3", feature = "wav-output"))]
+use self::support::assert_wav_file_matches_fixture;
+#[cfg(any(
+    feature = "format-wav",
+    feature = "format-m4a",
+    feature = "render",
+    all(feature = "format-mp3", feature = "wav-output")
+))]
+use self::support::fixture_path;
+#[cfg(any(
+    feature = "format-wav",
+    feature = "render",
+    all(feature = "format-mp3", feature = "wav-output")
+))]
+use self::support::named_temp_file;
+use self::support::read_fixture;
+#[cfg(feature = "render")]
+use self::support::{assert_png_bytes_match_fixture, assert_png_file_matches_fixture};
+
+#[test]
+fn prints_help_and_version() {
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .arg("--help")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("Usage: audiowaveform [OPTIONS]"))
+        .stdout(predicate::str::contains(
+            "Generate waveform data and images from audio",
+        ));
+
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .arg("--version")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains("AudioWaveform v"));
+}
+
+#[test]
+fn requires_input_and_output_configuration() {
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .assert()
+        .failure()
+        .stderr("Error: Must specify either input filename or input format\n");
+
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args(["--input-format", "wav"])
+        .assert()
+        .failure()
+        .stderr("Error: Must specify either output filename or output format\n");
+}
+
+#[test]
+fn rejects_invalid_enum_values_via_clap() {
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args(["--colors", "test"])
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains("invalid value 'test'"))
+        .stderr(predicate::str::contains("possible values"));
+}
+
+#[cfg(feature = "render")]
+#[test]
+fn rejects_non_finite_numeric_values() {
+    let input = fixture_path("test_file_stereo_8bit_64spp_wav.dat");
+    let input = input.to_str().expect("utf8");
+
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-q",
+            "-i",
+            input,
+            "--output-format",
+            "png",
+            "-z",
+            "64",
+            "--start",
+            "inf",
+        ])
+        .assert()
+        .failure()
+        .stderr("Invalid start time: minimum 0\n");
+
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-q",
+            "-i",
+            input,
+            "--output-format",
+            "png",
+            "-z",
+            "64",
+            "--amplitude-scale",
+            "NaN",
+        ])
+        .assert()
+        .failure()
+        .stderr("Error: Invalid amplitude scale: must be a positive number\n");
+}
+
+#[test]
+fn rejects_raw_channel_counts_that_do_not_fit_the_library_type() {
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-q",
+            "--input-format",
+            "raw",
+            "--output-format",
+            "wav",
+            "--raw-samplerate",
+            "48000",
+            "--raw-channels",
+            "65537",
+            "--raw-format",
+            "s16le",
+        ])
+        .assert()
+        .failure()
+        .stderr("Invalid number of input channels: maximum 65535\n");
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn generates_dat_output_to_file_and_stdout() {
+    let output = named_temp_file(".dat");
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-i",
+            fixture_path("test_file_stereo.wav").to_str().expect("utf8"),
+            "-o",
+            output.path().to_str().expect("utf8"),
+            "-b",
+            "8",
+            "-z",
+            "64",
+        ])
+        .assert()
+        .success()
+        .stderr("Done\n");
+    assert_eq!(
+        std::fs::read(output.path()).expect("read output"),
+        read_fixture("test_file_stereo_8bit_64spp_wav.dat")
+    );
+
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "--input-format",
+            "wav",
+            "--output-format",
+            "dat",
+            "-b",
+            "8",
+            "-z",
+            "64",
+        ])
+        .write_stdin(read_fixture("test_file_stereo.wav"))
+        .assert()
+        .success()
+        .stdout(read_fixture("test_file_stereo_8bit_64spp_wav.dat"))
+        .stderr("Done\n");
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn generates_json_and_text_outputs_to_stdout() {
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "--input-format",
+            "wav",
+            "--output-format",
+            "json",
+            "-b",
+            "8",
+            "-z",
+            "64",
+        ])
+        .write_stdin(read_fixture("test_file_stereo.wav"))
+        .assert()
+        .success()
+        .stdout(read_fixture("test_file_stereo_8bit_64spp_wav.json"))
+        .stderr("Done\n");
+
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-i",
+            fixture_path("test_file_stereo_8bit_64spp_wav.dat")
+                .to_str()
+                .expect("utf8"),
+            "--output-format",
+            "txt",
+        ])
+        .assert()
+        .success()
+        .stdout(read_fixture("test_file_stereo_8bit_64spp_wav.txt"))
+        .stderr("Done\n");
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn applies_fixed_amplitude_scaling_to_waveform_data_output() {
+    let unscaled_output = named_temp_file(".json");
+    let scaled_output = named_temp_file(".json");
+
+    for (output, amplitude_scale) in [(&unscaled_output, "1.0"), (&scaled_output, "2.0")] {
+        Command::cargo_bin("audiowaveform")
+            .expect("binary")
+            .args([
+                "-q",
+                "-i",
+                fixture_path("test_file_stereo.wav").to_str().expect("utf8"),
+                "-o",
+                output.path().to_str().expect("utf8"),
+                "-z",
+                "64",
+                "--amplitude-scale",
+                amplitude_scale,
+            ])
+            .assert()
+            .success();
+    }
+
+    let unscaled = Waveform::load_from_path(unscaled_output.path(), None).expect("unscaled");
+    let scaled = Waveform::load_from_path(scaled_output.path(), None).expect("scaled");
+    let expected = unscaled
+        .interleaved_samples()
+        .iter()
+        .map(|value| (i32::from(*value) * 2).clamp(i32::from(i16::MIN), i32::from(i16::MAX)) as i16)
+        .collect::<Vec<_>>();
+
+    assert_eq!(scaled.interleaved_samples(), expected);
+}
+
+#[cfg(feature = "render")]
+#[test]
+fn generates_png_output_to_file_and_stdout() {
+    let output = named_temp_file(".png");
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-i",
+            fixture_path("test_file_stereo_8bit_64spp_wav.dat")
+                .to_str()
+                .expect("utf8"),
+            "-o",
+            output.path().to_str().expect("utf8"),
+            "-z",
+            "128",
+        ])
+        .assert()
+        .success()
+        .stderr("Done\n");
+    assert_png_file_matches_fixture(output.path(), "test_file_stereo_dat_128spp.png");
+
+    let output = Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-i",
+            fixture_path("test_file_stereo_8bit_64spp_wav.dat")
+                .to_str()
+                .expect("utf8"),
+            "--output-format",
+            "png",
+            "-z",
+            "128",
+        ])
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    assert_png_bytes_match_fixture(&output, "test_file_stereo_dat_128spp.png");
+}
+
+#[cfg(all(feature = "format-mp3", feature = "wav-output"))]
+#[test]
+fn transcodes_audio_to_wav_output() {
+    let output = named_temp_file(".wav");
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-i",
+            fixture_path("test_file_mono.mp3").to_str().expect("utf8"),
+            "-o",
+            output.path().to_str().expect("utf8"),
+            "--output-format",
+            "wav",
+        ])
+        .assert()
+        .success()
+        .stderr("Done\n");
+
+    assert_wav_file_matches_fixture(output.path(), "test_file_mono_converted.wav", 1);
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn quiet_mode_suppresses_done_output() {
+    let output = named_temp_file(".dat");
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-q",
+            "-i",
+            fixture_path("test_file_stereo.wav").to_str().expect("utf8"),
+            "-o",
+            output.path().to_str().expect("utf8"),
+            "-b",
+            "8",
+            "-z",
+            "64",
+        ])
+        .assert()
+        .success()
+        .stderr("");
+}
+
+#[cfg(feature = "format-wav")]
+#[test]
+fn rejects_unsupported_output_combinations() {
+    Command::cargo_bin("audiowaveform")
+        .expect("binary")
+        .args([
+            "-i",
+            fixture_path("test_file_stereo.wav").to_str().expect("utf8"),
+            "--output-format",
+            "mp3",
+        ])
+        .assert()
+        .failure()
+        .stderr("Can't generate mp3 format output from wav format input\n");
+}
+
+#[test]
+fn converts_waveform_data_and_raw_pcm_without_optional_features() {
+    Command::cargo_bin("audiowaveform")
+        .unwrap()
+        .args(["-q", "--input-format", "dat", "--output-format", "txt"])
+        .write_stdin(read_fixture("test_file_stereo_8bit_64spp_wav.dat"))
+        .assert()
+        .success()
+        .stdout(read_fixture("test_file_stereo_8bit_64spp_wav.txt"));
+
+    let output = Command::cargo_bin("audiowaveform")
+        .unwrap()
+        .args([
+            "-q",
+            "--input-format",
+            "raw",
+            "--raw-samplerate",
+            "16000",
+            "--raw-channels",
+            "1",
+            "--raw-format",
+            "s16le",
+            "--output-format",
+            "dat",
+            "-b",
+            "8",
+            "-z",
+            "64",
+        ])
+        .write_stdin(read_fixture("test_file_mono.raw"))
+        .assert()
+        .success()
+        .get_output()
+        .stdout
+        .clone();
+    let waveform = audiowaveform::Waveform::load_from_reader(
+        std::io::Cursor::new(output),
+        audiowaveform::WaveformFormat::Dat,
+    )
+    .unwrap();
+    assert_eq!(waveform.sample_rate(), 16_000);
+    assert_eq!(waveform.channels(), 1);
+    assert_eq!(waveform.storage_bits(), 8);
+    assert_eq!(
+        waveform.len(),
+        read_fixture("test_file_mono.raw").len().div_ceil(2 * 64)
+    );
+}
+
+#[test]
+fn reports_disabled_formats_before_creating_output_files() {
+    for (format, enabled, feature) in [
+        ("mp3", cfg!(feature = "format-mp3"), "format-mp3"),
+        ("m4a", cfg!(feature = "format-m4a"), "format-m4a"),
+        ("wav", cfg!(feature = "format-wav"), "format-wav"),
+        ("webm", cfg!(feature = "format-mkv"), "format-mkv"),
+    ] {
+        if enabled {
+            continue;
+        }
+        let directory = tempfile::tempdir().unwrap();
+        let output = directory.path().join("output.json");
+        Command::cargo_bin("audiowaveform")
+            .unwrap()
+            .args([
+                "-q",
+                "--input-format",
+                format,
+                "-o",
+                output.to_str().unwrap(),
+            ])
+            .assert()
+            .failure()
+            .stderr(predicate::str::contains(format!(
+                "enable the `{feature}` Cargo feature"
+            )));
+        assert!(!output.exists());
+    }
+}
+
+#[test]
+fn reports_disabled_output_features() {
+    for (format, enabled, feature) in [
+        ("png", cfg!(feature = "render"), "render"),
+        ("wav", cfg!(feature = "wav-output"), "wav-output"),
+    ] {
+        if enabled {
+            continue;
+        }
+        Command::cargo_bin("audiowaveform")
+            .unwrap()
+            .args(["--input-format", "dat", "--output-format", format])
+            .assert()
+            .failure()
+            .stderr(predicate::str::contains(format!(
+                "enable the `{feature}` Cargo feature"
+            )));
+    }
+}
+
+#[cfg(feature = "format-m4a")]
+#[test]
+fn generates_waveforms_from_m4a_paths_and_mp4_stdin() {
+    for fixture in [
+        "formats/stereo.m4a",
+        "formats/alac.m4a",
+        "formats/video-first.mp4",
+    ] {
+        let path_output = Command::cargo_bin("audiowaveform")
+            .unwrap()
+            .args([
+                "-q",
+                "-i",
+                fixture_path(fixture).to_str().unwrap(),
+                "--output-format",
+                "json",
+            ])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone();
+        assert!(String::from_utf8_lossy(&path_output).contains("48000"));
+        Command::cargo_bin("audiowaveform")
+            .unwrap()
+            .args(["-q", "--input-format", "m4a", "--output-format", "json"])
+            .write_stdin(read_fixture(fixture))
+            .assert()
+            .success()
+            .stdout(path_output);
+    }
+}

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

@@ -0,0 +1,111 @@
+#![allow(dead_code)]
+
+use std::fs;
+use std::path::{Path, PathBuf};
+
+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 named_temp_file(suffix: &str) -> NamedTempFile {
+    Builder::new()
+        .suffix(suffix)
+        .tempfile()
+        .expect("create temp file")
+}
+
+pub fn assert_png_file_matches_fixture(actual: impl AsRef<Path>, fixture: &str) {
+    let actual = image::open(actual).expect("open actual png").into_rgba8();
+    let expected = image::open(fixture_path(fixture))
+        .expect("open expected png")
+        .into_rgba8();
+    assert_png_eq(&actual, &expected, fixture);
+}
+
+pub fn assert_png_bytes_match_fixture(actual: &[u8], fixture: &str) {
+    let actual = load_from_memory(actual)
+        .expect("decode actual png")
+        .into_rgba8();
+    let expected = image::open(fixture_path(fixture))
+        .expect("open expected png")
+        .into_rgba8();
+    assert_png_eq(&actual, &expected, fixture);
+}
+
+fn assert_png_eq(actual: &RgbaImage, expected: &RgbaImage, fixture: &str) {
+    assert_eq!(
+        actual.dimensions(),
+        expected.dimensions(),
+        "png dimensions mismatch for {fixture}"
+    );
+    assert_eq!(
+        actual.as_raw(),
+        expected.as_raw(),
+        "png pixels mismatch for {fixture}"
+    );
+}
+
+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);
+}
+
+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/sig/audiowaveform.rbs

@@ -0,0 +1,33 @@
+module AudioWaveform
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  def self.generate: (
+    path input,
+    ?samples_per_pixel: Integer?,
+    ?pixels_per_second: Integer?,
+    ?split_channels: bool,
+    ?amplitude_scale: (Numeric | :auto | String)?
+  ) -> Waveform
+
+  class Waveform
+    def sample_rate: () -> Integer
+    def samples_per_pixel: () -> Integer
+    def channels: () -> Integer
+    def storage_bits: () -> Integer
+    def bits: () -> Integer
+    def length: () -> Integer
+    def size: () -> Integer
+    def empty?: () -> bool
+    def duration: () -> Float
+    def duration_seconds: () -> Float
+    def data: () -> Array[Integer]
+    def point: (Integer index, ?channel: Integer) -> [Integer, Integer]
+    def save: (path path, ?format: (String | Symbol)?, ?bits: Integer) -> self
+    def to_dat: (?bits: Integer) -> String
+    def to_json: (*untyped arguments, ?bits: Integer) -> String
+    def to_txt: (?bits: Integer) -> String
+  end
+end