wavify 0.1.0 → 0.2.0

data/lib/wavify/sequencer/note_sequence.rb

@@ -28,18 +28,25 @@ module Wavify
       }.freeze
 
       # Parsed note event (`midi_note` is `nil` for rests).
-      Event = Struct.new(:index, :token, :midi_note, keyword_init: true) do
+      Event = Struct.new(:index, :token, :midi_note, :duration_denominator, :duration_multiplier, :tie, keyword_init: true) do
         def rest?
           midi_note.nil?
         end
+
+        def tie?
+          tie
+        end
       end
 
       attr_reader :default_octave, :events, :notation
 
       def initialize(notation, default_octave: 4)
-        @notation = notation
+        raise InvalidNoteError, "note sequence notation must be String" unless notation.is_a?(String)
+
+        @notation = notation.dup.freeze
         @default_octave = validate_default_octave!(default_octave)
-        @events = parse_events(notation).freeze
+        @events = parse_events(@notation).each(&:freeze).freeze
+        freeze
       end
 
       # Enumerates parsed events.
@@ -93,16 +100,47 @@ module Wavify
         raise InvalidNoteError, "note sequence notation must not be empty" if tokens.empty?
 
         tokens.each_with_index.map do |token, index|
-          Event.new(index: index, token: token, midi_note: parse_token(token))
+          midi_note, duration_denominator, duration_multiplier, tie = parse_token(token)
+          Event.new(
+            index: index,
+            token: token,
+            midi_note: midi_note,
+            duration_denominator: duration_denominator,
+            duration_multiplier: duration_multiplier,
+            tie: tie
+          )
         end
       end
 
       def parse_token(token)
-        return nil if token == "."
+        tie = token.end_with?("~")
+        body = tie ? token.delete_suffix("~") : token
+        body, duration_denominator, duration_multiplier = split_duration_suffix(body)
+
+        return [nil, duration_denominator, duration_multiplier, tie] if body == "."
+
+        midi_note = body.match?(/\A-?\d+\z/) ? parse_midi_number(body) : parse_note_name(body)
+        [midi_note, duration_denominator, duration_multiplier, tie]
+      end
+
+      def split_duration_suffix(token)
+        body, denominator = token.split("/", 2)
+        return [body, nil, 1.0] unless denominator
+
+        match = denominator.match(/\A(\d+)([.tT]?)\z/)
+        raise InvalidNoteError, "invalid duration suffix: #{token.inspect}" unless match
 
-        return parse_midi_number(token) if token.match?(/\A-?\d+\z/)
+        value = Integer(match[1])
+        raise InvalidNoteError, "duration denominator must be positive: #{token.inspect}" unless value.positive?
 
-        parse_note_name(token)
+        multiplier = case match[2]
+                     when "." then 1.5
+                     when "t", "T" then 2.0 / 3.0
+                     else 1.0
+                     end
+        [body, value, multiplier]
+      rescue ArgumentError
+        raise InvalidNoteError, "invalid duration suffix: #{token.inspect}"
       end
 
       def parse_midi_number(token)

data/lib/wavify/sequencer/pattern.rb

@@ -2,12 +2,17 @@
 
 module Wavify
   module Sequencer
-    # Step-pattern parser (`x`, `X`, `-`, `.`) for trigger sequencing.
+    # Step-pattern parser (`x`, `X`, `x0.7`, `x?50`, `x:3`, `-`, `.`) for trigger sequencing.
     class Pattern
       include Enumerable
 
+      # Highest supported step-grid resolution per bar.
+      MAX_RESOLUTION = 4_096
+      # Highest supported retrigger count for one pattern step.
+      MAX_RATCHET = 64
+
       # Parsed pattern step value object.
-      Step = Struct.new(:index, :trigger, :accent, :symbol, :velocity, keyword_init: true) do
+      Step = Struct.new(:index, :trigger, :accent, :symbol, :velocity, :probability, :ratchet, keyword_init: true) do
         def rest?
           !trigger
         end
@@ -24,9 +29,15 @@ module Wavify
       attr_reader :resolution, :steps, :notation
 
       def initialize(notation, resolution: 16)
-        @notation = notation
+        raise InvalidPatternError, "pattern notation must be String" unless notation.is_a?(String)
+
+        @notation = notation.dup.freeze
         @resolution = validate_resolution!(resolution)
