deftones 0.1.0

data/lib/deftones/core/signal_operators.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class BinarySignal < ComputedSignal
+      attr_reader :other
+
+      def initialize(input:, other:, units: nil, context: nil)
+        super(input: input, units: units, context: context)
+        @other = coerce_signal(other, units: @units)
+      end
+
+      def value_at(time)
+        compute(@input.value_at(time), @other.value_at(time), time)
+      end
+    end
+
+    class Add < BinarySignal
+      def initialize(input:, addend:, units: nil, context: nil)
+        super(input: input, other: addend, units: units, context: context)
+      end
+
+      def compute(left, right, _time)
+        left + right
+      end
+    end
+
+    class Subtract < BinarySignal
+      def initialize(input:, subtrahend:, units: nil, context: nil)
+        super(input: input, other: subtrahend, units: units, context: context)
+      end
+
+      def compute(left, right, _time)
+        left - right
+      end
+    end
+
+    class Multiply < BinarySignal
+      def initialize(input:, factor:, units: nil, context: nil)
+        super(input: input, other: factor, units: units, context: context)
+      end
+
+      def compute(left, right, _time)
+        left * right
+      end
+    end
+
+    class GreaterThan < BinarySignal
+      def initialize(input:, threshold:, context: nil)
+        super(input: input, other: threshold, units: :number, context: context)
+      end
+
+      def compute(left, right, _time)
+        left > right ? 1.0 : 0.0
+      end
+    end
+
+    class GreaterThanZero < GreaterThan
+      def initialize(input:, context: nil)
+        super(input: input, threshold: 0.0, context: context)
+      end
+    end
+
+    class Negate < ComputedSignal
+      def value_at(time)
+        -@input.value_at(time)
+      end
+    end
+
+    class Abs < ComputedSignal
+      def value_at(time)
+        @input.value_at(time).abs
+      end
+    end
+
+    class Pow < ComputedSignal
+      attr_reader :exponent
+
+      def initialize(input:, exponent:, context: nil)
+        super(input: input, units: :number, context: context)
+        @exponent = coerce_signal(exponent, units: :number)
+      end
+
+      def value_at(time)
+        exponentiate(@input.value_at(time), @exponent.value_at(time))
+      end
+    end
+
+    class Scale < ComputedSignal
+      attr_reader :min, :max
+
+      def initialize(input:, min:, max:, context: nil)
+        super(input: input, units: :number, context: context)
+        @min = coerce_signal(min, units: :number)
+        @max = coerce_signal(max, units: :number)
+      end
+
+      def value_at(time)
+        min_value = @min.value_at(time)
+        max_value = @max.value_at(time)
+
+        min_value + ((max_value - min_value) * @input.value_at(time))
+      end
+    end
+
+    class ScaleExp < Scale
+      attr_reader :exponent
+
+      def initialize(input:, min:, max:, exponent: 2.0, context: nil)
+        super(input: input, min: min, max: max, context: context)
+        @exponent = coerce_signal(exponent, units: :number)
+      end
+
+      def value_at(time)
+        min_value = @min.value_at(time)
+        max_value = @max.value_at(time)
+        scaled = exponentiate(@input.value_at(time), @exponent.value_at(time))
+
+        min_value + ((max_value - min_value) * scaled)
+      end
+    end
+
+    class AudioToGain < ComputedSignal
+      def value_at(time)
+        @input.value_at(time)
+      end
+    end
+
+    class GainToAudio < AudioToGain
+    end
+
+    class Zero < Signal
+      def initialize(context: Deftones.context)
+        super(value: 0.0, units: :number, context: context)
+      end
+    end
+  end
+end

data/lib/deftones/core/signal_shapers.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class EqualPowerGain < ComputedSignal
+      def initialize(input:, context: nil)
+        super(input: input, units: :number, context: context)
+      end
+
+      def value_at(time)
+        Math.sin(@input.value_at(time).clamp(0.0, 1.0) * Math::PI * 0.5)
+      end
+    end
+
+    class Modulo < BinarySignal
+      def initialize(input:, modulus:, context: nil)
+        super(input: input, other: modulus, units: :number, context: context)
+      end
+
+      def compute(left, right, _time)
+        return 0.0 if right.zero?
+
+        ((left % right) + right) % right
+      end
+    end
+
+    class Normalize < ComputedSignal
+      attr_reader :min, :max
+
+      def initialize(input:, min:, max:, context: nil)
+        super(input: input, units: :number, context: context)
+        @min = coerce_signal(min, units: :number)
+        @max = coerce_signal(max, units: :number)
+      end
+
+      def value_at(time)
+        min_value = @min.value_at(time)
+        max_value = @max.value_at(time)
+        span = max_value - min_value
+        return 0.0 if span.zero?
+
+        (@input.value_at(time) - min_value) / span
+      end
+    end
+
+    class WaveShaper < ComputedSignal
+      def initialize(input:, curve: nil, mapping: nil, context: nil, &block)
+        super(input: input, units: :number, context: context)
+        @mapping = mapping || block
+        @curve = normalize_curve(curve)
+        raise ArgumentError, "curve or mapping is required" unless @mapping || @curve
+      end
+
+      def value_at(time)
+        sample = @input.value_at(time)
+        return @mapping.call(sample, time) if @mapping
+
+        sample_curve(sample)
+      end
+
+      private
+
+      def normalize_curve(curve)
+        return if curve.nil?
+
+        values = curve.to_a.map(&:to_f)
+        raise ArgumentError, "curve must contain at least two points" if values.length < 2
+
+        values.freeze
+      end
+
+      def sample_curve(sample)
+        position = ((sample.clamp(-1.0, 1.0) + 1.0) * 0.5) * (@curve.length - 1)
+        index = position.floor
+        upper_index = [index + 1, @curve.length - 1].min
+        lower = @curve[index]
+        upper = @curve[upper_index]
+
+        lower + ((upper - lower) * (position - index))
+      end
+    end
+  end
+end

