muze 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 852274e098d5ea8d512680e8dbcf9962b8e380ce778c51912d5efa77cf5d4427
+  data.tar.gz: 4e49c534ea90ca6d01c1a3e37ca88e975db1a404a59b37288f8397642b71a7a5
+SHA512:
+  metadata.gz: 874a8d2467e25523dd91361a41b299b7c8e9dfec8bd22def1f382795026ce28b7aa086f19eb8ffc7616c25f90e60471c909c2a777c3f4bc8fced6ba1fbf8c65a
+  data.tar.gz: c4d63ca9bd4a35ff74e34eec358a03e3c3c5dd15dd03589debbb00c97c02d1719849ca883149afd984f76065bed8377678af88e2297832eaddab43d8dad3b970

data/.yardopts

@@ -0,0 +1,4 @@
+--markup markdown
+--output-dir doc
+lib/**/*.rb
+README.md

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## [0.1.0] - 2026-03-07
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# Muze
+
+Muze is a Ruby audio feature extraction library that provides a full pipeline from audio loading to spectral analysis, feature extraction, rhythm analysis, effects, and lightweight visualization.
+
+![Image](https://github.com/user-attachments/assets/1e88395b-c715-4c9a-b458-d1cb9fceb848)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "muze"
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install muze
+```
+
+## Quick Start
+
+```ruby
+require "muze"
+
+y, sr = RAF.load("sample.wav", sr: 22_050)
+mel = RAF.melspectrogram(y:, sr:)
+mfcc = RAF.mfcc(y:, sr:, n_mfcc: 13)
+tempo, beats = RAF.beat_track(y:, sr:)
+RAF.specshow(Muze.power_to_db(mel), output: "mel.svg")
+```
+
+## Main Features
+
+| Area | APIs |
+| --- | --- |
+| Audio I/O | `RAF.load` (`wav`, `flac`, `mp3`, `ogg`) |
+| STFT stack | `RAF.stft`, `RAF.istft`, `RAF.magphase` |
+| Scale helpers | `RAF.power_to_db`, `RAF.amplitude_to_db` |
+| Filters | `RAF.mel`, `RAF.chroma` |
+| Features | `RAF.melspectrogram`, `RAF.mfcc`, `RAF.delta` |
+| Spectral descriptors | centroid, bandwidth, rolloff, flatness, contrast, zcr, rms |
+| Rhythm | `RAF.onset_strength`, `RAF.onset_detect`, `RAF.beat_track`, `RAF.tempogram` |
+| Effects | `RAF.hpss`, `RAF.time_stretch`, `RAF.pitch_shift`, `RAF.trim` |
+| Visualization | `RAF.specshow`, `RAF.waveshow` |
+
+`wav` is loaded with `wavify`, and `flac/mp3/ogg` requires `ffmpeg` + `ffprobe`
+available on `PATH`.
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+```
+
+Benchmark and regression check:
+
+```bash
+bundle exec rake bench
+```
+
+This writes a JSON report to `benchmarks/reports/latest.json` and compares metrics
+against `benchmarks/baseline.json`. To refresh the baseline:
+
+```bash
+MUZE_BENCH_UPDATE_BASELINE=1 bundle exec rake bench
+```
+
+Quality regression thresholds for effects are documented in
+`benchmarks/quality_thresholds.md`.
+
+Optional native extension:
+
+```bash
+bundle exec rake compile
+```
+
+Generate API docs:
+
+```bash
+bundle exec yard doc
+```
+
+## License
+
+Muze is available under the [MIT License](./LICENSE.txt).

data/Rakefile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/clean"
+require_relative "benchmarks/quality_metrics"
+
+RSpec::Core::RakeTask.new(:spec)
+
+directory "ext/muze"
+
+desc "Compile optional C extension"
+task :compile do
+  Dir.chdir("ext/muze") do
+    ruby "extconf.rb"
+    sh "make"
+  end
+end
+
+desc "Run quality/performance benchmarks and compare with baseline"
+task :bench do
+  Muze::Benchmarks::QualityMetrics.run(
+    output_path: ENV.fetch("MUZE_BENCH_OUTPUT", Muze::Benchmarks::QualityMetrics::DEFAULT_OUTPUT_PATH),
+    baseline_path: ENV.fetch("MUZE_BENCH_BASELINE", Muze::Benchmarks::QualityMetrics::DEFAULT_BASELINE_PATH),
+    fail_on_regression: ENV.fetch("MUZE_BENCH_FAIL_ON_REGRESSION", "1") != "0",
+    update_baseline: ENV.fetch("MUZE_BENCH_UPDATE_BASELINE", "0") == "1"
+  )
+end
+
+task default: :spec

data/benchmarks/baseline.json

@@ -0,0 +1,24 @@
+{
+  "generated_at": "2026-03-05T08:25:13Z",
+  "ruby_version": "4.0.0",
+  "metrics": {
+    "istft_reconstruction_error": {
+      "value": 0.014255197813810787,
+      "unit": "rmse",
+      "direction": "lower",
+      "max_regression_ratio": 1.2
+    },
+    "time_stretch_processing_seconds": {
+      "value": 0.0018263333218379153,
+      "unit": "seconds_per_fixture",
+      "direction": "lower",
+      "max_regression_ratio": 4.0
+    },
+    "pitch_shift_processing_seconds": {
+      "value": 0.0046148888973726165,
+      "unit": "seconds_per_fixture",
+      "direction": "lower",
+      "max_regression_ratio": 4.0
+    }
+  }
+}

data/benchmarks/native_vs_ruby.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require_relative "../lib/muze"
+
+signal = Array.new(200_000) { rand(-1.0..1.0) }
+values = Array.new(255) { rand }
+
+puts "Native extension loaded: #{Muze::Native.extension_loaded?}"
+
+Benchmark.bm(24) do |x|
+  x.report("frame_slices") do
+    20.times { Muze::Native.frame_slices(signal, 2048, 512) }
+  end
+
+  x.report("median1d") do
+    2000.times { Muze::Native.median1d(values) }
+  end
+
+  x.report("sinc_resample") do
+    10.times { Muze.resample(signal, orig_sr: 44_100, target_sr: 22_050, res_type: :sinc) }
+  end
+end

data/benchmarks/quality_metrics.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "optparse"
+require "time"
+
+require_relative "../lib/muze"
+require_relative "support/fixture_library"
+
+module Muze
+  module Benchmarks
+    # Quality and performance benchmark runner with baseline comparison.
+    module QualityMetrics
+      module_function
+
+      DEFAULT_OUTPUT_PATH = "benchmarks/reports/latest.json"
+      DEFAULT_BASELINE_PATH = "benchmarks/baseline.json"
+      DEFAULT_ITERATIONS = 3
+
+      METRIC_DEFINITIONS = {
+        "istft_reconstruction_error" => {
+          unit: "rmse",
+          direction: "lower",
+          max_regression_ratio: 1.20
+        },
+        "time_stretch_processing_seconds" => {
+          unit: "seconds_per_fixture",
+          direction: "lower",
+          max_regression_ratio: 4.00
+        },
+        "pitch_shift_processing_seconds" => {
+          unit: "seconds_per_fixture",
+          direction: "lower",
+          max_regression_ratio: 4.00
+        }
+      }.freeze
+
+      # @param output_path [String]
+      # @param baseline_path [String]
+      # @param fail_on_regression [Boolean]
+      # @param update_baseline [Boolean]
+      # @return [Hash]
+      def run(output_path:, baseline_path:, fail_on_regression:, update_baseline:)
+        fixtures = Muze::Benchmarks::FixtureLibrary.build
+        metrics = collect_metrics(fixtures)
+        baseline_metrics = load_baseline_metrics(baseline_path)
+        regressions = detect_regressions(metrics, baseline_metrics)
+
+        report = {
+          generated_at: Time.now.utc.iso8601,
+          ruby_version: RUBY_VERSION,
+          ruby_platform: RUBY_PLATFORM,
+          fixture_names: fixtures.keys,
+          baseline_path: baseline_path,
+          metrics: metrics,
+          regressions: regressions
+        }
+
+        write_json(output_path, report)
+        update_baseline_file(baseline_path, metrics) if update_baseline
+
+        if fail_on_regression && !regressions.empty?
+          raise Muze::Error, format_regression_error(regressions)
+        end
+
+        report
+      end
+
+      # @param fixtures [Hash{String => Numo::SFloat}]
+      # @return [Hash]
+      def collect_metrics(fixtures)
+        {
+          "istft_reconstruction_error" => metric_entry(
+            value: average_istft_error(fixtures),
+            definition: METRIC_DEFINITIONS.fetch("istft_reconstruction_error")
+          ),
+          "time_stretch_processing_seconds" => metric_entry(
+            value: average_runtime_per_fixture(fixtures) { |signal| Muze.time_stretch(signal, rate: 1.25) },
+            definition: METRIC_DEFINITIONS.fetch("time_stretch_processing_seconds")
+          ),
+          "pitch_shift_processing_seconds" => metric_entry(
+            value: average_runtime_per_fixture(fixtures) { |signal| Muze.pitch_shift(signal, sr: 22_050, n_steps: 4.0) },
+            definition: METRIC_DEFINITIONS.fetch("pitch_shift_processing_seconds")
+          )
+        }
+      end
+      private_class_method :collect_metrics
+
+      # @param value [Float]
+      # @param definition [Hash]
+      # @return [Hash]
+      def metric_entry(value:, definition:)
+        {
+          value: value,
+          unit: definition.fetch(:unit),
+          direction: definition.fetch(:direction),
+          max_regression_ratio: definition.fetch(:max_regression_ratio)
+        }
+      end
+      private_class_method :metric_entry
+
+      # @param fixtures [Hash{String => Numo::SFloat}]
+      # @return [Float]
+      def average_istft_error(fixtures)
+        errors = fixtures.values.map do |signal|
+          stft_matrix = Muze.stft(signal, n_fft: 1024, hop_length: 256)
+          reconstructed = Muze.istft(stft_matrix, hop_length: 256, length: signal.size)
+          delta = signal - reconstructed
+          Math.sqrt((delta * delta).mean.to_f)
+        end
+
+        errors.sum / errors.size.to_f
+      end
+      private_class_method :average_istft_error
+
+      # @param fixtures [Hash{String => Numo::SFloat}]
+      # @yieldparam signal [Numo::SFloat]
+      # @return [Float]
+      def average_runtime_per_fixture(fixtures)
+        fixtures.each_value { |signal| yield(signal) }
+        elapsed = measure_elapsed do
+          DEFAULT_ITERATIONS.times do
+            fixtures.each_value { |signal| yield(signal) }
+          end
+        end
+
+        elapsed / (DEFAULT_ITERATIONS.to_f * fixtures.size)
+      end
+      private_class_method :average_runtime_per_fixture
+
+      # @yieldreturn [void]
+      # @return [Float]
+      def measure_elapsed
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      end
+      private_class_method :measure_elapsed
+
+      # @param baseline_path [String]
+      # @return [Hash]
+      def load_baseline_metrics(baseline_path)
+        return {} unless File.exist?(baseline_path)
+
+        baseline_json = JSON.parse(File.read(baseline_path))
+        baseline_json.fetch("metrics", {})
+      rescue JSON::ParserError
+        {}
+      end
+      private_class_method :load_baseline_metrics
+
+      # @param current_metrics [Hash]
+      # @param baseline_metrics [Hash]
+      # @return [Array<Hash>]
+      def detect_regressions(current_metrics, baseline_metrics)
+        current_metrics.filter_map do |metric_name, current|
+          baseline = baseline_metrics[metric_name]
+          next unless baseline
+
+          baseline_value = baseline.fetch("value").to_f
+          ratio = current.fetch(:max_regression_ratio)
+          max_allowed_value = baseline_value * ratio
+          current_value = current.fetch(:value)
+          next unless current_value > max_allowed_value
+
+          {
+            metric: metric_name,
+            baseline_value: baseline_value,
+            current_value: current_value,
+            max_allowed_value: max_allowed_value,
+            max_regression_ratio: ratio
+          }
+        end
+      end
+      private_class_method :detect_regressions
+
+      # @param path [String]
+      # @param report [Hash]
+      # @return [void]
+      def write_json(path, report)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(report))
+      end
+      private_class_method :write_json
+
+      # @param baseline_path [String]
+      # @param metrics [Hash]
+      # @return [void]
+      def update_baseline_file(baseline_path, metrics)
+        FileUtils.mkdir_p(File.dirname(baseline_path))
+        payload = {
+          generated_at: Time.now.utc.iso8601,
+          ruby_version: RUBY_VERSION,
+          metrics: metrics.transform_values do |entry|
+            {
+              value: entry.fetch(:value),
+              unit: entry.fetch(:unit),
+              direction: entry.fetch(:direction),
+              max_regression_ratio: entry.fetch(:max_regression_ratio)
+            }
+          end
+        }
+        File.write(baseline_path, JSON.pretty_generate(payload))
+      end
+      private_class_method :update_baseline_file
+
+      # @param regressions [Array<Hash>]
+      # @return [String]
+      def format_regression_error(regressions)
+        lines = regressions.map do |regression|
+          format(
+            "%<metric>s regressed: current=%<current>.8f baseline=%<baseline>.8f limit=%<limit>.8f (x%<ratio>.2f)",
+            metric: regression.fetch(:metric),
+            current: regression.fetch(:current_value),
+            baseline: regression.fetch(:baseline_value),
+            limit: regression.fetch(:max_allowed_value),
+            ratio: regression.fetch(:max_regression_ratio)
+          )
+        end
+
+        "Benchmark regression detected:\n#{lines.join("\n")}"
+      end
+      private_class_method :format_regression_error
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  options = {
+    output_path: Muze::Benchmarks::QualityMetrics::DEFAULT_OUTPUT_PATH,
+    baseline_path: Muze::Benchmarks::QualityMetrics::DEFAULT_BASELINE_PATH,
+    fail_on_regression: false,
+    update_baseline: false
+  }
+
+  OptionParser.new do |opts|
+    opts.banner = "Usage: ruby benchmarks/quality_metrics.rb [options]"
+
+    opts.on("--output PATH", "Output JSON path (default: #{options[:output_path]})") do |path|
+      options[:output_path] = path
+    end
+
+    opts.on("--baseline PATH", "Baseline JSON path (default: #{options[:baseline_path]})") do |path|
+      options[:baseline_path] = path
+    end
+
+    opts.on("--fail-on-regression", "Exit with non-zero code on baseline regression") do
+      options[:fail_on_regression] = true
+    end
+
+    opts.on("--update-baseline", "Write current metrics into baseline JSON") do
+      options[:update_baseline] = true
+    end
+  end.parse!
+
+  begin
+    report = Muze::Benchmarks::QualityMetrics.run(**options)
+    puts "Benchmark report written to #{options[:output_path]}"
+    puts "No regressions detected" if report.fetch(:regressions).empty?
+  rescue Muze::Error => e
+    warn e.message
+    exit(1)
+  end
+end

