deftones 0.1.0 → 1.0.0

data/lib/deftones/core/signal.rb

@@ -9,6 +9,7 @@ module Deftones
 
       attr_reader :context, :units, :input, :output, :default_value
       attr_accessor :min_value, :max_value, :convert_values
+      attr_reader :clamp_values
 
       def initialize(value: 0.0, units: :number, context: Deftones.context)
         @context = context
@@ -21,6 +22,8 @@ module Deftones
         @min_value = -Float::INFINITY
         @max_value = Float::INFINITY
         @events = []
+        @next_event_order = 0
+        @clamp_values = false
         @disposed = false
       end
 
@@ -29,7 +32,7 @@ module Deftones
       end
 
       def value=(new_value)
-        @base_value = coerce_value(new_value)
+        @base_value = bounded_value(coerce_value(new_value))
         @events.clear
       end
 
@@ -50,7 +53,7 @@ module Deftones
         resolved_end = context.current_time + Deftones::Music::Time.parse(duration)
         schedule_automation(
           :linear,
-          coerce_value(target_value),
+          bounded_value(coerce_value(target_value)),
           start_time: resolve_automation_start_time(resolved_end),
           end_time: resolved_end
         )
@@ -60,7 +63,7 @@ module Deftones
         resolved_end = resolve_time(end_time)
         schedule_automation(
           :linear,
-          coerce_value(target_value),
+          bounded_value(coerce_value(target_value)),
           start_time: resolve_automation_start_time(resolved_end),
           end_time: resolved_end
         )
@@ -70,7 +73,7 @@ module Deftones
         resolved_end = context.current_time + Deftones::Music::Time.parse(duration)
         schedule_automation(
           :exponential,
-          coerce_value(target_value),
+          bounded_value(coerce_value(target_value)),
           start_time: resolve_automation_start_time(resolved_end),
           end_time: resolved_end
         )
@@ -80,45 +83,42 @@ module Deftones
         resolved_end = resolve_time(end_time)
         schedule_automation(
           :exponential,
-          coerce_value(target_value),
+          bounded_value(coerce_value(target_value)),
           start_time: resolve_automation_start_time(resolved_end),
           end_time: resolved_end
         )
       end
 
       def set_value_at_time(target_value, time)
-        @events << { type: :set, time: resolve_time(time), value: coerce_value(target_value) }
-        sort_events!
+        add_event(type: :set, time: resolve_time(time), value: bounded_value(coerce_value(target_value)))
         self
       end
 
       def set_value_curve_at_time(values, start_time, duration)
-        curve = Array(values).map { |value| coerce_value(value) }
+        curve = Array(values).map { |value| bounded_value(coerce_value(value)) }
         resolved_start = resolve_time(start_time)
         resolved_duration = Deftones::Music::Time.parse(duration)
-        @events << {
+        add_event(
           type: :curve,
           time: resolved_start,
           start_time: resolved_start,
           end_time: resolved_start + resolved_duration,
           duration: resolved_duration,
           values: curve
-        }
-        sort_events!
+        )
         self
       end
 
       def set_target_at_time(target_value, start_time, time_constant)
         resolved_start = resolve_time(start_time)
-        @events << {
+        add_event(
           type: :target,
           time: resolved_start,
           start_time: resolved_start,
           time_constant: [Deftones::Music::Time.parse(time_constant), 1.0e-6].max,
           from: value_at(resolved_start),
-          to: coerce_value(target_value)
-        }
-        sort_events!
+          to: bounded_value(coerce_value(target_value))
+        )
         self
       end
 
@@ -152,6 +152,11 @@ module Deftones
         value_at(resolve_time(time))
       end
 
+      def clamp_values=(value)
+        @clamp_values = !!value
+        @base_value = bounded_value(@base_value)
+      end
+
       def dispose
         @events.clear
         @disposed = true
@@ -174,9 +179,9 @@ module Deftones
       alias getValueAtTime get_value_at_time
 
       def connect(destination, output_index: 0, input_index: 0)
-        _ = output_index
-        _ = input_index
-        return self if destination.nil?
+        raise ArgumentError, "destination is required" if destination.nil?
+        raise ArgumentError, "output_index must be 0 for Signal connections" unless Integer(output_index).zero?
+        raise ArgumentError, "input_index must be 0 for Signal connections" unless Integer(input_index).zero?
 
         if destination.respond_to?(:value=)
           destination.value = value
