audiowaveform 0.1.0

data/bindings/ruby/README.md

@@ -0,0 +1,193 @@
+# audiowaveform for Ruby
+
+The `audiowaveform` gem provides native Ruby bindings for the Rust
+`audiowaveform` library. It generates waveform data in process without invoking
+the command-line program. Audio decoding runs without Ruby's global VM lock, so
+other Ruby threads can continue while a waveform is generated.
+
+## Installation
+
+Add the gem to your bundle:
+
+```ruby
+gem "audiowaveform", "~> 0.1"
+```
+
+Releases include precompiled gems for CRuby 3.2, 3.3, 3.4, and 4.0 on these platforms:
+
+| OS | Architectures | Gem platforms |
+| --- | --- | --- |
+| Linux (glibc) | x86-64, ARM64 | `x86_64-linux-gnu`, `aarch64-linux-gnu` |
+| Linux (musl/Alpine) | x86-64, ARM64 | `x86_64-linux-musl`, `aarch64-linux-musl` |
+| macOS | Intel, Apple Silicon | `x86_64-darwin`, `arm64-darwin` |
+| Windows (UCRT) | x86-64 | `x64-mingw-ucrt` |
+
+Precompiled gems do not require Rust, FFmpeg, or compilation during installation.
+They contain a separate extension for each supported Ruby minor version.
+Other Ruby versions and platforms fall back to the source gem, which needs Rust
+and Ruby development headers. Installing directly from GitHub also builds from
+source. JRuby and TruffleRuby are not supported.
+
+## Usage
+
+Generate waveform data from an audio file:
+
+```ruby
+require "audiowaveform"
+
+waveform = AudioWaveform.generate(
+  "recording.mp3",
+  samples_per_pixel: 256,
+  split_channels: false
+)
+
+waveform.sample_rate       # => 44_100
+waveform.samples_per_pixel # => 256
+waveform.channels          # => 1
+waveform.length            # => number of waveform points per channel
+waveform.data              # => interleaved [min, max, ...] samples
+```
+
+`AudioWaveform.generate` accepts these keyword arguments:
+
+| Keyword | Default | Description |
+| --- | --- | --- |
+| `samples_per_pixel` | `256` | Number of source samples represented by each waveform point. Must be at least 2. |
+| `pixels_per_second` | none | Time-based scale. Cannot be combined with `samples_per_pixel`. |
+| `split_channels` | `false` | Preserve separate audio channels instead of mixing them down. |
+| `amplitude_scale` | none | Non-negative numeric multiplier, or `:auto` to normalize automatically. |
+
+The returned `AudioWaveform::Waveform` exposes:
+
+| Method | Result |
+| --- | --- |
+| `sample_rate` | Source sample rate in hertz. |
+| `samples_per_pixel` | Source samples represented by each waveform point. |
+| `channels` | Number of waveform channels. |
+| `storage_bits` / `bits` | Internal sample resolution, either 8 or 16. |
+| `length` / `size` | Number of waveform points per channel. |
+| `empty?` | Whether the waveform contains no points. |
+| `duration` / `duration_seconds` | Approximate duration in seconds. |
+| `data` | Interleaved minimum and maximum sample values. |
+| `point(index, channel: 0)` | `[minimum, maximum]` pair for one point and channel. |
+
+Save the generated waveform as binary DAT, JSON, or text:
+
+```ruby
+waveform.save("recording.dat", bits: 8)
+waveform.save("recording.json", bits: 16)
+waveform.save("recording.waveform", format: :txt)
+
+json = waveform.to_json(bits: 8)
+binary = waveform.to_dat(bits: 16)
+text = waveform.to_txt(bits: 8)
+```
+
+`bits` must be 8 or 16. `save` infers the format from a `.dat`, `.json`, or
+`.txt` extension unless `format:` is provided explicitly. Invalid generation
+or serialization options raise `ArgumentError`; an out-of-range `point` raises
+`IndexError`; decoding and file I/O failures raise `AudioWaveform::Error`.
+
+Use `pixels_per_second` instead of `samples_per_pixel` when a time-based scale
+is more convenient:
+
+```ruby
+waveform = AudioWaveform.generate("recording.flac", pixels_per_second: 100)
+```
+
+Amplitude can be scaled with a numeric multiplier or normalized automatically:
+
+```ruby
+AudioWaveform.generate("quiet.wav", amplitude_scale: 1.5)
+AudioWaveform.generate("quiet.wav", amplitude_scale: :auto)
+```
+
+Both source and precompiled gems enable the Rust library's `all-formats` feature:
+AAC-LC/ADTS, AAC-LC and ALAC in M4A/MP4, MP1/MP2/MP3, WAV/W64 (PCM and ADPCM),
+FLAC, Ogg (Vorbis and FLAC), AIFF, CAF (PCM and ALAC), and supported audio tracks
+in Matroska/WebM. No FFmpeg installation is required for decoding.
+
+AAC-LC supports mono and stereo. HE-AAC and Opus remain unsupported, including
+Opus inside Ogg/WebM/MP4. Raw PCM input is not currently exposed by the gem.
+The filename extension identifies the container; an enabled container can still
+contain an unsupported codec. Such files raise `AudioWaveform::Error`.
+AAC/MP4 waveform duration can include encoder delay and padding; gapless
+trimming is not currently supported.
+
+## Development
+
+From the repository root:
+
+```sh
+bundle install
+bundle exec rake
+bundle exec rake build
+```
+
+Gem packages are written to the repository root's `pkg/` directory. To build a
+native gem for the current Ruby and platform, use `bundle exec rake native gem`.
+For the same multi-version build used in CI, install Docker and run:
+
+```sh
+bundle exec rb-sys-dock --platform x86_64-linux --ruby-versions 3.2,3.3,3.4,4.0 --build
+```
+
+The Linux build targets `x86_64-linux` and `aarch64-linux` produce explicitly
+tagged `-linux-gnu` gems, so RubyGems can distinguish glibc from musl.
+The rb_sys version pinned in the root Gemfile selects the cross-compilation image.
+
+## Releasing to RubyGems
+
+The gem has its own semantic version, independent of the Rust library. Releases
+use `ruby-vX.Y.Z` tags and [the Ruby Gem Release workflow](../../.github/workflows/ruby-release.yml).
+Each release runs the Ruby tests, builds a source gem and seven platform gems,
+installs and exercises every native gem on all four supported Ruby versions, and
+publishes the validated artifacts to RubyGems and a GitHub release.
+
+### One-time setup
+
+1. Create a GitHub environment named `release` in `Antti/audiowaveform`, allowing
+   deployments only from tags matching `ruby-v*`.
+2. Sign in to the RubyGems account that will own `audiowaveform`, with MFA enabled.
+   For the first release, create a **pending trusted publisher** from your profile.
+   For an existing gem you own, use its **Trusted publishers** page.
+3. Configure these exact values:
+
+   | Field | Value |
+   | --- | --- |
+   | Gem name (pending publisher) | `audiowaveform` |
+   | Repository owner | `Antti` |
+   | Repository name | `audiowaveform` |
+   | Workflow filename | `ruby-release.yml` |
+   | Environment | `release` |
+
+   Leave the optional reusable-workflow repository fields empty: publishing
+   happens directly in `ruby-release.yml`. No RubyGems API-key secret is needed.
+   Pending publishers expire after 12 hours, so create one shortly before the
+   first release; recreate it if it expires before the first successful push.
+   See the [RubyGems Trusted Publishing guide](https://guides.rubygems.org/trusted-publishing/).
+
+### Each release
+
+1. Update `bindings/ruby/lib/audiowaveform/version.rb` and the [Ruby changelog](CHANGELOG.md).
+   Refresh the local Bundler lockfile with `bundle install` after changing the version.
+2. Run `bundle exec rake` and `bundle exec rake build`, then commit and merge the
+   release preparation. The source gem is `pkg/audiowaveform-X.Y.Z.gem`.
+3. Optionally run **Ruby Gem Release** manually on that commit. Manual runs build
+   and test all packages without publishing, including when run against a tag.
+4. Tag the release commit and push the tag to the project repository:
+
+   ```sh
+   git tag -a ruby-vX.Y.Z -m "Release Ruby gem X.Y.Z"
+   git push antti ruby-vX.Y.Z
+   ```
+
+   Replace `X.Y.Z` with the gem version, and `antti` with your remote name if different.
+   The workflow rejects a tag that does not match the Ruby version file.
+5. Check that the release workflow succeeds and all eight artifacts are visible
+   on RubyGems and the GitHub release.
+
+If publishing fails partway through, rerun the failed job using the same artifacts.
+It skips previously uploaded gems only when their SHA-256 checksums match. A
+different artifact under the same version/platform is rejected; release a new
+version instead. Do not move an existing release tag.

data/bindings/ruby/ext/audiowaveform/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "audiowaveform-ruby"
+version = "0.1.0"
+edition = "2024"
+authors = ["Andrii Dmytrenko", "BBC Research and Development"]
+license = "GPL-3.0-or-later"
+repository = "https://github.com/Antti/audiowaveform"
+publish = false
+
+[lib]
+name = "audiowaveform_ruby"
+crate-type = ["cdylib"]
+
+[dependencies]
+audiowaveform-core = { package = "audiowaveform", path = "../../../../crates/audiowaveform", default-features = false, features = ["all-formats"] }
+magnus = { version = "0.8.2", features = ["rb-sys"] }
+rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback", "global-allocator"] }
+
+[build-dependencies]
+rb-sys-env = "0.2.2"

data/bindings/ruby/ext/audiowaveform/build.rs

@@ -0,0 +1,4 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    rb_sys_env::activate()?;
+    Ok(())
+}

