deftones 0.1.0

data/lib/deftones/core/audio_block.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class AudioBlock
+      attr_reader :channel_data
+
+      def self.silent(num_frames, channels = 1)
+        from_channel_data(Array.new([channels.to_i, 1].max) { Array.new(num_frames.to_i, 0.0) })
+      end
+
+      def self.from_channel_data(channel_data)
+        normalized = channel_data.map { |channel| channel.map(&:to_f) }
+        new(normalized)
+      end
+
+      def self.from_mono(samples, channels: 1)
+        normalized = samples.map(&:to_f)
+        from_channel_data(Array.new([channels.to_i, 1].max) { normalized.dup })
+      end
+
+      def initialize(channel_data)
+        @channel_data = channel_data
+      end
+
+      def channels
+        @channel_data.length
+      end
+
+      def num_frames
+        @channel_data.first&.length || 0
+      end
+
+      def dup
+        self.class.from_channel_data(@channel_data)
+      end
+
+      def mono
+        return [] if @channel_data.empty?
+        return @channel_data.first.dup if channels == 1
+
+        Array.new(num_frames) do |frame_index|
+          @channel_data.sum { |channel| channel[frame_index] } / channels.to_f
+        end
+      end
+
+      def interleaved
+        Array.new(num_frames * channels) do |index|
+          frame_index = index / channels
+          channel_index = index % channels
+          @channel_data[channel_index][frame_index]
+        end
+      end
+
+      def channel(index)
+        @channel_data[index] || Array.new(num_frames, 0.0)
+      end
+
+      def fit_channels(target_channels)
+        target = [target_channels.to_i, 1].max
+        return dup if target == channels
+        return self.class.from_channel_data([mono]) if target == 1
+
+        if channels == 1
+          return self.class.from_channel_data(Array.new(target) { @channel_data.first.dup })
+        end
+
+        self.class.from_channel_data(Array.new(target) { |index| channel(index % channels).dup })
+      end
+
+      def mix!(other)
+        incoming = other.fit_channels(channels)
+        channels.times do |channel_index|
+          num_frames.times do |frame_index|
+            @channel_data[channel_index][frame_index] += incoming.channel_data[channel_index][frame_index]
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/deftones/core/audio_node.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class AudioNode
+      attr_reader :context, :input
+
+      def initialize(context: Deftones.context)
+        @context = context
+        @input = self
+        @sources = []
+        @destinations = []
+        @disposed = false
+      end
+
+      def output
+        self
+      end
+
+      def connect(destination, output_index: 0, input_index: 0)
+        _ = output_index
+        _ = input_index
+        raise ArgumentError, "destination is required" if destination.nil?
+
+        destination_node = destination.respond_to?(:input) ? destination.input : destination
+        output.attach_destination(destination_node)
+        self
+      end
+
+      def disconnect(destination = nil)
+        if destination
+          destination_node = destination.respond_to?(:input) ? destination.input : destination
+          output.detach_destination(destination_node)
+        else
+          output.detach_all_destinations
+        end
+        self
+      end
+
+      def >>(other)
+        connect(other)
+        other
+      end
+
+      def chain(*nodes)
+        [self, *nodes].each_cons(2) { |source, destination| source.connect(destination) }
+        nodes.last || self
+      end
+
+      def fan(*nodes)
+        nodes.each { |node| connect(node) }
+        self
+      end
+
+      def to_output
+        connect(context.output)
+        self
+      end
+
+      def to_destination
+        to_output
+      end
+
+      def to_master
+        to_destination
+      end
+
+      def now
+        context.current_time
+      end
+
+      def immediate
+        now
+      end
+
+      def to_seconds(time = nil)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+
+      def to_ticks(time = nil)
+        return Deftones.transport.ticks if time.nil?
+
+        Deftones.transport.seconds_to_ticks(to_seconds(time))
+      end
+
+      def to_frequency(value)
+        Deftones::Music::Frequency.parse(value)
+      end
+
+      def to_midi(value)
+        Deftones::Music::Midi.parse(value)
+      end
+
+      def sample_time
+        1.0 / context.sample_rate
+      end
+
+      def block_time
+        context.buffer_size.to_f / context.sample_rate
+      end
+
+      def channel_count
+        context.channels
+      end
+
+      def channel_count_mode
+        "max"
+      end
+
+      def channel_interpretation
+        "speakers"
+      end
+
+      def number_of_inputs
+        1
+      end
+
+      def number_of_outputs
+        1
+      end
+
+      def set(**params)
+        params.each do |key, value|
+          writer = :"#{key}="
+          public_send(writer, value) if respond_to?(writer)
+        end
+        self
+      end
+
+      def get(*keys)
+        keys.flatten.each_with_object({}) do |key, values|
+          reader = key.to_sym
+          values[reader] = public_send(reader) if respond_to?(reader)
+        end
+      end
+
+      def name
+        self.class.name.split("::").last
+      end
+
+      def to_s
+        name
+      end
+
+      alias toDestination to_destination
+      alias toMaster to_master
+      alias toSeconds to_seconds
+      alias toTicks to_ticks
+      alias toFrequency to_frequency
+      alias toMidi to_midi
+      alias sampleTime sample_time
+      alias blockTime block_time
+      alias channelCount channel_count
+      alias channelCountMode channel_count_mode
+      alias channelInterpretation channel_interpretation
+      alias numberOfInputs number_of_inputs
+      alias numberOfOutputs number_of_outputs
+      alias toString to_s
+
+      def dispose
+        disconnect
+        @sources.dup.each { |source| source.detach_destination(self) }
+        @sources.clear
+        @disposed = true
+        self
+      end
+
+      def disposed?
+        @disposed
+      end
+
+      def render(num_frames, start_frame = 0, cache = {})
+        render_block(num_frames, start_frame, cache).mono
+      end
+
+      protected
+
+      def render_block(num_frames, start_frame = 0, cache = {})
+        cache_key = [object_id, :block, start_frame, num_frames]
+        return cache.fetch(cache_key).dup if cache.key?(cache_key)
+
+        output_block = if uses_legacy_render_for_block?
+                         normalize_output_block(render(num_frames, start_frame, cache), num_frames, 1)
+                       else
+                         input_block = mix_source_blocks(num_frames, start_frame, cache)
+                         if multichannel_process?
+                           normalize_output_block(process(input_block, num_frames, start_frame, cache), num_frames, input_block.channels)
+                         else
+                           mono_output = process(input_block.mono, num_frames, start_frame, cache)
+                           normalize_output_block(mono_output, num_frames, [input_block.channels, default_output_channels].max)
+                         end
+                       end
+
+        cache[cache_key] = output_block
+        output_block.dup
+      end
+
+      def attach_source(source)
+        return if @sources.include?(source)
+
+        @sources << source
+      end
+
+      def detach_source(source)
+        @sources.delete(source)
+      end
+
+      def attach_destination(destination)
+        return if @destinations.include?(destination)
+
+        @destinations << destination
+        destination.attach_source(self)
+      end
+
+      def detach_destination(destination)
+        return unless @destinations.delete(destination)
+
+        destination.detach_source(self)
+      end
+
+      def detach_all_destinations
+        @destinations.dup.each { |destination| detach_destination(destination) }
+      end
+
+      def mix_source_blocks(num_frames, start_frame, cache)
+        blocks = @sources.map { |source| source.send(:render_block, num_frames, start_frame, cache) }
+        output_channels = blocks.map(&:channels).max || default_input_channels
+        mixed = AudioBlock.silent(num_frames, output_channels)
+        blocks.each { |block| mixed.mix!(block) }
+        mixed
+      end
+
+      def normalize_output_block(output, num_frames, channels)
+        return output.dup if output.is_a?(AudioBlock)
+
+        AudioBlock.from_mono(output, channels: channels)
+      end
+
+      def process(input_buffer, _num_frames, _start_frame, _cache)
+        input_buffer
+      end
+
+      def uses_legacy_render_for_block?
+        self.class.instance_method(:render).owner != AudioNode
+      end
+
+      def multichannel_process?
+        false
+      end
+
+      def default_input_channels
+        1
+      end
+
+      def default_output_channels
+        default_input_channels
+      end
+    end
+  end
+end