data/benchmarks/quality_thresholds.md

@@ -0,0 +1,28 @@
+# Effects Quality Regression Thresholds
+
+This document defines thresholds for `time_stretch` and `pitch_shift` regression tests.
+
+## Signals
+
+- Harmonic: 440Hz + 660Hz mixed sine wave (`2.0s`, `22_050Hz`)
+- Transient: click impulses at fixed timestamps (`2.0s`, `22_050Hz`)
+
+## Thresholds
+
+- `time_stretch` dominant frequency drift:
+  - Condition: `rate=2.0` and `rate=0.5`
+  - Threshold: within `20Hz` from original dominant frequency
+  - Rationale: keeps clear musical pitch identity while allowing FFT-bin granularity error.
+
+- `time_stretch` transient alignment:
+  - Condition: `rate=2.0`
+  - Threshold: each detected click within `256 samples` from expected scaled position
+  - Rationale: catches obvious transient collapse while tolerating local phase vocoder artifacts.
+
+- `pitch_shift` octave peak movement:
+  - Condition: `n_steps=+12`
+  - Threshold: contains peaks near `880Hz` (`±25Hz`) and `1320Hz` (`±35Hz`)
+  - Rationale: verifies octave translation for fundamental + harmonic pair.
+
+These thresholds are intentionally conservative to avoid flaky CI failures while still
+catching meaningful quality regressions.