data/bindings/ruby/ext/audiowaveform/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("audiowaveform/audiowaveform_ruby")

data/bindings/ruby/ext/audiowaveform/src/lib.rs

@@ -0,0 +1,239 @@
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::panic::{AssertUnwindSafe, catch_unwind};
+use std::{ffi::c_void, ptr};
+
+use audiowaveform_core::{
+    AmplitudeScale, Error as CoreError, GenerateOptions, ScaleSpec, Waveform, WaveformFormat,
+    generate_waveform_from_path,
+};
+use magnus::{
+    DataTypeFunctions, Error, ExceptionClass, Module, Object, RString, Ruby, TypedData, function,
+    method, rb_sys::protect,
+};
+
+#[derive(TypedData)]
+#[magnus(class = "AudioWaveform::Waveform", free_immediately, size)]
+struct RubyWaveform(Waveform);
+
+impl DataTypeFunctions for RubyWaveform {
+    fn size(&self) -> usize {
+        std::mem::size_of_val(self) + self.0.allocated_bytes()
+    }
+}
+
+struct NoGvlTask<F, T> {
+    function: Option<F>,
+    result: Option<T>,
+    panicked: bool,
+}
+
+unsafe extern "C" fn call_without_gvl<F, T>(data: *mut c_void) -> *mut c_void
+where
+    F: FnOnce() -> T,
+{
+    // SAFETY: `data` points to a live `NoGvlTask` for the duration of the
+    // synchronous `rb_thread_call_without_gvl` call, and Ruby cannot access it.
+    let task = unsafe { &mut *data.cast::<NoGvlTask<F, T>>() };
+    let Some(function) = task.function.take() else {
+        return ptr::null_mut();
+    };
+    match catch_unwind(AssertUnwindSafe(function)) {
+        Ok(result) => task.result = Some(result),
+        Err(_) => task.panicked = true,
+    }
+    ptr::null_mut()
+}
+
+fn without_gvl<F, T>(ruby: &Ruby, function: F) -> Result<T, Error>
+where
+    F: FnOnce() -> T,
+{
+    let mut task = NoGvlTask {
+        function: Some(function),
+        result: None,
+        panicked: false,
+    };
+    // Ruby can raise while checking interrupts before or after the callback.
+    // Keep the task outside `protect` so its closure/result is dropped normally
+    // even when Ruby exits the protected call with a non-local jump.
+    protect(|| {
+        // SAFETY: the callback only accesses the live stack-allocated task,
+        // does not invoke Ruby methods, and catches Rust panics before they
+        // cross the C ABI boundary. rb-sys tracks its allocations for Ruby GC.
+        unsafe {
+            rb_sys::rb_thread_call_without_gvl(
+                Some(call_without_gvl::<F, T>),
+                (&mut task as *mut NoGvlTask<F, T>).cast(),
+                None,
+                ptr::null_mut(),
+            );
+        }
+        rb_sys::Qnil as rb_sys::VALUE
+    })?;
+
+    if task.panicked {
+        Err(ruby_error(
+            ruby,
+            "native waveform operation failed unexpectedly",
+        ))
+    } else {
+        task.result
+            .ok_or_else(|| ruby_error(ruby, "native waveform operation did not complete"))
+    }
+}
+
+impl RubyWaveform {
+    fn sample_rate(&self) -> u32 {
+        self.0.sample_rate()
+    }
+
+    fn samples_per_pixel(&self) -> u32 {
+        self.0.samples_per_pixel()
+    }
+
+    fn channels(&self) -> u16 {
+        self.0.channels()
+    }
+
+    fn storage_bits(&self) -> u8 {
+        self.0.storage_bits()
+    }
+
+    fn length(&self) -> usize {
+        self.0.len()
+    }
+
+    fn empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    fn duration(&self) -> f64 {
+        self.0.duration_seconds()
+    }
+
+    fn data(&self) -> Vec<i16> {
+        self.0.interleaved_samples().to_vec()
+    }
+
+    fn point(&self, channel: u16, index: usize) -> Option<(i16, i16)> {
+        self.0
+            .point(channel, index)
+            .map(|point| (point.min, point.max))
+    }
+
+    fn save(
+        ruby: &Ruby,
+        waveform: &Self,
+        path: String,
+        format: String,
+        bits: u8,
+    ) -> Result<(), Error> {
+        let format = parse_format(ruby, &format)?;
+        let result = without_gvl(ruby, || -> Result<(), CoreError> {
+            let file = File::create(path)?;
+            let mut writer = BufWriter::new(file);
+            waveform
+                .0
+                .write_to_writer(&mut writer, format, Some(bits))?;
+            writer.flush()?;
+            Ok(())
+        })?;
+        result.map_err(|error| core_error(ruby, error))
+    }
+
+    fn serialize(ruby: &Ruby, waveform: &Self, format: String, bits: u8) -> Result<RString, Error> {
+        let format = parse_format(ruby, &format)?;
+        let result = without_gvl(ruby, || {
+            let mut bytes = Vec::new();
+            waveform
+                .0
+                .write_to_writer(&mut bytes, format, Some(bits))
+                .map(|()| bytes)
+        })?;
+        let bytes = result.map_err(|error| core_error(ruby, error))?;
+        Ok(ruby.str_from_slice(&bytes))
+    }
+}
+
+fn generate(
+    ruby: &Ruby,
+    input: String,
+    scale_kind: String,
+    scale_value: u32,
+    split_channels: bool,
+    amplitude_kind: String,
+    amplitude_value: f64,
+) -> Result<RubyWaveform, Error> {
+    let scale = match scale_kind.as_str() {
+        "samples_per_pixel" => ScaleSpec::SamplesPerPixel(scale_value),
+        "pixels_per_second" => ScaleSpec::PixelsPerSecond(scale_value),
+        _ => return Err(argument_error(ruby, "unsupported waveform scale")),
+    };
+    let amplitude_scale = match amplitude_kind.as_str() {
+        "none" => None,
+        "auto" => Some(AmplitudeScale::Auto),
+        "fixed" => Some(AmplitudeScale::Fixed(amplitude_value)),
+        _ => return Err(argument_error(ruby, "unsupported amplitude scale")),
+    };
+    let options = GenerateOptions {
+        scale,
+        split_channels,
+        amplitude_scale,
+    };
+
+    without_gvl(ruby, || generate_waveform_from_path(input, &options))?
+        .map(RubyWaveform)
+        .map_err(|error| core_error(ruby, error))
+}
+
+fn parse_format(ruby: &Ruby, format: &str) -> Result<WaveformFormat, Error> {
+    format
+        .parse()
+        .map_err(|error: CoreError| core_error(ruby, error))
+}
+
+fn core_error(ruby: &Ruby, error: CoreError) -> Error {
+    if matches!(error, CoreError::InvalidArgument { .. }) {
+        argument_error(ruby, error.to_string())
+    } else {
+        ruby_error(ruby, error.to_string())
+    }
+}
+
+fn argument_error(ruby: &Ruby, message: impl AsRef<str>) -> Error {
+    Error::new(ruby.exception_arg_error(), message.as_ref().to_owned())
+}
+
+fn ruby_error(ruby: &Ruby, message: impl AsRef<str>) -> Error {
+    let error_class = ruby
+        .eval::<ExceptionClass>("AudioWaveform::Error")
+        .unwrap_or_else(|_| ruby.exception_standard_error());
+    Error::new(error_class, message.as_ref().to_owned())
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("AudioWaveform")?;
+    module.define_error("Error", ruby.exception_standard_error())?;
+
+    let native = module.define_module("Native")?;
+    native.define_singleton_method("generate", function!(generate, 6))?;
+
+    let waveform = module.define_class("Waveform", ruby.class_object())?;
+    waveform.define_method("sample_rate", method!(RubyWaveform::sample_rate, 0))?;
+    waveform.define_method(
+        "samples_per_pixel",
+        method!(RubyWaveform::samples_per_pixel, 0),
+    )?;
+    waveform.define_method("channels", method!(RubyWaveform::channels, 0))?;
+    waveform.define_method("storage_bits", method!(RubyWaveform::storage_bits, 0))?;
+    waveform.define_method("length", method!(RubyWaveform::length, 0))?;
+    waveform.define_method("empty?", method!(RubyWaveform::empty, 0))?;
+    waveform.define_method("duration", method!(RubyWaveform::duration, 0))?;
+    waveform.define_method("data", method!(RubyWaveform::data, 0))?;
+    waveform.define_private_method("__point", method!(RubyWaveform::point, 2))?;
+    waveform.define_private_method("__save", method!(RubyWaveform::save, 3))?;
+    waveform.define_private_method("__serialize", method!(RubyWaveform::serialize, 2))?;
+    Ok(())
+}