@@ -190,7 +195,10 @@ module Deftones
         self
       end
 
-      def set(**params)
+      def set(strict: false, **params)
+        unknown = params.keys.reject { |key| respond_to?(:"#{key}=") }
+        raise ArgumentError, "Unknown parameter(s): #{unknown.join(', ')}" if strict && unknown.any?
+
         params.each do |key, entry|
           writer = :"#{key}="
           public_send(writer, entry) if respond_to?(writer)
@@ -198,11 +206,19 @@ module Deftones
         self
       end
 
-      def get(*keys)
-        keys.flatten.each_with_object({}) do |key, values|
+      def get(*keys, strict: false)
+        unknown = []
+        values = keys.flatten.each_with_object({}) do |key, collected|
           reader = key.to_sym
-          values[reader] = public_send(reader) if respond_to?(reader)
+          if respond_to?(reader)
+            collected[reader] = public_send(reader)
+          else
+            unknown << reader
+          end
         end
+        raise ArgumentError, "Unknown parameter(s): #{unknown.join(', ')}" if strict && unknown.any?
+
+        values
       end
 
       def get_defaults
@@ -252,6 +268,8 @@ module Deftones
       alias minValue= min_value=
       alias maxValue max_value
       alias maxValue= max_value=
+      alias clampValues clamp_values
+      alias clampValues= clamp_values=
       alias defaultValue default_value
       alias getDefaults get_defaults
       alias toSeconds to_seconds
@@ -261,11 +279,24 @@ module Deftones
       alias exponentialApproachValueAtTime exponential_approach_value_at_time
 
       def process(num_frames, start_frame = 0)
+        return Array.new(num_frames, bounded_value(@base_value)) if @events.empty?
+
         Array.new(num_frames) do |offset|
           value_at(sample_time(start_frame + offset))
         end
       end
 
+      def automation_event_count
+        @events.length
+      end
+
+      def automation_events?
+        @events.any?
+      end
+
+      alias automationEventCount automation_event_count
+      alias automationEvents? automation_events?
+
       def value_at(time)
         current_value = @base_value
 
@@ -300,14 +331,14 @@ module Deftones
           end
         end
 
-        current_value
+        bounded_value(current_value)
       end
 
       private
 
       def schedule_automation(type, target_value, start_time:, end_time:)
         duration_in_seconds = [end_time.to_f - start_time.to_f, 0.0].max
-        @events << {
+        add_event(
           type: type,
           start_time: start_time,
           end_time: end_time,
@@ -315,13 +346,26 @@ module Deftones
           duration: duration_in_seconds,
           from: value_at(start_time),
           to: target_value
-        }
-        sort_events!
+        )
         self
       end
 
-      def sort_events!
-        @events.sort_by! { |event| event.fetch(:time, event[:start_time]) }
+      def add_event(event)
+        event[:order] = @next_event_order
+        @next_event_order += 1
+        insert_event(event)
+      end
+
+      def insert_event(event)
+        key = event_sort_key(event)
+        index = @events.bsearch_index { |existing| (event_sort_key(existing) <=> key).positive? }
+        return @events << event unless index
+
+        @events.insert(index, event)
+      end
+
+      def event_sort_key(event)
+        [event.fetch(:time, event[:start_time]), event.fetch(:order, 0)]
       end
 
       def resolve_automation_start_time(end_time)
@@ -447,6 +491,13 @@ module Deftones
       def db_to_gain(value)
         10.0**(value / 20.0)
       end
+
+      def bounded_value(value)
+        return value unless @clamp_values
+        return value unless value.is_a?(Numeric)
+
+        value.clamp(@min_value, @max_value)
+      end
     end
   end
 end

data/lib/deftones/core/source.rb

@@ -5,30 +5,91 @@ module Deftones
     class Source < AudioNode
       class VolumeProxy
         attr_reader :source
-        attr_accessor :value
 
         def initialize(source, value: 0.0)
           @source = source
           @value = value.to_f
+          @automation = Signal.new(value: @value, units: :number, context: source.context)
+        end
+
+        def value
+          @value
         end
 
         def value=(new_value)
           @value = new_value.to_f