-        @steps = parse_steps(notation).freeze
+        @steps = parse_steps(@notation).freeze
+        if @steps.length > @resolution
+          raise InvalidPatternError, "pattern has #{@steps.length} steps but resolution is #{@resolution}"
+        end
+        freeze
       end
 
       # Enumerates parsed steps.
@@ -73,7 +84,9 @@ module Wavify
       private
 
       def validate_resolution!(value)
-        raise InvalidPatternError, "resolution must be a positive Integer" unless value.is_a?(Integer) && value.positive?
+        unless value.is_a?(Integer) && value.between?(1, MAX_RESOLUTION)
+          raise InvalidPatternError, "resolution must be an Integer between 1 and #{MAX_RESOLUTION}"
+        end
 
         value
       end
@@ -81,21 +94,117 @@ module Wavify
       def parse_steps(notation)
         raise InvalidPatternError, "pattern notation must be String" unless notation.is_a?(String)
 
-        chars = notation.each_char.reject { |char| char =~ /\s/ || char == "|" }
+        chars = notation.each_char.reject { |char| char =~ /\s/ || char == "|" }.join
         raise InvalidPatternError, "pattern notation must not be empty" if chars.empty?
 
-        chars.each_with_index.map do |char, index|
+        steps = []
+        cursor = 0
+        while cursor < chars.length
+          char = chars[cursor]
+          index = steps.length
+
           case char
-          when "x"
-            Step.new(index: index, trigger: true, accent: false, symbol: char, velocity: 0.8)
-          when "X"
-            Step.new(index: index, trigger: true, accent: true, symbol: char, velocity: 1.0)
+          when "x", "X"
+            cursor += 1
+            velocity_text, cursor = scan_velocity_suffix(chars, cursor)
+            probability, ratchet, cursor = scan_trigger_modifiers(chars, cursor, index)
+            default_velocity = char == "X" ? 1.0 : 0.8
+            velocity = velocity_text ? parse_velocity!(velocity_text, index) : default_velocity
+            steps << Step.new(
+              index: index,
+              trigger: true,
+              accent: char == "X",
+              symbol: char,
+              velocity: velocity,
+              probability: probability,
+              ratchet: ratchet
+            ).freeze
           when "-", "."
-            Step.new(index: index, trigger: false, accent: false, symbol: char, velocity: 0.0)
+            steps << Step.new(
+              index: index, trigger: false, accent: false, symbol: char, velocity: 0.0, probability: 0.0, ratchet: 1
+            ).freeze
+            cursor += 1
           else
             raise InvalidPatternError, "invalid pattern symbol #{char.inspect} at step #{index}"
           end
         end
+
+        steps
+      end
+
+      def scan_velocity_suffix(chars, cursor)
+        return [nil, cursor] unless chars[cursor]&.match?(/\d/)
+
+        start = cursor
+        cursor += 1
+        cursor += 1 while cursor < chars.length && chars[cursor].match?(/\d/)
+        if chars[cursor] == "."
+          cursor += 1
+          cursor += 1 while cursor < chars.length && chars[cursor].match?(/\d/)
+        end
+        [chars[start...cursor], cursor]
+      end
+
+      def scan_trigger_modifiers(chars, cursor, index)
+        probability = 1.0
+        ratchet = 1
+        seen = {}
+
+        while cursor < chars.length && ["?", ":"].include?(chars[cursor])
+          modifier = chars[cursor]
+          raise InvalidPatternError, "duplicate modifier #{modifier.inspect} at step #{index}" if seen[modifier]
+
+          seen[modifier] = true
+          case modifier
+          when "?"
+            text, cursor = scan_numeric_modifier(chars, cursor + 1, "probability", index)
+            probability = parse_probability!(text, index)
+          when ":"
+            text, cursor = scan_numeric_modifier(chars, cursor + 1, "ratchet", index)
+            ratchet = parse_ratchet!(text, index)
+          end
+        end
+
+        [probability, ratchet, cursor]
+      end
+
+      def scan_numeric_modifier(chars, cursor, name, index)
+        start = cursor
+        cursor += 1 while cursor < chars.length && chars[cursor].match?(/\d/)
+        if chars[cursor] == "."
+          cursor += 1
+          cursor += 1 while cursor < chars.length && chars[cursor].match?(/\d/)
+        end
+        raise InvalidPatternError, "missing #{name} value at step #{index}" if start == cursor
+
+        [chars[start...cursor], cursor]
+      end
+
+      def parse_velocity!(text, index)
+        velocity = Float(text)
+        return velocity if velocity.between?(0.0, 1.0)
+
+        raise InvalidPatternError, "velocity must be between 0.0 and 1.0 at step #{index}"
+      rescue ArgumentError
+        raise InvalidPatternError, "invalid velocity #{text.inspect} at step #{index}"
+      end
+
+      def parse_probability!(text, index)
+        probability = Float(text) / 100.0
+        return probability if probability.between?(0.0, 1.0)
+
+        raise InvalidPatternError, "probability must be between 0 and 100 at step #{index}"
+      rescue ArgumentError
+        raise InvalidPatternError, "invalid probability #{text.inspect} at step #{index}"
+      end
+
+      def parse_ratchet!(text, index)
+        ratchet = Integer(text)
+        return ratchet if ratchet.between?(1, MAX_RATCHET)
+
+        raise InvalidPatternError, "ratchet must be between 1 and #{MAX_RATCHET} at step #{index}"
+      rescue ArgumentError
+        raise InvalidPatternError, "invalid ratchet #{text.inspect} at step #{index}"
       end
     end
   end

