deftones 0.1.0

data/lib/deftones/source/player.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class Player < Core::Source
+      attr_reader :buffer, :playback_rate
+      attr_accessor :loop, :loop_start, :loop_end, :reverse, :fade_in, :fade_out, :curve
+      attr_accessor :autostart
+
+      def initialize(buffer:, playback_rate: 1.0, loop: false, loop_start: 0.0, loop_end: nil,
+                     reverse: false, fade_in: 0.0, fade_out: 0.0, curve: :linear,
+                     autostart: false, onstop: nil, context: Deftones.context)
+        super(context: context)
+        @buffer = buffer.is_a?(IO::Buffer) ? buffer : IO::Buffer.load(buffer)
+        @playback_rate = Core::Signal.new(value: playback_rate, units: :number, context: context)
+        @loop = loop
+        @loop_start = loop_start.to_f
+        @loop_end = loop_end
+        @reverse = reverse
+        @fade_in = fade_in.to_f
+        @fade_out = fade_out.to_f
+        @curve = curve.to_sym
+        @autostart = !!autostart
+        @onstop = onstop
+        @seek_position = 0.0
+        @start_time = Float::INFINITY
+        @stop_notified = false
+        start(0.0) if @autostart
+      end
+
+      def playback_rate=(value)
+        @playback_rate.value = value
+      end
+
+      def onstop
+        @onstop
+      end
+
+      def onstop=(callback)
+        @onstop = callback
+      end
+
+      def loaded?
+        !@buffer.nil?
+      end
+
+      def loaded
+        loaded?
+      end
+
+      def dispose
+        @buffer = nil
+        super
+      end
+
+      def start(time = nil, offset = nil, duration = nil)
+        seek(offset) if offset
+        @stop_notified = false
+        super(time)
+        self.stop(@start_time + Deftones::Music::Time.parse(duration)) if duration
+        self
+      end
+
+      def restart(time = nil, offset = nil, duration = nil)
+        stop(time)
+        start(time, offset, duration)
+      end
+
+      def state(time = context.current_time)
+        active_at?(resolve_time(time)) ? :started : :stopped
+      end
+
+      def seek(time = nil)
+        return @seek_position.to_f / @buffer.sample_rate if time.nil?
+
+        @seek_position = Deftones::Music::Time.parse(time) * @buffer.sample_rate
+        self
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        rates = @playback_rate.process(num_frames, start_frame)
+        return process_multichannel_buffer(num_frames, start_frame, rates) if multichannel_process?
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          notify_stop(current_time) if @stop_time && current_time >= @stop_time
+          next 0.0 unless active_at?(current_time)
+
+          sample_position = sample_position_for(current_time, rates[index])
+          if sample_position.negative?
+            @stop_time ||= current_time
+            notify_stop(current_time)
+            next 0.0
+          end
+
+          @buffer.sample_at(sample_position) * envelope_gain(current_time)
+        end
+      end
+
+      alias playbackRate playback_rate
+      alias loopStart loop_start
+      alias loopEnd loop_end
+      alias fadeIn fade_in
+      alias fadeOut fade_out
+
+      def playbackRate=(value)
+        self.playback_rate = value
+      end
+
+      def loopStart=(value)
+        self.loop_start = value
+      end
+
+      def loopEnd=(value)
+        self.loop_end = value
+      end
+
+      def fadeIn=(value)
+        self.fade_in = value
+      end
+
+      def fadeOut=(value)
+        self.fade_out = value
+      end
+
+      private
+
+      def multichannel_process?
+        @buffer && @buffer.channels > 1
+      end
+
+      def envelope_gain(current_time)
+        fade_in_gain(current_time) * fade_out_gain(current_time)
+      end
+
+      def fade_in_gain(current_time)
+        return 1.0 if @fade_in <= 0.0
+
+        shaped_gain((current_time - @start_time) / @fade_in)
+      end
+
+      def fade_out_gain(current_time)
+        return 1.0 unless @stop_time && @fade_out > 0.0
+
+        shaped_gain((@stop_time - current_time) / @fade_out)
+      end
+
+      def shaped_gain(progress)
+        bounded = progress.clamp(0.0, 1.0)
+        return bounded if @curve == :linear
+
+        Math.sin(bounded * Math::PI * 0.5)
+      end
+
+      def notify_stop(current_time)
+        return if @stop_notified
+
+        @stop_notified = true
+        @onstop&.call(current_time)
+      end
+
+      def process_multichannel_buffer(num_frames, start_frame, rates)
+        output = Array.new(@buffer.channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          notify_stop(current_time) if @stop_time && current_time >= @stop_time
+          next unless active_at?(current_time)
+
+          sample_position = sample_position_for(current_time, rates[index])
+          if sample_position.negative?
+            @stop_time ||= current_time
+            notify_stop(current_time)
+            next
+          end
+
+          gain = envelope_gain(current_time)
+          @buffer.channels.times do |channel_index|
+            output[channel_index][index] = @buffer.sample_at(sample_position, channel_index) * gain
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def sample_position_for(current_time, rate)
+        elapsed_frames = (current_time - @start_time) * @buffer.sample_rate * rate
+        base_position = @seek_position + elapsed_frames
+        resolve_buffer_position(base_position)
+      end
+
+      def resolve_buffer_position(base_position)
+        return -1 if base_position.negative?
+        return reverse_position(base_position) if @reverse
+        return looped_position(base_position) if @loop
+
+        base_position < @buffer.frames ? base_position : -1
+      end
+
+      def reverse_position(base_position)
+        max_position = loop_end_frame || (@buffer.frames - 1)
+        min_position = @loop_start * @buffer.sample_rate
+        position = max_position - base_position
+        return looped_reverse_position(position, min_position, max_position) if @loop
+
+        position
+      end
+
+      def looped_position(position)
+        min_position = @loop_start * @buffer.sample_rate
+        max_position = loop_end_frame || @buffer.frames
+        span = [max_position - min_position, 1.0].max
+        min_position + ((position - min_position) % span)
+      end
+
+      def looped_reverse_position(position, min_position, max_position)
+        span = [max_position - min_position, 1.0].max
+        min_position + ((position - min_position) % span)
+      end
+
+      def loop_end_frame
+        return unless @loop_end
+
+        Deftones::Music::Time.parse(@loop_end) * @buffer.sample_rate
+      end
+    end
+  end
+end

data/lib/deftones/source/players.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class Players
+      include Enumerable
+
+      class VolumeProxy
+        attr_reader :players
+        attr_accessor :value
+
+        def initialize(players, value: 0.0)
+          @players = players
+          @value = value.to_f
+        end
+
+        def value=(new_value)
+          @value = new_value.to_f
+          players.send(:apply_controls!)
+        end
+
+        def ramp_to(target_value, _duration = nil)
+          self.value = target_value
+          self
+        end
+
+        alias linear_ramp_to ramp_to
+        alias exponential_ramp_to ramp_to
+      end
+
+      attr_reader :volume
+
+      def initialize(buffers = {}, context: Deftones.context)
+        @context = context
+        @players = {}
+        @mute = false
+        @volume = VolumeProxy.new(self)
+        @disposed = false
+        source_buffers = buffers.is_a?(IO::Buffers) ? buffers : IO::Buffers.new(buffers)
+        source_buffers.each { |name, buffer| add(name, buffer) }
+      end
+
+      def add(name, buffer)
+        player = Player.new(buffer: buffer, context: @context)
+        player.volume.value = @volume.value
+        player.mute = @mute
+        @players[name.to_sym] = player
+        player
+      end
+
+      def [](name)
+        get(name)
+      end
+
+      def get(name)
+        @players[name.to_sym]
+      end
+
+      def player(name)
+        get(name)
+      end
+
+      def has?(name)
+        @players.key?(name.to_sym)
+      end
+
+      def names
+        @players.keys
+      end
+
+      def loaded?
+        !@disposed
+      end
+
+      def loaded
+        loaded?
+      end
+
+      def mute
+        @mute
+      end
+
+      def mute=(value)
+        @mute = !!value
+        apply_controls!
+      end
+
+      def mute?
+        @mute
+      end
+
+      def volume=(value)
+        @volume.value = value
+      end
+
+      def stop_all(time = nil)
+        @players.each_value { |player| player.stop(time) }
+        self
+      end
+
+      def state(name = nil, time: @context.current_time)
+        return get(name)&.state(time) if name
+
+        @players.transform_values { |player| player.state(time) }
+      end
+
+      def dispose
+        @players.each_value(&:dispose)
+        @players.clear
+        @disposed = true
+        self
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+
+        @players.each_value(&block)
+      end
+
+      alias stopAll stop_all
+
+      private
+
+      def apply_controls!
+        @players.each_value do |player|
+          player.volume.value = @volume.value
+          player.mute = @mute
+        end
+        self
+      end
+    end
+  end
+end

data/lib/deftones/source/pulse_oscillator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class PulseOscillator < Core::Source
+      attr_reader :frequency, :width, :detune
+
+      def initialize(frequency: 440.0, width: 0.5, detune: 0.0, phase: 0.0, context: Deftones.context)
+        super(context: context)
+        @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
+        @width = Core::Signal.new(value: width, units: :number, context: context)
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        @phase = phase.to_f % 1.0
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        frequencies = @frequency.process(num_frames, start_frame)
+        widths = @width.process(num_frames, start_frame)
+        detunes = @detune.process(num_frames, start_frame)
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          next 0.0 unless active_at?(current_time)
+
+          duty = Deftones::DSP::Helpers.clamp(widths[index], 0.01, 0.99)
+          sample = @phase < duty ? 1.0 : -1.0
+          frequency = frequencies[index] * (2.0**(detunes[index].to_f / 1200.0))
+          @phase = (@phase + (frequency / context.sample_rate)) % 1.0
+          sample
+        end
+      end
+    end
+  end
+end

data/lib/deftones/source/pwm_oscillator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class PWMOscillator < Core::Source
+      attr_reader :frequency, :modulation_frequency, :modulation_depth, :detune
+
+      def initialize(frequency: 440.0, modulation_frequency: 0.5, modulation_depth: 0.4,
+                     pulse_width: 0.5, detune: 0.0, context: Deftones.context)
+        super(context: context)
+        @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
+        @modulation_frequency = Core::Signal.new(value: modulation_frequency, units: :frequency, context: context)
+        @modulation_depth = Core::Signal.new(value: modulation_depth, units: :number, context: context)
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        @base_width = pulse_width.to_f
+        @phase = 0.0
+        @modulation_phase = 0.0
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        frequencies = @frequency.process(num_frames, start_frame)
+        mod_frequencies = @modulation_frequency.process(num_frames, start_frame)
+        mod_depths = @modulation_depth.process(num_frames, start_frame)
+        detunes = @detune.process(num_frames, start_frame)
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          next 0.0 unless active_at?(current_time)
+
+          width = @base_width + (Math.sin(2.0 * Math::PI * @modulation_phase) * mod_depths[index] * 0.5)
+          duty = Deftones::DSP::Helpers.clamp(width, 0.05, 0.95)
+          sample = @phase < duty ? 1.0 : -1.0
+
+          frequency = frequencies[index] * (2.0**(detunes[index].to_f / 1200.0))
+          @phase = (@phase + (frequency / context.sample_rate)) % 1.0
+          @modulation_phase = (@modulation_phase + (mod_frequencies[index] / context.sample_rate)) % 1.0
+          sample
+        end
+      end
+
+      alias modulationFrequency modulation_frequency
+      alias modulationDepth modulation_depth
+    end
+  end
+end

data/lib/deftones/source/tone_buffer_source.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class ToneBufferSource < Player
+      attr_accessor :curve, :fade_in, :fade_out, :onended
+      attr_reader :detune, :start_gain
+
+      def initialize(buffer:, playback_rate: 1.0, detune: 0.0, fade_in: 0.0, fade_out: 0.0, curve: :linear,
+                     context: Deftones.context, **options)
+        super(buffer: buffer, playback_rate: playback_rate, context: context, **options)
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        @fade_in = fade_in.to_f
+        @fade_out = fade_out.to_f
+        @curve = curve.to_sym
+        @start_gain = 1.0
+        @onended = nil
+        @ended_notified = false
+      end
+
+      def playback_rate=(value)
+        @playback_rate.value = value
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def start(time = nil, offset = nil, duration = nil, gain: 1.0)
+        seek(offset) if offset
+        @start_gain = gain.to_f
+        @ended_notified = false
+        super(time)
+        self.stop(@start_time + Deftones::Music::Time.parse(duration)) if duration
+        self
+      end
+
+      def cancel_stop
+        @stop_time = nil
+        self
+      end
+
+      def state(time = context.current_time)
+        active_at?(resolve_time(time)) ? :started : :stopped
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        rates = @playback_rate.process(num_frames, start_frame)
+        detunes = @detune.process(num_frames, start_frame)
+        return process_multichannel_buffer(num_frames, start_frame, rates, detunes) if multichannel_process?
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          notify_ended(current_time) if @stop_time && current_time >= @stop_time
+          next 0.0 unless active_at?(current_time)
+
+          rate = rates[index] * detune_ratio(detunes[index])
+          sample_position = sample_position_for(current_time, rate)
+          if sample_position.negative?
+            @stop_time ||= current_time
+            notify_ended(current_time)
+            next 0.0
+          end
+
+          @buffer.sample_at(sample_position) * envelope_gain(current_time)
+        end
+      end
+
+      private
+
+      def process_multichannel_buffer(num_frames, start_frame, rates, detunes)
+        output = Array.new(@buffer.channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          notify_ended(current_time) if @stop_time && current_time >= @stop_time
+          next unless active_at?(current_time)
+
+          rate = rates[index] * detune_ratio(detunes[index])
+          sample_position = sample_position_for(current_time, rate)
+          if sample_position.negative?
+            @stop_time ||= current_time
+            notify_ended(current_time)
+            next
+          end
+
+          gain = envelope_gain(current_time)
+          @buffer.channels.times do |channel_index|
+            output[channel_index][index] = @buffer.sample_at(sample_position, channel_index) * gain
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def detune_ratio(cents)
+        2.0**(cents.to_f / 1200.0)
+      end
+
+      def envelope_gain(current_time)
+        gain = @start_gain
+        gain *= fade_in_gain(current_time)
+        gain *= fade_out_gain(current_time)
+        gain
+      end
+
+      def fade_in_gain(current_time)
+        return 1.0 if @fade_in <= 0.0
+
+        elapsed = current_time - @start_time
+        shaped_gain(elapsed / @fade_in)
+      end
+
+      def fade_out_gain(current_time)
+        return 1.0 unless @stop_time && @fade_out > 0.0
+
+        remaining = @stop_time - current_time
+        shaped_gain(remaining / @fade_out)
+      end
+
+      def shaped_gain(progress)
+        bounded = progress.clamp(0.0, 1.0)
+        return bounded if @curve == :linear
+
+        Math.sin(bounded * Math::PI * 0.5)
+      end
+
+      def notify_ended(current_time)
+        return if @ended_notified
+
+        @ended_notified = true
+        @onended&.call(current_time)
+      end
+    end
+  end
+end

data/lib/deftones/source/tone_oscillator_node.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class ToneOscillatorNode < Oscillator
+      attr_accessor :onended
+      attr_reader :detune
+
+      def initialize(detune: 0.0, context: Deftones.context, **options)
+        super(context: context, **options)
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        @onended = nil
+        @ended_notified = false
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def state(time = context.current_time)
+        active_at?(resolve_time(time)) ? :started : :stopped
+      end
+
+      def cancel_stop
+        @stop_time = nil
+        self
+      end
+
+      def start(time = nil)
+        @ended_notified = false
+        super
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        generator = GENERATORS.fetch(send(:normalize_type, @type))
+        frequencies = @frequency.process(num_frames, start_frame)
+        detunes = @detune.process(num_frames, start_frame)
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          notify_ended(current_time) if @stop_time && current_time >= @stop_time
+          next 0.0 unless active_at?(current_time)
+
+          sample = generator.call(@phase)
+          frequency = frequencies[index] * detune_ratio(detunes[index])
+          @phase = (@phase + (frequency / context.sample_rate)) % 1.0
+          sample
+        end
+      end
+
+      private
+
+      def detune_ratio(cents)
+        2.0**(cents.to_f / 1200.0)
+      end
+
+      def notify_ended(current_time)
+        return if @ended_notified
+
+        @ended_notified = true
+        @onended&.call(current_time)
+      end
+    end
+  end
+end