data/benchmarks/support/fixture_library.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Muze
+  module Benchmarks
+    # Fixture signal builder for quality/performance benchmark runs.
+    module FixtureLibrary
+      module_function
+
+      # @param sample_rate [Integer]
+      # @param duration [Float]
+      # @return [Hash{String => Numo::SFloat}]
+      def build(sample_rate: 22_050, duration: 1.0)
+        sample_count = [(sample_rate * duration).round, 1].max
+
+        sine = sine_wave(
+          sample_rate: sample_rate,
+          sample_count: sample_count,
+          frequency: 440.0,
+          amplitude: 0.8
+        )
+        click = click_track(
+          sample_rate: sample_rate,
+          sample_count: sample_count,
+          interval_seconds: 0.1
+        )
+        simple_mix = mixed_signal(sample_rate:, sample_count:)
+
+        {
+          "sine" => Numo::SFloat.cast(sine),
+          "click" => Numo::SFloat.cast(click),
+          "simple_mix" => Numo::SFloat.cast(simple_mix)
+        }
+      end
+
+      # @param sample_rate [Integer]
+      # @param sample_count [Integer]
+      # @param frequency [Float]
+      # @param amplitude [Float]
+      # @return [Array<Float>]
+      def sine_wave(sample_rate:, sample_count:, frequency:, amplitude:)
+        Array.new(sample_count) do |index|
+          angle = (2.0 * Math::PI * frequency * index) / sample_rate
+          amplitude * Math.sin(angle)
+        end
+      end
+      private_class_method :sine_wave
+
+      # @param sample_rate [Integer]
+      # @param sample_count [Integer]
+      # @param interval_seconds [Float]
+      # @return [Array<Float>]
+      def click_track(sample_rate:, sample_count:, interval_seconds:)
+        click_interval = [(sample_rate * interval_seconds).round, 1].max
+        signal = Array.new(sample_count, 0.0)
+
+        index = 0
+        while index < sample_count
+          signal[index] = 0.95
+          index += click_interval
+        end
+
+        signal
+      end
+      private_class_method :click_track
+
+      # @param sample_rate [Integer]
+      # @param sample_count [Integer]
+      # @return [Array<Float>]
+      def mixed_signal(sample_rate:, sample_count:)
+        low = sine_wave(
+          sample_rate: sample_rate,
+          sample_count: sample_count,
+          frequency: 220.0,
+          amplitude: 0.5
+        )
+        high = sine_wave(
+          sample_rate: sample_rate,
+          sample_count: sample_count,
+          frequency: 880.0,
+          amplitude: 0.35
+        )
+        clicks = click_track(
+          sample_rate: sample_rate,
+          sample_count: sample_count,
+          interval_seconds: 0.2
+        )
+
+        normalize_peak(
+          low.each_with_index.map { |sample, index| sample + high[index] + (0.25 * clicks[index]) }
+        )
+      end
+      private_class_method :mixed_signal
+
+      # @param signal [Array<Float>]
+      # @param target_peak [Float]
+      # @return [Array<Float>]
+      def normalize_peak(signal, target_peak: 0.9)
+        peak = signal.map(&:abs).max.to_f
+        return signal if peak <= 0.0
+
+        scale = target_peak / peak
+        signal.map { |sample| sample * scale }
+      end
+      private_class_method :normalize_peak
+    end
+  end
+end