data/lib/deftones/core/clock.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class Clock < Emitter
+      attr_reader :context, :frequency, :state
+
+      def initialize(frequency: 1.0, context: Deftones.context, &block)
+        super()
+        @context = context
+        @frequency = Signal.new(value: frequency, units: :frequency, context: context)
+        @state = :stopped
+        @start_time = 0.0
+        @offset_ticks = 0.0
+        on(:tick, &block) if block
+      end
+
+      def start(time = nil, offset: nil)
+        @start_time = resolve_time(time)
+        @offset_ticks = offset.to_f if offset
+        @state = :started
+        self
+      end
+
+      def stop(time = nil)
+        @offset_ticks = ticks_at(resolve_time(time))
+        @start_time = resolve_time(time)
+        @state = :stopped
+        self
+      end
+
+      def pause(time = nil)
+        @offset_ticks = ticks_at(resolve_time(time))
+        @start_time = resolve_time(time)
+        @state = :paused
+        self
+      end
+
+      def ticks(time = context.current_time)
+        ticks_at(resolve_time(time))
+      end
+
+      def seconds(time = context.current_time)
+        ticks(time) / current_frequency
+      end
+
+      def next_tick_time(time = context.current_time)
+        tick_duration = 1.0 / current_frequency
+        current_ticks = ticks(time)
+        next_tick = current_ticks.floor + 1
+        resolve_time(time) + ((next_tick - current_ticks) * tick_duration)
+      end
+
+      def get_ticks_at_time(time)
+        ticks(time)
+      end
+
+      def emit_ticks_until(time)
+        return self unless state == :started
+
+        current_time = resolve_time(time)
+        emitted_ticks = (@last_emitted_tick || @offset_ticks.floor) + 1
+        while emitted_ticks <= ticks_at(current_time).floor
+          emit(:tick, emitted_ticks)
+          emitted_ticks += 1
+        end
+        @last_emitted_tick = emitted_ticks - 1
+        self
+      end
+
+      alias getTicksAtTime get_ticks_at_time
+      alias nextTickTime next_tick_time
+
+      private
+
+      def resolve_time(value)
+        value.nil? ? context.current_time : Deftones::Music::Time.parse(value)
+      end
+
+      def ticks_at(time)
+        return @offset_ticks unless state == :started
+
+        @offset_ticks + ([time - @start_time, 0.0].max * current_frequency)
+      end
+
+      def current_frequency
+        [frequency.value.to_f, 1.0e-6].max
+      end
+    end
+  end
+end