data/lib/wavify/sequencer/track.rb

@@ -11,7 +11,7 @@ module Wavify
         "MAJ" => [0, 4, 7],
         "MAJ7" => [0, 4, 7, 11],
         "7" => [0, 4, 7, 10],
-        "M7" => [0, 3, 7, 10],
+        "M7" => [0, 4, 7, 11],
         "MIN" => [0, 3, 7],
         "MIN7" => [0, 3, 7, 10],
         "MIN9" => [0, 3, 7, 10, 14],
@@ -37,8 +37,17 @@ module Wavify
         "aug" => [0, 4, 8]
       ).freeze
 
+      SCALE_INTERVALS = {
+        major: [0, 2, 4, 5, 7, 9, 11],
+        minor: [0, 2, 3, 5, 7, 8, 10],
+        chromatic: (0..11).to_a,
+        pentatonic_major: [0, 2, 4, 7, 9],
+        pentatonic_minor: [0, 3, 5, 7, 10]
+      }.freeze
+
       attr_reader :name, :pattern, :note_sequence, :chord_progression, :waveform, :gain_db, :pan_position,
-                  :pattern_resolution, :note_resolution, :default_octave, :envelope, :effects
+                  :pattern_resolution, :note_resolution, :default_octave, :envelope, :effects, :key_root, :scale,
+                  :chord_voicing, :synth_options
 
       def initialize(name, **options)
         @name = validate_name!(name)
@@ -50,14 +59,19 @@ module Wavify
         @note_resolution = validate_resolution!(note_resolution, :note_resolution)
         @default_octave = validate_default_octave!(default_octave)
         @waveform = options.fetch(:waveform, :sine).to_sym
+        @synth_options = validate_synth_options!(options.fetch(:synth_options, {}))
         @gain_db = validate_numeric!(options.fetch(:gain_db, 0.0), :gain_db).to_f
         @pan_position = validate_pan!(options.fetch(:pan_position, 0.0))
         @envelope = validate_envelope!(options[:envelope])
         @effects = validate_effects!(options.fetch(:effects, []))
+        @key_root = normalize_key_root(options[:key])
+        @scale = normalize_scale(options[:scale])
+        @chord_voicing = normalize_chord_voicing(options[:chord_voicing])
 
         @pattern = coerce_pattern(options[:pattern])
         @note_sequence = coerce_note_sequence(options[:note_sequence])
         @chord_progression = coerce_chord_progression(options[:chord_progression])
+        freeze
       end
 
       # Returns a copy with a new pattern.
@@ -86,6 +100,23 @@ module Wavify
         copy(chord_progression: chords, default_octave: default_octave)
       end
 
+      # Returns a copy with scale quantization settings.
+      #
+      # @param key [Symbol, String, nil]
+      # @param scale [Symbol, String, nil]
+      # @return [Track]
+      def with_key(key, scale: @scale)
+        copy(key: key, scale: scale)
+      end
+
+      # Returns a copy with chord voicing settings.
+      #
+      # @param voicing [Symbol, String, nil]
+      # @return [Track]
+      def with_chord_voicing(voicing)
+        copy(chord_voicing: voicing)
+      end
+
       # Returns a copy with a different oscillator waveform.
       #
       # @param waveform [Symbol, String]