data/examples/beat_tracking.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Usage: bundle exec ruby examples/beat_tracking.rb path/to/audio.wav
+
+require_relative "../lib/muze"
+
+input_path = ARGV[0]
+abort("Usage: bundle exec ruby examples/beat_tracking.rb path/to/audio.wav") unless input_path
+
+target_sr = 22_050
+n_fft = 1024
+hop_length = 256
+
+y, sr = Muze.load(input_path, sr: target_sr, mono: true)
+onset_envelope = Muze.onset_strength(y:, sr:, hop_length:, n_fft:)
+onset_times = Muze.onset_detect(onset_envelope:, sr:, hop_length:, backtrack: true, units: :time)
+tempo, beat_frames = Muze.beat_track(onset_envelope:, sr:, hop_length:)
+beat_times = beat_frames.map { |frame| (frame * hop_length.to_f) / sr }
+
+puts "Input: #{input_path}"
+puts format("Estimated tempo: %.2f BPM", tempo)
+puts "Detected onsets: #{onset_times.length}"
+puts "Detected beats: #{beat_times.length}"
+puts "First onsets (s): #{onset_times.first(8).map { |time| format('%.3f', time) }.join(', ')}"
+puts "First beats (s): #{beat_times.first(8).map { |time| format('%.3f', time) }.join(', ')}"