+          @automation.value = @value
           source.send(:apply_volume!)
         end
 
-        def ramp_to(target_value, _duration = nil)
-          self.value = target_value
+        def ramp_to(target_value, duration = nil)
+          return assign_immediately(target_value) if duration.nil?
+
+          resolved_duration = Deftones::Music::Time.parse(duration)
+          return assign_immediately(target_value) if resolved_duration <= 0.0
+
+          @value = target_value.to_f
+          @automation.linear_ramp_to_value_at_time(@value, source.context.current_time + resolved_duration)
+          source.send(:apply_volume!)
+          self
+        end
+
+        def set_value_at_time(target_value, time)
+          @value = target_value.to_f
+          @automation.set_value_at_time(@value, time)
+          source.send(:apply_volume!)
+          self
+        end
+
+        def gains(num_frames, start_frame)
+          return Array.new(num_frames, 0.0) if source.mute?
+
+          @automation.process(num_frames, start_frame).map { |db| Deftones.db_to_gain(db) }
+        end
+
+        def current_gain
+          return 0.0 if source.mute?
+
+          Deftones.db_to_gain(@automation.get_value_at_time(source.context.current_time))
+        end
+
+        def cancel_scheduled_values(after_time = 0)
+          @automation.cancel_scheduled_values(after_time)
           self
         end
 
-        alias linear_ramp_to ramp_to
-        alias exponential_ramp_to ramp_to
+        def cancel_and_hold_at_time(time)
+          @automation.cancel_and_hold_at_time(time)
+          @value = @automation.get_value_at_time(time)
+          source.send(:apply_volume!)
+          self
+        end
+
+        def linear_ramp_to(target_value, duration = nil)
+          ramp_to(target_value, duration)
+        end
+
+        def exponential_ramp_to(target_value, duration = nil)
+          ramp_to(target_value, duration)
+        end
+
+        alias setValueAtTime set_value_at_time
+        alias cancelScheduledValues cancel_scheduled_values
+        alias cancelAndHoldAtTime cancel_and_hold_at_time
+        alias linearRampTo linear_ramp_to
+        alias exponentialRampTo exponential_ramp_to
+
+        private
+
+        def assign_immediately(target_value)
+          self.value = target_value
+          self
+        end
       end
 
       attr_reader :volume
       attr_accessor :onstop
-      attr_accessor :mute
+      attr_reader :mute
 
       def initialize(context: Deftones.context)
         super(context: context)
@@ -127,16 +188,15 @@ module Deftones
       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
+        super
       end
 
       def render_block(num_frames, start_frame = 0, cache = {})
         output_block = super
+        volume_gains = @volume.gains(num_frames, start_frame)
         scaled = AudioBlock.from_channel_data(
           output_block.channel_data.map do |channel|
-            channel.map { |sample| sample * @output_gain }
+            channel.each_with_index.map { |sample, index| sample * volume_gains[index] }
           end
         )
         notify_stop_in_window(start_frame, num_frames)
@@ -159,7 +219,7 @@ module Deftones
       end
 
       def apply_volume!
-        @output_gain = mute ? 0.0 : Deftones.db_to_gain(@volume.value)
+        @output_gain = @volume.current_gain
         self
       end
 

data/lib/deftones/destination.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module Deftones
   class Destination
     class VolumeProxy
       attr_reader :destination
-      attr_accessor :value
+      attr_reader :value
 
       def initialize(destination, value: 0.0)
         @destination = destination
@@ -16,24 +18,56 @@ module Deftones
         destination.apply_volume!
       end
 
-      def ramp_to(target_value, _duration = nil)
-        self.value = target_value
+      def ramp_to(target_value, duration = nil)
+        return assign_immediately(target_value) if duration.nil?
+
+        resolved_duration = Deftones::Music::Time.parse(duration)
+        return assign_immediately(target_value) if resolved_duration <= 0.0
+
+        @value = target_value.to_f
+        destination.node.gain.linear_ramp_to_value_at_time(
+          destination.mute? ? 0.0 : Deftones.db_to_gain(@value),
+          destination.context.current_time + resolved_duration
+        )
         self
       end
 
