deftones 0.1.0

data/lib/deftones/instrument/noise_synth.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class NoiseSynth < Core::Instrument
+      attr_reader :noise, :filter, :envelope
+
+      def initialize(type: :white, filter_type: :bandpass, filter_frequency: 1_500.0, attack: 0.001,
+                     decay: 0.12, sustain: 0.0, release: 0.1, context: Deftones.context, &block)
+        super(context: context)
+        @noise = Source::Noise.new(type: type, context: context)
+        @filter = Component::Filter.new(type: filter_type, frequency: filter_frequency, q: 0.8, context: context)
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @noise.start(0.0)
+        @noise >> @filter >> @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(_note = nil, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(duration, at, velocity)
+      end
+
+      def trigger_attack(time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        @envelope.trigger_release(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      private
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/pluck_synth.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class PluckSynth < Core::Instrument
+      attr_reader :resonator
+
+      def initialize(decay: 0.995, damping: 0.5, context: Deftones.context, &block)
+        super(context: context)
+        @resonator = Source::KarplusStrong.new(decay: decay, damping: damping, context: context)
+        @resonator >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        @resonator.trigger(note, resolve_time(time), velocity)
+        self
+      end
+
+      def trigger_release(_time = nil)
+        self
+      end
+
+      def trigger_attack_release(note, _duration, time = nil, velocity = 1.0)
+        trigger_attack(note, resolve_time(time), velocity)
+      end
+
+      private
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/poly_synth.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class PolySynth < Core::Instrument
+      attr_reader :voice_pool
+
+      def initialize(voice_class = Synth, voices: 8, context: Deftones.context, **voice_options)
+        super(context: context)
+        @voice_class = voice_class
+        @voice_pool = Array.new(voices) { @voice_class.new(context: context, **voice_options) }
+        @voice_pool.each { |voice| voice >> @output }
+        @active_voices = {}
+      end
+
+      def play(notes, duration: "8n", at: nil, velocity: 1.0)
+        scheduled_time = resolve_time(at)
+
+        Array(notes).compact.each do |note|
+          trigger_attack(note, scheduled_time, velocity)
+        end
+
+        release_time = scheduled_time + Deftones::Music::Time.parse(duration)
+        Array(notes).compact.each do |note|
+          trigger_release(note, release_time)
+        end
+
+        self
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        voice = allocate_voice(note)
+        @active_voices.delete(note)
+        @active_voices[note] = voice
+        voice.trigger_attack(note, resolve_time(time), velocity)
+        self
+      end
+
+      def trigger_release(note, time = nil)
+        voice = @active_voices.delete(note)
+        voice&.trigger_release(resolve_time(time))
+        self
+      end
+
+      def set(**params)
+        @voice_pool.each do |voice|
+          params.each do |key, value|
+            writer = :"#{key}="
+            voice.public_send(writer, value) if voice.respond_to?(writer)
+          end
+        end
+        self
+      end
+
+      def release_all(time = nil)
+        scheduled_time = resolve_time(time)
+        @active_voices.each_value { |voice| voice.trigger_release(scheduled_time) }
+        @active_voices.clear
+        self
+      end
+
+      def max_polyphony
+        @voice_pool.length
+      end
+
+      def loaded?
+        true
+      end
+
+      alias loaded loaded?
+      alias releaseAll release_all
+
+      def active?
+        @voice_pool.any?(&:active?)
+      end
+
+      private
+
+      def allocate_voice(note)
+        return @active_voices[note] if @active_voices.key?(note)
+
+        available_voice = @voice_pool.find { |voice| !@active_voices.value?(voice) }
+        return available_voice if available_voice
+
+        _, stolen_voice = @active_voices.shift
+        stolen_voice
+      end
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/sampler.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class Sampler < Core::Instrument
+      attr_reader :samples, :voices
+
+      def initialize(samples:, max_voices: 8, context: Deftones.context)
+        super(context: context)
+        @samples = samples.transform_keys(&:to_s)
+        @max_voices = max_voices
+        @voices = []
+      end
+
+      def play(notes, duration: "8n", at: nil, velocity: 1.0)
+        Array(notes).each do |note|
+          trigger_attack(note, at, velocity)
+          trigger_release(note, resolve_time(at) + Deftones::Music::Time.parse(duration))
+        end
+        self
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        buffer_note, buffer = closest_sample(note)
+        playback_rate = Deftones::Music::Note.to_frequency(note) / Deftones::Music::Note.to_frequency(buffer_note)
+        player = Source::Player.new(buffer: buffer, playback_rate: playback_rate, context: context)
+        gain = Core::Gain.new(gain: velocity, context: context)
+        player >> gain >> @output
+        player.start(resolve_time(time))
+        @voices << { note: note, player: player }
+        @voices.shift if @voices.length > @max_voices
+        self
+      end
+
+      def trigger_release(note, time = nil)
+        voice = @voices.find { |entry| entry[:note] == note }
+        voice&.fetch(:player)&.stop(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(note, scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      def add(note, buffer)
+        @samples[note.to_s] = buffer.is_a?(Deftones::IO::Buffer) ? buffer : Deftones::IO::Buffer.load(buffer)
+        self
+      end
+
+      def get(note)
+        @samples[note.to_s]
+      end
+
+      def has?(note)
+        @samples.key?(note.to_s)
+      end
+
+      def release_all(time = nil)
+        scheduled_time = resolve_time(time)
+        @voices.each { |voice| voice[:player].stop(scheduled_time) }
+        self
+      end
+
+      def loaded?
+        true
+      end
+
+      def dispose
+        release_all(context.current_time)
+        @voices.clear
+        super
+      end
+
+      alias loaded loaded?
+      alias triggerAttackRelease trigger_attack_release
+      alias releaseAll release_all
+
+      private
+
+      def closest_sample(note)
+        target_midi = Deftones::Music::Note.to_midi(note)
+        @samples.min_by do |sample_note, _|
+          (Deftones::Music::Note.to_midi(sample_note) - target_midi).abs
+        end
+      end
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/synth.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class Synth < Core::Instrument
+      attr_reader :oscillator, :envelope
+
+      def initialize(type: :triangle, attack: 0.005, decay: 0.1, sustain: 0.3, release: 1.0,
+                     context: Deftones.context, &block)
+        super(context: context)
+        @oscillator = Source::Oscillator.new(type: type, context: context)
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @oscillator.start(0.0)
+        @oscillator >> @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        @oscillator.frequency.set_value_at_time(note, scheduled_time)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        @envelope.trigger_release(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      def active?
+        @envelope.active?
+      end
+
+      private
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/io/buffer.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+
+module Deftones
+  module IO
+    class Buffer
+      include Enumerable
+
+      attr_reader :samples, :channels, :sample_rate
+
+      COMPRESSED_EXTENSIONS = %w[.mp3 .ogg .oga].freeze
+      SAVEABLE_FORMATS = %i[wav mp3 ogg].freeze
+
+      def self.interleave(mono_samples, channels)
+        return mono_samples.dup if channels == 1
+
+        mono_samples.flat_map { |sample| Array.new(channels, sample) }
+      end
+
+      def self.from_mono(samples, channels: 1, sample_rate: Context::DEFAULT_SAMPLE_RATE)
+        interleaved = channels == 1 ? samples : interleave(samples, channels)
+        new(interleaved, channels: channels, sample_rate: sample_rate)
+      end
+
+      def self.from_array(samples, sample_rate: Context::DEFAULT_SAMPLE_RATE, channels: nil)
+        if samples.first.is_a?(Array)
+          channel_count = channels || samples.length
+          frame_count = samples.map(&:length).max || 0
+          interleaved = Array.new(frame_count * channel_count, 0.0)
+
+          frame_count.times do |frame_index|
+            channel_count.times do |channel_index|
+              source_channel = samples[channel_index] || []
+              interleaved[(frame_index * channel_count) + channel_index] = source_channel[frame_index].to_f
+            end
+          end
+
+          new(interleaved, channels: channel_count, sample_rate: sample_rate)
+        else
+          from_mono(samples, channels: channels || 1, sample_rate: sample_rate)
+        end
+      end
+
+      def self.from_url(path)
+        load(path)
+      end
+
+      def self.loaded
+        true
+      end
+
+      class << self
+        alias fromArray from_array
+        alias fromUrl from_url
+      end
+
+      def self.load(path)
+        extension = File.extname(path).downcase
+        return load_wav(path) if extension == ".wav"
+        return load_compressed(path, extension) if COMPRESSED_EXTENSIONS.include?(extension)
+
+        raise ArgumentError, "Unsupported audio format: #{extension}"
+      end
+
+      def initialize(samples, channels:, sample_rate:)
+        @samples = samples.map(&:to_f)
+        @channels = channels
+        @sample_rate = sample_rate
+        @disposed = false
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+
+        mono.each(&block)
+      end
+
+      def each_frame
+        return enum_for(:each_frame) unless block_given?
+
+        frames.times do |frame_index|
+          yield frame(frame_index)
+        end
+      end
+
+      def frames
+        @samples.length / @channels
+      end
+
+      def duration
+        frames.to_f / @sample_rate
+      end
+
+      def length
+        frames
+      end
+
+      def loaded?
+        !@disposed
+      end
+
+      def mono
+        return @samples if @channels == 1
+
+        Array.new(frames) do |frame|
+          offset = frame * @channels
+          @samples[offset, @channels].sum / @channels.to_f
+        end
+      end
+
+      def peak
+        @samples.map(&:abs).max || 0.0
+      end
+
+      def rms
+        return 0.0 if @samples.empty?
+
+        Math.sqrt(@samples.sum { |sample| sample * sample } / @samples.length)
+      end
+
+      def [](frame_index, channel = nil)
+        return mono[frame_index] if channel.nil?
+
+        @samples[(frame_index * @channels) + channel]
+      end
+
+      def frame(frame_index)
+        offset = frame_index * @channels
+        @samples[offset, @channels]
+      end
+
+      def number_of_channels
+        @channels
+      end
+
+      def get_channel_data(channel)
+        channel_index = channel.to_i
+        raise ArgumentError, "channel is out of range" if channel_index.negative? || channel_index >= @channels
+
+        Array.new(frames) { |frame_index| self[frame_index, channel_index] }
+      end
+
+      def to_array
+        Array.new(@channels) { |channel_index| get_channel_data(channel_index) }
+      end
+
+      def sample_at(frame_position, channel = 0)
+        return 0.0 if @samples.empty?
+
+        clamped_position = Deftones::DSP::Helpers.clamp(frame_position.to_f, 0.0, [frames - 1, 0].max)
+        lower = clamped_position.floor
+        upper = [lower + 1, frames - 1].min
+        fraction = clamped_position - lower
+        lower_sample = self[lower, [channel, @channels - 1].min]
+        upper_sample = self[upper, [channel, @channels - 1].min]
+        Deftones::DSP::Helpers.lerp(lower_sample, upper_sample, fraction)
+      end
+
+      def slice(start_frame, length)
+        frame_count = [length.to_i, 0].max
+        offset = start_frame.to_i * @channels
+        subset = @samples.slice(offset, frame_count * @channels) || []
+        self.class.new(subset, channels: @channels, sample_rate: @sample_rate)
+      end
+
+      def reverse
+        reversed_frames = each_frame.to_a.reverse.flatten
+        self.class.new(reversed_frames, channels: @channels, sample_rate: @sample_rate)
+      end
+
+      def normalize(target_peak = 0.99)
+        return self.class.new(@samples, channels: @channels, sample_rate: @sample_rate) if peak.zero?
+
+        scale = target_peak.to_f / peak
+        self.class.new(@samples.map { |sample| sample * scale }, channels: @channels, sample_rate: @sample_rate)
+      end
+
+      def mixdown
+        self.class.new(mono, channels: 1, sample_rate: @sample_rate)
+      end
+
+      def dispose
+        @samples = []
+        @disposed = true
+        self
+      end
+
+      alias numberOfChannels number_of_channels
+      alias getChannelData get_channel_data
+      alias toArray to_array
+
+      def save(path, format: nil)
+        resolved_format = self.class.send(:resolve_save_format, path, format)
+        raise ArgumentError, "Unsupported format: #{resolved_format}" unless SAVEABLE_FORMATS.include?(resolved_format)
+
+        case resolved_format
+        when :wav
+          save_wav(path)
+        when :mp3, :ogg
+          save_compressed(path, resolved_format)
+        end
+        path
+      end
+
+      private
+
+      def save_wav(path)
+        sample_buffer = Wavify::Core::SampleBuffer.new(
+          @samples,
+          self.class.send(:wavify_work_format, @channels, @sample_rate)
+        )
+        Wavify::Codecs::Wav.write(
+          path,
+          sample_buffer,
+          format: self.class.send(:wavify_wav_format, @channels, @sample_rate)
+        )
+      end
+
+      def save_compressed(path, format)
+        backend = self.class.send(:encoder_backend_for, format)
+        raise ArgumentError, self.class.send(:missing_encoder_message, format) unless backend
+
+        Tempfile.create(["deftones-buffer-export", ".wav"]) do |tempfile|
+          tempfile.close
+          save_wav(tempfile.path)
+          stdout, stderr, status = Open3.capture3(*self.class.send(:encoder_command, backend, tempfile.path, path, format))
+          return if status.success?
+
+          message = [stderr, stdout].map(&:strip).reject(&:empty?).first || "unknown encoder error"
+          raise ArgumentError, "Failed to encode #{format}: #{message}"
+        end
+      end
+
+      class << self
+        private
+
+        def load_wav(path)
+          sample_buffer = Wavify::Codecs::Wav.read(path)
+          float_buffer = sample_buffer.convert(wavify_work_format(sample_buffer.format.channels, sample_buffer.format.sample_rate))
+          new(float_buffer.samples, channels: float_buffer.format.channels, sample_rate: float_buffer.format.sample_rate)
+        rescue Wavify::Error => error
+          raise ArgumentError, "Failed to load WAV: #{error.message}"
+        end
+
+        def load_compressed(path, extension)
+          backend = decoder_backend_for(extension)
+          raise ArgumentError, missing_decoder_message(extension) unless backend
+
+          Tempfile.create(["deftones-buffer", ".wav"]) do |tempfile|
+            tempfile.close
+            stdout, stderr, status = Open3.capture3(*decoder_command(backend, path, tempfile.path))
+            next load_wav(tempfile.path) if status.success?
+
+            message = [stderr, stdout].map(&:strip).reject(&:empty?).first || "unknown decoder error"
+            raise ArgumentError, "Failed to decode #{extension}: #{message}"
+          end
+        end
+
+        def wavify_work_format(channels, sample_rate)
+          Wavify::Core::Format.new(
+            channels: channels,
+            sample_rate: sample_rate,
+            bit_depth: 32,
+            sample_format: :float
+          )
+        end
+
+        def wavify_wav_format(channels, sample_rate)
+          Wavify::Core::Format.new(
+            channels: channels,
+            sample_rate: sample_rate,
+            bit_depth: 16,
+            sample_format: :pcm
+          )
+        end
+
+        def decoder_backend_for(extension)
+          return :ffmpeg if executable_available?("ffmpeg")
+          return :afconvert if extension == ".mp3" && executable_available?("afconvert")
+
+          nil
+        end
+
+        def encoder_backend_for(format)
+          return :ffmpeg if executable_available?("ffmpeg")
+          return :afconvert if format == :mp3 && executable_available?("afconvert")
+
+          nil
+        end
+
+        def decoder_command(backend, input_path, output_path)
+          case backend
+          when :ffmpeg
+            ["ffmpeg", "-v", "error", "-y", "-i", input_path, "-f", "wav", output_path]
+          when :afconvert
+            ["afconvert", "-f", "WAVE", "-d", "LEI16", input_path, output_path]
+          else
+            raise ArgumentError, "Unknown decoder backend: #{backend}"
+          end
+        end
+
+        def encoder_command(backend, input_path, output_path, format)
+          case backend
+          when :ffmpeg
+            container = format == :ogg ? "ogg" : format.to_s
+            ["ffmpeg", "-v", "error", "-y", "-i", input_path, "-f", container, output_path]
+          when :afconvert
+            raise ArgumentError, "afconvert only supports mp3 export" unless format == :mp3
+
+            ["afconvert", "-f", "MPG3", "-d", ".mp3", input_path, output_path]
+          else
+            raise ArgumentError, "Unknown encoder backend: #{backend}"
+          end
+        end
+
+        def executable_available?(name)
+          ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |directory|
+            executable = File.join(directory, name)
+            File.file?(executable) && File.executable?(executable)
+          end
+        end
+
+        def missing_decoder_message(extension)
+          "No decoder available for #{extension}. Install ffmpeg to enable compressed audio loading."
+        end
+
+        def missing_encoder_message(format)
+          "No encoder available for #{format}. Install ffmpeg to enable compressed audio export."
+        end
+
+        def resolve_save_format(path, format)
+          return normalize_format(format) if format
+
+          extension = File.extname(path).downcase
+          return :mp3 if extension == ".mp3"
+          return :ogg if COMPRESSED_EXTENSIONS.include?(extension)
+
+          :wav
+        end
+
+        def normalize_format(format)
+          normalized = format.to_sym
+          return :ogg if normalized == :oga
+
+          normalized
+        end
+      end
+    end
+  end
+end