data/lib/deftones/core/source.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class Source < AudioNode
+      class VolumeProxy
+        attr_reader :source
+        attr_accessor :value
+
+        def initialize(source, value: 0.0)
+          @source = source
+          @value = value.to_f
+        end
+
+        def value=(new_value)
+          @value = new_value.to_f
+          source.send(:apply_volume!)
+        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
+      attr_accessor :onstop
+      attr_accessor :mute
+
+      def initialize(context: Deftones.context)
+        super(context: context)
+        @input = nil
+        @volume = VolumeProxy.new(self)
+        @mute = false
+        @start_time = Float::INFINITY
+        @stop_time = nil
+        @onstop = nil
+        @stop_notified = false
+        @synced = false
+        @transport_event_ids = {}
+        apply_volume!
+      end
+
+      def number_of_inputs
+        0
+      end
+
+      def volume=(value)
+        @volume.value = value
+      end
+
+      def mute=(value)
+        @mute = !!value
+        apply_volume!
+      end
+
+      def mute?
+        @mute
+      end
+
+      def source_type
+        class_name = self.class.name.split("::").last
+        words = class_name
+          .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase
+          .split("_")
+
+        [words.first, *words.drop(1).map(&:capitalize)].join
+      end
+
+      def start(time = nil)
+        return schedule_transport_event(:start, time) if synced?
+
+        @start_time = resolve_time(time)
+        @stop_time = nil if @stop_time && @stop_time <= @start_time
+        @stop_notified = false
+        self
+      end
+
+      def stop(time = nil)
+        return schedule_transport_event(:stop, time) if synced?
+
+        @stop_time = resolve_time(time)
+        self
+      end
+
+      def restart(time = nil)
+        stop(time)
+        start(time)
+      end
+
+      def cancel_stop
+        clear_transport_event(:stop)
+        @stop_time = nil
+        self
+      end
+
+      def state(time = context.current_time)
+        active_at?(resolve_time(time)) ? :started : :stopped
+      end
+
+      def sync
+        @synced = true
+        self
+      end
+
+      def unsync
+        @synced = false
+        clear_transport_event(:start)
+        clear_transport_event(:stop)
+        self
+      end
+
+      def synced?
+        @synced
+      end
+
+      def active_at?(time)
+        return false if time < @start_time
+        return true if @stop_time.nil?
+
+        time < @stop_time
+      end
+
+      def render(num_frames, start_frame = 0, cache = {})
+        output_buffer = super.map { |sample| sample * @output_gain }
+        notify_stop_in_window(start_frame, num_frames)
+        output_buffer
+      end
+
+      def render_block(num_frames, start_frame = 0, cache = {})
+        output_block = super
+        scaled = AudioBlock.from_channel_data(
+          output_block.channel_data.map do |channel|
+            channel.map { |sample| sample * @output_gain }
+          end
+        )
+        notify_stop_in_window(start_frame, num_frames)
+        scaled
+      end
+
+      def dispose
+        unsync
+        super
+      end
+
+      alias cancelStop cancel_stop
+      alias numberOfInputs number_of_inputs
+      alias sourceType source_type
+
+      private
+
+      def uses_legacy_render_for_block?
+        false
+      end
+
+      def apply_volume!
+        @output_gain = mute ? 0.0 : Deftones.db_to_gain(@volume.value)
+        self
+      end
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+
+      def resolve_transport_time(time)
+        return Deftones.transport.seconds if time.nil?
+
+        time
+      end
+
+      def schedule_transport_event(kind, time)
+        clear_transport_event(kind)
+        @transport_event_ids[kind] = Deftones.transport.schedule(resolve_transport_time(time)) do |scheduled_time|
+          if kind == :start
+            @start_time = scheduled_time
+            @stop_time = nil if @stop_time && @stop_time <= @start_time
+            @stop_notified = false
+          else
+            @stop_time = scheduled_time
+          end
+        end
+        self
+      end
+
+      def clear_transport_event(kind)
+        event_id = @transport_event_ids.delete(kind)
+        return self unless event_id
+
+        Deftones.transport.clear(event_id)
+        self
+      end
+
+      def notify_stop_in_window(start_frame, num_frames)
+        return unless @stop_time
+        return if @stop_notified
+
+        start_time = start_frame.to_f / context.sample_rate
+        end_time = (start_frame + num_frames).to_f / context.sample_rate
+        return unless @stop_time >= start_time && @stop_time <= end_time
+
+        @stop_notified = true
+        @onstop&.call(@stop_time)
+      end
+    end
+  end
+end