data/bindings/ruby/lib/audiowaveform/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AudioWaveform
+  VERSION = "0.1.0"
+end

data/bindings/ruby/lib/audiowaveform.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "audiowaveform/version"
+require "rbconfig"
+
+# Platform gems contain one extension per Ruby minor version. Source builds put
+# the extension directly under audiowaveform/.
+native_extension = File.join(
+  __dir__, "audiowaveform", RUBY_VERSION[/\A\d+\.\d+/],
+  "audiowaveform_ruby.#{RbConfig::CONFIG.fetch('DLEXT')}"
+)
+if File.file?(native_extension)
+  require native_extension
+else
+  require "audiowaveform/audiowaveform_ruby"
+end
+
+module AudioWaveform
+  class << self
+    # Generates waveform data from an audio file.
+    def generate(
+      input,
+      samples_per_pixel: nil,
+      pixels_per_second: nil,
+      split_channels: false,
+      amplitude_scale: nil
+    )
+      scale_kind, scale_value = resolve_scale(samples_per_pixel, pixels_per_second)
+      amplitude_kind, amplitude_value = resolve_amplitude_scale(amplitude_scale)
+
+      Native.generate(
+        File.path(input),
+        scale_kind,
+        scale_value,
+        !!split_channels,
+        amplitude_kind,
+        amplitude_value
+      )
+    end
+
+    private
+
+    def resolve_scale(samples_per_pixel, pixels_per_second)
+      if samples_per_pixel && pixels_per_second
+        raise ArgumentError, "samples_per_pixel and pixels_per_second are mutually exclusive"
+      end
+
+      if pixels_per_second
+        ["pixels_per_second", positive_integer(pixels_per_second, :pixels_per_second)]
+      else
+        value = samples_per_pixel || 256
+        ["samples_per_pixel", positive_integer(value, :samples_per_pixel, minimum: 2)]
+      end
+    end
+
+    def resolve_amplitude_scale(value)
+      return ["none", 0.0] if value.nil?
+      return ["auto", 0.0] if value == :auto || value == "auto"
+
+      numeric = Float(value)
+      unless numeric.finite? && numeric >= 0.0
+        raise ArgumentError, "amplitude_scale must be a finite non-negative number or :auto"
+      end
+
+      ["fixed", numeric]
+    rescue TypeError, ArgumentError
+      raise ArgumentError, "amplitude_scale must be a finite non-negative number or :auto"
+    end
+
+    def positive_integer(value, name, minimum: 1)
+      unless value.is_a?(Integer) && value >= minimum
+        raise ArgumentError, "#{name} must be an integer greater than or equal to #{minimum}"
+      end
+
+      value
+    end
+  end
+
+  class Waveform
+    private_class_method :new
+
+    alias size length
+    alias bits storage_bits
+    alias duration_seconds duration
+
+    # Returns the [minimum, maximum] pair at +index+ for +channel+.
+    def point(index, channel: 0)
+      unless index.is_a?(Integer) && index.between?(0, length - 1) &&
+          channel.is_a?(Integer) && channel.between?(0, channels - 1)
+        raise IndexError, "waveform point is outside the available channel or index range"
+      end
+
+      value = __point(channel, index)
+      return value if value
+
+      raise IndexError, "waveform point is outside the available channel or index range"
+    end
+
+    # Writes waveform data to +path+ and returns self.
+    def save(path, format: nil, bits: storage_bits)
+      resolved_format = format || File.extname(File.path(path)).delete_prefix(".")
+      __save(File.path(path), resolved_format.to_s, validate_bits(bits))
+      self
+    end
+
+    # Returns binary DAT waveform data.
+    def to_dat(bits: storage_bits)
+      __serialize("dat", validate_bits(bits))
+    end
+
+    # Returns JSON waveform data.
+    def to_json(*, bits: storage_bits)
+      __serialize("json", validate_bits(bits)).force_encoding(Encoding::UTF_8)
+    end
+
+    # Returns plain-text waveform data.
+    def to_txt(bits: storage_bits)
+      __serialize("txt", validate_bits(bits)).force_encoding(Encoding::UTF_8)
+    end
+
+    private
+
+    def validate_bits(bits)
+      return bits if bits == 8 || bits == 16
+
+      raise ArgumentError, "bits must be either 8 or 16"
+    end
+  end
+
+  private_constant :Native
+end