data/lib/deftones/core/computed_signal.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class ComputedSignal < Signal
+      attr_reader :input
+
+      def initialize(input:, units: nil, context: nil)
+        resolved_context = resolve_context(input, fallback: context)
+        resolved_units = units || default_units(input)
+
+        super(value: 0.0, units: resolved_units, context: resolved_context)
+        @input = coerce_signal(input || 0.0, units: resolved_units)
+      end
+
+      def value
+        value_at(context.current_time)
+      end
+
+      def value=(_new_value)
+        raise Deftones::Error, "#{self.class.name} is derived and cannot be assigned"
+      end
+
+      def ramp_to(*)
+        raise Deftones::Error, "#{self.class.name} is derived and cannot be automated directly"
+      end
+
+      alias linear_ramp_to ramp_to
+      alias exponential_ramp_to ramp_to
+      alias set_value_at_time ramp_to
+      alias cancel_scheduled_values ramp_to
+
+      def process(num_frames, start_frame = 0)
+        Array.new(num_frames) do |offset|
+          value_at(sample_time(start_frame + offset))
+        end
+      end
+
+      private
+
+      def default_units(candidate)
+        candidate.respond_to?(:units) ? candidate.units : :number
+      end
+
+      def resolve_context(candidate, fallback:)
+        return candidate.context if candidate.respond_to?(:context)
+        return fallback if fallback
+
+        Deftones.context
+      end
+
+      def coerce_signal(value, units:)
+        return value if value.respond_to?(:value_at)
+
+        Signal.new(value: value, units: units, context: context)
+      end
+
+      def exponentiate(value, exponent)
+        return value**exponent if value >= 0.0 || integer_like?(exponent)
+
+        -((-value)**exponent)
+      end
+
+      def integer_like?(value)
+        value.finite? && value.round == value
+      end
+    end
+  end
+end