-      alias linear_ramp_to ramp_to
-      alias exponential_ramp_to ramp_to
+      def linear_ramp_to(target_value, duration = nil)
+        ramp_to(target_value, duration)
+      end
+
+      def exponential_ramp_to(target_value, duration = nil)
+        ramp_to(target_value, duration)
+      end
 
       def set_value_at_time(target_value, _time)
+        @value = target_value.to_f
+        destination.node.gain.set_value_at_time(destination.mute? ? 0.0 : Deftones.db_to_gain(@value), _time)
+        self
+      end
+
+      alias linearRampTo linear_ramp_to
+      alias exponentialRampTo exponential_ramp_to
+      alias setValueAtTime set_value_at_time
+
+      private
+
+      def assign_immediately(target_value)
         self.value = target_value
         self
       end
     end
 
-    attr_reader :context, :volume
-    attr_accessor :mute
+    attr_reader :context, :mute, :volume
 
     class << self
+      extend Forwardable
+
+      def_delegators :node, :input, :output, :volume, :mute, :mute=, :mute?
+      def_delegators :node, :sample_time, :block_time, :max_channel_count
+      def_delegators :node, :connect, :disconnect, :chain, :fan, :apply_volume!
+      def_delegators :node, :sampleTime, :blockTime, :maxChannelCount
+
       def node(context: Deftones.context)
         registry[context.object_id] ||= new(context: context)
       end
@@ -43,16 +77,6 @@ module Deftones
         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

data/lib/deftones/draw.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module Deftones
   class Draw
     class << self
+      extend Forwardable
+
+      def_delegators :instance, :schedule, :cancel, :dispose, :prepare_render, :advance_to
+
       def instance
         @instance ||= new
       end
@@ -11,16 +17,6 @@ module Deftones
         @instance = nil
         self
       end
-
-      def method_missing(method_name, *arguments, &block)
-        return super unless instance.respond_to?(method_name)
-
-        instance.public_send(method_name, *arguments, &block)
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        instance.respond_to?(method_name, include_private) || super
-      end
     end
 
     def initialize

data/lib/deftones/dsp/biquad.rb

@@ -13,8 +13,12 @@ module Deftones
       def update(type:, frequency:, q:, gain_db:, sample_rate:)
         raise ArgumentError, "Unsupported filter type: #{type}" unless TYPES.include?(type)
 
-        normalized_frequency = Helpers.clamp(frequency.to_f, 10.0, (sample_rate / 2.0) - 10.0)
-        omega = (2.0 * Math::PI * normalized_frequency) / sample_rate
+        normalized_sample_rate = [sample_rate.to_f, 1.0].max
+        nyquist = normalized_sample_rate / 2.0
+        lower_bound = [10.0, nyquist * 0.5].min
+        upper_bound = [nyquist - 1.0e-6, lower_bound].max
+        normalized_frequency = Helpers.clamp(frequency.to_f, lower_bound, upper_bound)
+        omega = (2.0 * Math::PI * normalized_frequency) / normalized_sample_rate
         sin_omega = Math.sin(omega)
         cos_omega = Math.cos(omega)
         alpha = sin_omega / (2.0 * [q.to_f, 0.001].max)
@@ -45,9 +49,10 @@ module Deftones
 
       def process_sample(sample)
         b0, b1, b2, a1, a2 = @coefficients
-        output = (b0 * sample) + (b1 * @x1) + (b2 * @x2) - (a1 * @y1) - (a2 * @y2)
+        input = Helpers.flush_denormal(sample)
+        output = Helpers.flush_denormal((b0 * input) + (b1 * @x1) + (b2 * @x2) - (a1 * @y1) - (a2 * @y2))
         @x2 = @x1
-        @x1 = sample
+        @x1 = input
         @y2 = @y1
         @y1 = output
         output

data/lib/deftones/dsp/delay_line.rb

@@ -13,7 +13,7 @@ module Deftones
       end
 
       def write(sample)
-        @buffer[@write_index] = sample
+        @buffer[@write_index] = Helpers.flush_denormal(sample)
         @write_index = (@write_index + 1) % @buffer.length
         sample
       end
@@ -34,7 +34,7 @@ module Deftones
         next_index = (base_index + 1) % @buffer.length
         fraction = read_position - read_position.floor
 