data/crates/audiowaveform/Cargo.toml

@@ -0,0 +1,73 @@
+[package]
+name = "audiowaveform"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+authors.workspace = true
+description = "Audio waveform generation, serialization, rendering, and transcoding library"
+
+[[example]]
+name = "generate_waveform"
+required-features = ["format-mp3"]
+
+[[example]]
+name = "render_waveform"
+required-features = ["render"]
+
+[[example]]
+name = "generate_from_pcm"
+
+[[example]]
+name = "resample_waveform"
+
+[[test]]
+name = "generate"
+required-features = ["decode"]
+
+[[test]]
+name = "render"
+required-features = ["render"]
+
+[[test]]
+name = "wav"
+required-features = ["wav-output"]
+
+[features]
+default = []
+decode = ["dep:symphonia"]
+all-formats = ["format-aac", "format-aiff", "format-caf", "format-flac", "format-m4a", "format-mkv", "format-mp1", "format-mp2", "format-mp3", "format-ogg", "format-wav"]
+format-aac = ["decode", "symphonia/aac"]
+format-aiff = ["decode", "symphonia/aiff", "symphonia/pcm"]
+format-caf = ["decode", "symphonia/caf", "symphonia/alac", "symphonia/pcm"]
+format-flac = ["decode", "symphonia/flac"]
+format-m4a = ["decode", "symphonia/isomp4", "symphonia/aac", "symphonia/alac", "symphonia/mp3", "symphonia/pcm"]
+format-mp4 = ["format-m4a"]
+format-mkv = ["decode", "symphonia/mkv", "symphonia/aac", "symphonia/flac", "symphonia/mpa", "symphonia/pcm", "symphonia/vorbis"]
+format-webm = ["format-mkv"]
+format-mp1 = ["decode", "symphonia/mp1"]
+format-mp2 = ["decode", "symphonia/mp2"]
+format-mp3 = ["decode", "symphonia/mp3"]
+format-ogg = ["decode", "symphonia/ogg", "symphonia/vorbis", "symphonia/flac"]
+format-wav = ["decode", "symphonia/wav", "symphonia/pcm", "symphonia/adpcm"]
+render = ["dep:image", "dep:png"]
+wav-output = ["dep:hound"]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[dependencies]
+byteorder.workspace = true
+hound = { workspace = true, optional = true }
+image = { workspace = true, optional = true }
+png = { workspace = true, optional = true }
+serde.workspace = true
+serde_json.workspace = true
+symphonia = { workspace = true, optional = true }
+thiserror.workspace = true
+
+[dev-dependencies]
+assert_cmd.workspace = true
+image.workspace = true
+predicates.workspace = true
+tempfile.workspace = true