data/examples/chroma_svg.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Usage: bundle exec ruby examples/chroma_svg.rb path/to/audio.wav [output.svg]
+
+require "fileutils"
+require_relative "../lib/muze"
+
+note_names = %w[C C# D D# E F F# G G# A A# B].freeze
+input_path = ARGV[0]
+abort("Usage: bundle exec ruby examples/chroma_svg.rb path/to/audio.wav [output.svg]") unless input_path
+
+sample_name = File.basename(input_path, ".*")
+output_path = ARGV[1] || File.expand_path("output/#{sample_name}_chroma.svg", __dir__)
+FileUtils.mkdir_p(File.dirname(output_path))
+
+target_sr = 22_050
+n_fft = 2048
+hop_length = 512
+
+y, sr = Muze.load(input_path, sr: target_sr, mono: true)
+chroma = Muze.chroma_stft(y:, sr:, n_chroma: 12, n_fft:, hop_length:)
+Muze.specshow(chroma, sr:, hop_length:, y_axis: :linear, output: output_path)
+
+pitch_strengths = chroma.to_a.map do |row|
+  row.sum(0.0) / [row.length, 1].max
+end
+dominant_pitch = note_names.fetch(pitch_strengths.each_with_index.max_by(&:first).last)
+
+puts "Input: #{input_path}"
+puts "Chroma shape: #{chroma.shape.join(' x ')}"
+puts "Dominant pitch class: #{dominant_pitch}"
+puts "Wrote: #{output_path}"