@@ -156,13 +187,17 @@ module Wavify
           note_sequence: overrides.fetch(:note_sequence, @note_sequence),
           chord_progression: overrides.fetch(:chord_progression, @chord_progression),
           waveform: overrides.fetch(:waveform, @waveform),
+          synth_options: overrides.fetch(:synth_options, @synth_options),
           gain_db: overrides.fetch(:gain_db, @gain_db),
           pan_position: overrides.fetch(:pan_position, @pan_position),
           pattern_resolution: overrides.fetch(:pattern_resolution, @pattern_resolution),
           note_resolution: overrides.fetch(:note_resolution, @note_resolution),
           default_octave: overrides.fetch(:default_octave, @default_octave),
           envelope: overrides.fetch(:envelope, @envelope),
-          effects: overrides.fetch(:effects, @effects)
+          effects: overrides.fetch(:effects, @effects),
+          key: overrides.fetch(:key, @key_root),
+          scale: overrides.fetch(:scale, @scale),
+          chord_voicing: overrides.fetch(:chord_voicing, @chord_voicing)
         )
       end
 
@@ -190,26 +225,53 @@ module Wavify
       end
 
       def self.parse_chord_token(token, default_octave:)
-        match = token.match(/\A([A-Ga-g])([#b]?)(.*)\z/)
+        chord_token, inline_voicing = token.to_s.split("@", 2)
+        match = chord_token.match(/\A([A-Ga-g])([#b]?)(.*)\z/)
         raise InvalidNoteError, "invalid chord token: #{token.inspect}" unless match
 
         root_name = "#{match[1].upcase}#{match[2]}"
-        suffix = match[3].to_s
+        suffix, bass_name = match[3].to_s.split("/", 2)
         suffix_key = normalize_chord_suffix(suffix)
         intervals = CHORD_INTERVALS[suffix_key] || CHORD_INTERVALS[suffix]
         raise InvalidNoteError, "unsupported chord quality: #{suffix.inspect}" unless intervals
 
         root_midi = NoteSequence.new("#{root_name}#{default_octave}", default_octave: default_octave).midi_notes.first
+        midi_notes = intervals.map { |interval| root_midi + interval }
+        midi_notes = apply_chord_inversion(midi_notes, bass_name, root_midi, default_octave) if bass_name
+        midi_notes = apply_chord_voicing(midi_notes, inline_voicing) if inline_voicing
         {
           token: token,
           root_midi: root_midi,
-          midi_notes: intervals.map { |interval| root_midi + interval }
+          midi_notes: midi_notes
         }
       end
 
+      def self.apply_chord_inversion(midi_notes, bass_name, root_midi, default_octave)
+        bass = NoteSequence.new("#{bass_name}#{default_octave}", default_octave: default_octave).midi_notes.first
+        bass -= 12 while bass > root_midi
+        remaining = midi_notes.reject { |midi| midi % 12 == bass % 12 }
+        [bass, *remaining].sort
+      end
+
+      def self.apply_chord_voicing(midi_notes, voicing)
+        case normalize_chord_voicing(voicing)
+        when nil, :root
+          midi_notes
+        when :open
+          midi_notes.each_with_index.map { |midi, index| index.odd? ? midi + 12 : midi }.sort
+        when :drop2
+          return midi_notes if midi_notes.length < 3
+
+          ordered = midi_notes.sort
+          dropped = ordered.delete_at(-2) - 12
+          [dropped, *ordered].sort
+        end
+      end
+
       def self.normalize_chord_suffix(suffix)
         value = suffix.to_s
         return "" if value.empty?
+        return value.upcase if value.start_with?("M")
 
         if value.start_with?("m") && !value.start_with?("maj")
           "m#{value[1..]}"
@@ -220,6 +282,23 @@ module Wavify
 
       private_class_method :normalize_chord_suffix
 
+      def quantize_midi_note(midi_note)
+        return midi_note unless @key_root && @scale
+
+        self.class.quantize_midi_note(midi_note, key: @key_root, scale: @scale)
+      end
+
+      def self.quantize_midi_note(midi_note, key:, scale:)
+        key_pitch = NoteSequence::NOTE_OFFSETS.fetch(key.to_s.upcase)
+        intervals = SCALE_INTERVALS.fetch(scale.to_sym)
+        octave = midi_note / 12
+        candidates = ((octave - 1)..(octave + 1)).flat_map do |candidate_octave|
+          base = (candidate_octave * 12) + key_pitch
+          intervals.map { |interval| base + interval }
+        end.select { |candidate| candidate.between?(0, 127) }
+        candidates.min_by { |candidate| [(candidate - midi_note).abs, candidate] } || midi_note
+      end
+
       private
 
       def validate_name!(name)
@@ -232,7 +311,9 @@ module Wavify
       end
 
       def validate_resolution!(value, name)
-        raise SequencerError, "#{name} must be a positive Integer" unless value.is_a?(Integer) && value.positive?
+        unless value.is_a?(Integer) && value.between?(1, Pattern::MAX_RESOLUTION)
+          raise SequencerError, "#{name} must be an Integer in 1..#{Pattern::MAX_RESOLUTION}"
+        end
 
         value
       end
@@ -244,13 +325,17 @@ module Wavify
       end
 
       def validate_numeric!(value, name)
-        raise SequencerError, "#{name} must be Numeric" unless value.is_a?(Numeric)
+        unless value.is_a?(Numeric) && value.respond_to?(:finite?) && value.finite?
+          raise SequencerError, "#{name} must be a finite Numeric"
+        end
 
         value
       end
 
       def validate_pan!(value)
-        raise SequencerError, "pan_position must be Numeric in -1.0..1.0" unless value.is_a?(Numeric) && value.between?(-1.0, 1.0)
+        unless value.is_a?(Numeric) && value.respond_to?(:finite?) && value.finite? && value.between?(-1.0, 1.0)
+          raise SequencerError, "pan_position must be a finite Numeric in -1.0..1.0"
+        end
 
         value.to_f
       end
@@ -271,6 +356,52 @@ module Wavify
         effects.freeze
       end
 
+      def validate_synth_options!(value)
+        raise SequencerError, "synth_options must be a Hash" unless value.is_a?(Hash)
+
+        supported = %i[amplitude phase pulse_width detune unison]
+        unknown = value.keys - supported
+        raise SequencerError, "unsupported synth options: #{unknown.join(', ')}" unless unknown.empty?
+
+        value.dup.freeze
+      end
+
+      def normalize_key_root(value)
+        return nil if value.nil?
+
+        key = value.to_s.upcase
+        raise SequencerError, "key must be a note name" unless NoteSequence::NOTE_OFFSETS.key?(key)
+
+        key
+      end
+
+      def normalize_scale(value)
+        return nil if value.nil?
+
+        scale = value.to_sym
+        raise SequencerError, "unsupported scale: #{value.inspect}" unless SCALE_INTERVALS.key?(scale)
+
+        scale
+      rescue NoMethodError
+        raise SequencerError, "scale must be Symbol/String"
+      end
+
+      def normalize_chord_voicing(value)
+        self.class.send(:normalize_chord_voicing, value)
+      end
+
+      def self.normalize_chord_voicing(value)
+        return nil if value.nil?
+
+        voicing = value.to_sym
+        return voicing if %i[root open drop2].include?(voicing)
+
+        raise SequencerError, "unsupported chord voicing: #{value.inspect}"
+      rescue NoMethodError
+        raise SequencerError, "chord_voicing must be Symbol/String"
+      end
+      private_class_method :normalize_chord_voicing
+
       def coerce_pattern(pattern)
         return nil if pattern.nil?
         return pattern if pattern.is_a?(Pattern)
@@ -288,10 +419,18 @@ module Wavify
       def coerce_chord_progression(chord_progression)
         return nil if chord_progression.nil?
         if chord_progression.is_a?(Array) && chord_progression.all? { |item| item.is_a?(Hash) && item[:midi_notes] }
-          return chord_progression
+          return chord_progression.map { |chord| chord.transform_values { |item| item.is_a?(Array) ? item.dup.freeze : item }.freeze }.freeze
         end
 
         self.class.parse_chords(chord_progression, default_octave: @default_octave)
+                   .map { |chord| apply_track_chord_options(chord).transform_values { |item| item.is_a?(Array) ? item.freeze : item }.freeze }
+                   .freeze
+      end
+
+      def apply_track_chord_options(chord)
+        midi_notes = chord.fetch(:midi_notes).map { |midi| quantize_midi_note(midi) }
+        midi_notes = self.class.apply_chord_voicing(midi_notes, @chord_voicing) if @chord_voicing
+        chord.merge(midi_notes: midi_notes)
       end
     end
   end

data/lib/wavify/version.rb

@@ -2,5 +2,5 @@
 
 module Wavify
   # Gem version string (Semantic Versioning).
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/wavify.rb

@@ -5,7 +5,9 @@ require_relative "wavify/errors"
 require_relative "wavify/core/format"
 require_relative "wavify/core/duration"
 require_relative "wavify/core/sample_buffer"
+require_relative "wavify/dsp/processor"
 require_relative "wavify/core/stream"
+require_relative "wavify/adapters"
 require_relative "wavify/codecs/base"
 require_relative "wavify/codecs/raw"
 require_relative "wavify/codecs/wav"
@@ -13,16 +15,32 @@ require_relative "wavify/codecs/flac"
 require_relative "wavify/codecs/ogg_vorbis"
 require_relative "wavify/codecs/aiff"
 require_relative "wavify/codecs/registry"
+require_relative "wavify/dsp/automation"
+require_relative "wavify/dsp/lfo"
 require_relative "wavify/dsp/oscillator"
 require_relative "wavify/dsp/envelope"
 require_relative "wavify/dsp/filter"
+require_relative "wavify/dsp/loudness_meter"
+require_relative "wavify/dsp/headroom"
 require_relative "wavify/dsp/effects"
 require_relative "wavify/sequencer"
 require_relative "wavify/audio"
 require_relative "wavify/dsl"
+require_relative "wavify/cli"
 
 ##
 # Wavify is a pure Ruby audio processing toolkit with immutable transforms,
 # multiple codecs, DSP primitives, and a small sequencing DSL.
 module Wavify
+  # @param value [Numeric]
+  # @return [Wavify::Core::Duration]
+  def self.seconds(value)
+    Core::Duration.new(value)
+  end
+
+  # @param value [Numeric] milliseconds
+  # @return [Wavify::Core::Duration]
+  def self.ms(value)
+    Core::Duration.new(value.to_f / 1000.0)
+  end
 end

data/sig/audio.rbs

@@ -0,0 +1,86 @@
+module Wavify
+  class Audio
+    attr_reader buffer: Core::SampleBuffer
+
+    def self.read: (String | IO path_or_io, ?format: Core::Format?, ?codec_options: Hash[Symbol, untyped]?, ?strict: bool, ?filename: String?) -> Audio
+    def self.metadata: (String | IO path_or_io, ?format: Core::Format?, ?codec_options: Hash[Symbol, untyped]?, ?strict: bool, ?filename: String?) -> Hash[Symbol, untyped]
+    def self.info: (String | IO path_or_io, ?format: Core::Format?, ?codec_options: Hash[Symbol, untyped]?, ?strict: bool, ?filename: String?) -> Hash[Symbol, untyped]
+    def self.mix: (*Audio audios, ?strategy: Symbol, ?gains: Array[Numeric]?, ?align: Symbol, ?format: Core::Format?, ?work_format: Core::Format?, ?headroom_smoothing: Numeric) -> Audio
+    def self.stream: (String | IO path_or_io, ?chunk_size: Integer, ?format: Core::Format?, ?codec_options: Hash[Symbol, untyped]?, ?strict: bool, ?filename: String?) -> Core::Stream
+    def self.tone: (frequency: Numeric, duration: Numeric | Core::Duration, format: Core::Format, ?waveform: Symbol, **untyped oscillator_options) -> Audio
+    def self.silence: (Numeric | Core::Duration duration_seconds, format: Core::Format) -> Audio
+
+    def initialize: (Core::SampleBuffer buffer) -> void
+    def format: () -> Core::Format
+    def duration: () -> Core::Duration
+    def sample_frame_count: () -> Integer
+    def channels: () -> Integer
+    def sample_rate: () -> Integer
+    def bit_depth: () -> Integer
+    def with_bit_depth: (Integer value, ?dither: bool, ?dither_seed: Integer?) -> Audio
+    def frames: () -> Array[Array[Numeric]]
+    def each_frame: () { (Array[Numeric]) -> void } -> Audio
+                  | () -> Enumerator[Array[Numeric], Audio]
+    def write: (String | IO path, ?format: Core::Format?, ?codec: Symbol | untyped, ?filename: String?, ?codec_options: Hash[Symbol, untyped]?, ?overwrite: bool) -> Audio
+    def convert: (Core::Format new_format, ?dither: bool, ?dither_seed: Integer?, ?resampler: Symbol) -> Audio
+    def resample: (sample_rate: Integer, ?resampler: Symbol) -> Audio
+    def to_mono: () -> Audio
+    def to_stereo: () -> Audio
+    def split: (at: Numeric | Core::Duration) -> [Audio, Audio]
+    def slice: (from: Numeric | Core::Duration, to: Numeric | Core::Duration) -> Audio
+    def crop: (start: Numeric | Core::Duration, duration: Numeric | Core::Duration) -> Audio
+    def concat: (Audio other) -> Audio
+    def append: (Audio other) -> Audio
+    def +: (Audio other) -> Audio
+    def prepend: (Audio other) -> Audio
+    def overlay: (Audio other, at: Numeric | Core::Duration, ?strategy: Symbol, ?headroom_smoothing: Numeric) -> Audio
+    def crossfade: (Audio other, duration: Numeric | Core::Duration) -> Audio
+    def pad_start: (Numeric seconds) -> Audio
+    def pad_end: (Numeric seconds) -> Audio
+    def insert_silence: (at: Numeric | Core::Duration, duration: Numeric | Core::Duration) -> Audio
+    def repeat: (times: Integer) -> Audio
+    def repeat_chunks: (times: Integer, ?chunk_frames: Integer) -> Enumerator[Audio, nil]
+    def repeat!: (times: Integer) -> Audio
+    def reverse: () -> Audio
+    def reverse!: () -> Audio
+    def gain: (Numeric db) -> Audio
+    def gain!: (Numeric db) -> Audio
+    def normalize: (?target_db: Numeric, ?mode: Symbol) -> Audio
+    def normalize!: (?target_db: Numeric, ?mode: Symbol) -> Audio
+    def trim: (?threshold: Numeric) -> Audio
+    def trim!: (?threshold: Numeric) -> Audio
+    def fade_in: (Numeric seconds, ?curve: Symbol) -> Audio
+    def fade_in!: (Numeric seconds, ?curve: Symbol) -> Audio
+    def fade_out: (Numeric seconds, ?curve: Symbol) -> Audio
+    def fade_out!: (Numeric seconds, ?curve: Symbol) -> Audio
+    def fade: (Numeric seconds, type: Symbol, ?curve: Symbol) -> Audio
+    def pan: (Numeric position) -> Audio
+    def pan!: (Numeric position) -> Audio
+    def balance: (Numeric position) -> Audio
+    def stereo_rotate: (Numeric position) -> Audio
+    def apply: (untyped effect) -> Audio
+    def apply!: (untyped effect) -> Audio
+    def map_samples: () { (Numeric, Integer) -> Numeric } -> Audio
+    def map_frames: () { (Array[Numeric], Integer) -> Array[Numeric] } -> Audio
+    def sample_peak_amplitude: () -> Float
+    def peak_amplitude: () -> Float
+    def true_peak_amplitude: (?oversampling: Integer) -> Float
+    def rms_amplitude: () -> Float
+    def peak_dbfs: () -> Float
+    def sample_peak_dbfs: () -> Float
+    def true_peak_dbfs: (?oversampling: Integer) -> Float
+    def rms_dbfs: () -> Float
+    def lufs: () -> Float
+    def stats: () -> Hash[Symbol, untyped]
+    def silent?: (?threshold: Numeric) -> bool
+    def clipped?: (?consecutive_frames: Integer) -> bool
+    def dc_offset: () -> Float
+    def dc_offsets: () -> Array[Float]
+    def remove_dc_offset: () -> Audio
+    def zero_crossing_rate: () -> Float
+    def ==: (untyped other) -> bool
+    def eql?: (untyped other) -> bool
+    def hash: () -> Integer
+    def inspect: () -> String
+  end
+end