data/lib/deftones/core/delay.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class Delay < AudioNode
+      attr_reader :delay_time, :max_delay
+
+      def initialize(delay_time: 0.0, max_delay: 1.0, context: Deftones.context)
+        super(context: context)
+        @delay_time = Signal.new(value: delay_time, units: :time, context: context)
+        @max_delay = [max_delay.to_f, @delay_time.value].max
+        @delay_lines = []
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        delay_values = @delay_time.process(num_frames, start_frame)
+        AudioBlock.from_channel_data(
+          input_block.channel_data.each_with_index.map do |channel, channel_index|
+            delay_line = ensure_delay_line(channel_index)
+            Array.new(num_frames) do |index|
+              delay_seconds = [delay_values[index], 0.0].max
+              delay_samples = [delay_seconds * context.sample_rate, @max_delay * context.sample_rate].min
+              delay_line.tap(delay_samples, input_sample: channel[index], feedback: 0.0)
+            end
+          end
+        )
+      end
+
+      private
+
+      def ensure_delay_line(channel_index)
+        required = [channel_index.to_i, 0].max
+        while @delay_lines.length <= required
+          @delay_lines << DSP::DelayLine.new((@max_delay * context.sample_rate).ceil)
+        end
+        @delay_lines[required]
+      end
+    end
+  end
+end

data/lib/deftones/core/effect.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class Effect < AudioNode
+      attr_reader :wet
+
+      def initialize(wet: 1.0, context: Deftones.context)
+        super(context: context)
+        @wet = Signal.new(value: wet, units: :number, context: context)
+      end
+
+      def wet=(value)
+        @wet.value = value
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, cache)
+        wet_values = @wet.process(num_frames, start_frame)
+        wet_block = process_effect_block(input_block.dup, num_frames, start_frame, cache)
+        output_channels = [input_block.channels, wet_block.channels].max
+        dry_block = input_block.fit_channels(output_channels)
+        wet_block = wet_block.fit_channels(output_channels)
+
+        AudioBlock.from_channel_data(
+          Array.new(output_channels) do |channel_index|
+            Array.new(num_frames) do |frame_index|
+              DSP::Helpers.mix(
+                dry_block.channel_data[channel_index][frame_index],
+                wet_block.channel_data[channel_index][frame_index],
+                wet_values[frame_index].clamp(0.0, 1.0)
+              )
+            end
+          end
+        )
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, cache)
+        AudioBlock.from_channel_data(
+          input_block.channel_data.each_with_index.map do |channel, channel_index|
+            normalize_channel_output(
+              process_effect(channel, num_frames, start_frame, cache, channel_index: channel_index),
+              num_frames
+            )
+          end
+        )
+      end
+
+      def process_effect(input_buffer, _num_frames, _start_frame, _cache, channel_index: 0)
+        input_buffer
+      end
+
+      def normalize_channel_output(output, num_frames)
+        normalized = Array(output).map(&:to_f)
+        return normalized.first(num_frames) if normalized.length >= num_frames
+
+        normalized + Array.new(num_frames - normalized.length, 0.0)
+      end
+    end
+  end
+end

data/lib/deftones/core/emitter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class Emitter
+      def initialize
+        @listeners = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def on(event_name, &block)
+        raise ArgumentError, "block is required" unless block
+
+        @listeners[event_name.to_sym] << block
+        self
+      end
+
+      def once(event_name, &block)
+        raise ArgumentError, "block is required" unless block
+
+        wrapper = nil
+        wrapper = proc do |*arguments|
+          off(event_name, wrapper)
+          block.call(*arguments)
+        end
+        on(event_name, &wrapper)
+      end
+
+      def off(event_name, listener = nil)
+        key = event_name.to_sym
+        return @listeners.delete(key) unless listener
+
+        @listeners[key].delete(listener)
+        self
+      end
+
+      def emit(event_name, *arguments)
+        @listeners[event_name.to_sym].dup.each { |listener| listener.call(*arguments) }
+        self
+      end
+
+      def listeners(event_name)
+        @listeners[event_name.to_sym].dup
+      end
+
+      def dispose
+        @listeners.clear
+        self
+      end
+    end
+  end
+end

data/lib/deftones/core/gain.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class Gain < AudioNode
+      attr_reader :gain
+
+      def initialize(gain: 1.0, context: Deftones.context)
+        super(context: context)
+        @gain = Signal.new(value: gain, units: :number, context: context)
+      end
+
+      def gain=(value)
+        @gain.value = value
+      end
+
+      def process(input_buffer, num_frames, start_frame, _cache)
+        gain_values = @gain.process(num_frames, start_frame)
+
+        Array.new(num_frames) do |index|
+          input_buffer[index] * gain_values[index]
+        end
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        gain_values = @gain.process(num_frames, start_frame)
+        AudioBlock.from_channel_data(
+          input_block.channel_data.map do |channel|
+            Array.new(num_frames) { |index| channel[index] * gain_values[index] }
+          end
+        )
+      end
+    end
+  end
+end