data/lib/deftones/core/synced_signal.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Core
+    class SyncedSignal < Signal
+      attr_reader :transport
+
+      def initialize(transport: Deftones.transport, **options)
+        @transport = transport
+        @synced = true
+        super(**options)
+      end
+
+      def value
+        value_at(current_base_time)
+      end
+
+      def sync
+        @synced = true
+        self
+      end
+
+      def unsync
+        @synced = false
+        self
+      end
+
+      def synced?
+        @synced
+      end
+
+      def linear_ramp_to(target_value, duration)
+        resolved_end = current_base_time + Deftones::Music::Time.parse(duration)
+        schedule_automation(
+          :linear,
+          coerce_value(target_value),
+          start_time: resolve_automation_start_time(resolved_end),
+          end_time: resolved_end
+        )
+      end
+
+      def exponential_ramp_to(target_value, duration)
+        resolved_end = current_base_time + Deftones::Music::Time.parse(duration)
+        schedule_automation(
+          :exponential,
+          coerce_value(target_value),
+          start_time: resolve_automation_start_time(resolved_end),
+          end_time: resolved_end
+        )
+      end
+
+      def process(num_frames, start_frame = 0)
+        timeline_offset = synced? ? transport.seconds : 0.0
+
+        Array.new(num_frames) do |offset|
+          value_at(timeline_offset + sample_time(start_frame + offset))
+        end
+      end
+
+      private
+
+      def current_base_time
+        synced? ? transport.seconds : context.current_time
+      end
+
+      def resolve_time(time)
+        return current_base_time if time.nil?
+        return super unless synced?
+
+        Deftones::Music::Time.parse(
+          time,
+          bpm: transport.bpm,
+          time_signature: transport.time_signature,
+          ppq: transport.ppq
+        )
+      end
+
+      def resolve_automation_start_time(end_time)
+        anchors = @events.filter_map do |event|
+          anchor = automation_anchor_time(event)
+          anchor if anchor <= end_time
+        end
+
+        anchors.max || current_base_time
+      end
+    end
+  end
+end

data/lib/deftones/destination.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Deftones
+  class Destination
+    class VolumeProxy
+      attr_reader :destination
+      attr_accessor :value
+
+      def initialize(destination, value: 0.0)
+        @destination = destination
+        @value = value.to_f
+      end
+
+      def value=(new_value)
+        @value = new_value.to_f
+        destination.apply_volume!
+      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
+
+      def set_value_at_time(target_value, _time)
+        self.value = target_value
+        self
+      end
+    end
+
+    attr_reader :context, :volume
+    attr_accessor :mute
+
+    class << self
+      def node(context: Deftones.context)
+        registry[context.object_id] ||= new(context: context)
+      end
+
+      def reset!
+        @registry = {}
+        self
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        return super unless node.respond_to?(method_name)
+
+        node.public_send(method_name, *arguments, &block)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        node.respond_to?(method_name, include_private) || super
+      end
+
+      private
+
+      def registry
+        @registry ||= {}
+      end
+    end
+
+    def initialize(context:)
+      @context = context
+      @volume = VolumeProxy.new(self)
+      @mute = false
+      apply_volume!
+    end
+
+    def input
+      node
+    end
+
+    def output
+      node
+    end
+
+    def node
+      context.output
+    end
+
+    def mute=(value)
+      @mute = !!value
+      apply_volume!
+    end
+
+    def mute?
+      @mute
+    end
+
+    def name
+      "Destination"
+    end
+
+    def sample_time
+      1.0 / context.sample_rate
+    end
+
+    def block_time
+      context.buffer_size.to_f / context.sample_rate
+    end
+
+    def max_channel_count
+      context.channels
+    end
+
+    def connect(*arguments, **keywords)
+      node.connect(*arguments, **keywords)
+    end
+
+    def disconnect(*arguments)
+      node.disconnect(*arguments)
+    end
+
+    def chain(*nodes)
+      node.chain(*nodes)
+    end
+
+    def fan(*nodes)
+      node.fan(*nodes)
+    end
+
+    def apply_volume!
+      node.gain.value = mute ? 0.0 : Deftones.db_to_gain(@volume.value)
+      self
+    end
+
+    alias sampleTime sample_time
+    alias blockTime block_time
+    alias maxChannelCount max_channel_count
+  end
+end