-        Helpers.lerp(@buffer[base_index], @buffer[next_index], fraction)
+        Helpers.flush_denormal(Helpers.lerp(@buffer[base_index], @buffer[next_index], fraction))
       end
     end
   end

data/lib/deftones/dsp/helpers.rb

@@ -3,6 +3,8 @@
 module Deftones
   module DSP
     module Helpers
+      DENORMAL_THRESHOLD = 1.0e-300
+
       module_function
 
       def clamp(value, min_value, max_value)
@@ -20,6 +22,11 @@ module Deftones
       def soft_clip(value, drive = 1.0)
         Math.tanh(value * drive)
       end
+
+      def flush_denormal(value)
+        sample = value.to_f
+        sample.abs < DENORMAL_THRESHOLD ? 0.0 : sample
+      end
     end
   end
 end

data/lib/deftones/effect/bit_crusher.rb

@@ -3,12 +3,15 @@
 module Deftones
   module Effects
     class BitCrusher < Core::Effect
+      include Oversampling
+
       attr_accessor :bits, :downsample
 
-      def initialize(bits: 8, downsample: 2, **options)
+      def initialize(bits: 8, downsample: 2, oversample: 1, **options)
         super(**options)
         @bits = bits.to_i
         @downsample = [downsample.to_i, 1].max
+        self.oversample = oversample
         @hold_counters = []
         @held_samples = []
       end
@@ -21,13 +24,18 @@ module Deftones
 
         input_buffer.map do |sample|
           if (@hold_counters[channel_index] % @downsample).zero?
-            @held_samples[channel_index] = ((sample / step).round * step).clamp(-1.0, 1.0)
+            @held_samples[channel_index] =
+              process_oversampled([sample], channel_index) { |candidate| quantize(candidate, step) }.first
           end
           @hold_counters[channel_index] += 1
           @held_samples[channel_index]
         end
       end
 
+      def quantize(sample, step)
+        ((sample / step).round * step).clamp(-1.0, 1.0)
+      end
+
       def ensure_state(channel_index)
         required = [channel_index.to_i, 0].max
         @hold_counters.fill(0, @hold_counters.length..required)

data/lib/deftones/effect/chebyshev.rb

@@ -3,18 +3,22 @@
 module Deftones
   module Effects
     class Chebyshev < Core::Effect
+      include Oversampling
+
       attr_accessor :order
 
-      def initialize(order: 3, **options)
+      def initialize(order: 3, oversample: 1, **options)
         super(**options)
         @order = [order.to_i, 1].max
+        self.oversample = oversample
       end
 
       private
 
       def process_effect(input_buffer, _num_frames, _start_frame, _cache, channel_index: 0)
-        _ = channel_index
-        input_buffer.map { |sample| chebyshev(sample.clamp(-1.0, 1.0), @order) }
+        process_oversampled(input_buffer, channel_index) do |sample|
+          chebyshev(sample.clamp(-1.0, 1.0), @order)
+        end
       end
 
       def chebyshev(value, order)

data/lib/deftones/effect/distortion.rb

@@ -3,19 +3,21 @@
 module Deftones
   module Effects
     class Distortion < Core::Effect
+      include Oversampling
+
       attr_accessor :amount
 
-      def initialize(amount: 0.5, **options)
+      def initialize(amount: 0.5, oversample: 1, **options)
         super(**options)
         @amount = amount.to_f
+        self.oversample = oversample
       end
 
       private
 
       def process_effect(input_buffer, _num_frames, _start_frame, _cache, channel_index: 0)
-        _ = channel_index
         drive = 1.0 + (@amount * 20.0)
-        input_buffer.map { |sample| DSP::Helpers.soft_clip(sample, drive) }
+        process_oversampled(input_buffer, channel_index) { |sample| DSP::Helpers.soft_clip(sample, drive) }
       end
     end
   end

data/lib/deftones/effect/feedback_delay.rb

@@ -22,7 +22,8 @@ module Deftones
 
         Array.new(num_frames) do |index|
           delay_samples = delays[index] * context.sample_rate
-          delay_line.tap(delay_samples, input_sample: input_buffer[index], feedback: feedbacks[index])
+          feedback = feedbacks[index].to_f.clamp(-0.999, 0.999)
+          delay_line.tap(delay_samples, input_sample: input_buffer[index], feedback: feedback)
         end
       end