deftones 0.1.0

data/lib/deftones/draw.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Deftones
+  class Draw
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def reset!
+        @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
+      @timeline = {}
+      @next_id = 0
+    end
+
+    def schedule(callback_or_time = nil, maybe_time = nil, &block)
+      callback, time = resolve_schedule_arguments(callback_or_time, maybe_time, block)
+      event_id = @next_id
+      @timeline[event_id] = { time: resolve_time(time), callback: callback }
+      @next_id += 1
+      event_id
+    end
+
+    def cancel(after_time = 0, event_id: nil)
+      if event_id.nil? && after_time.is_a?(Integer) && @timeline.key?(after_time)
+        return @timeline.delete(after_time)
+      end
+
+      return @timeline.delete(event_id) if event_id
+
+      threshold = resolve_time(after_time)
+      @timeline.delete_if { |_id, event| event[:time] >= threshold }
+      self
+    end
+
+    def dispose
+      @timeline.clear
+      @next_id = 0
+      self
+    end
+
+    def prepare_render(duration)
+      flush_until(duration)
+      self
+    end
+
+    def advance_to(time)
+      flush_until(time)
+      self
+    end
+
+    private
+
+    def resolve_schedule_arguments(callback_or_time, maybe_time, block)
+      if callback_or_time.respond_to?(:call)
+        [callback_or_time, maybe_time]
+      else
+        [block, callback_or_time]
+      end.tap do |callback, _time|
+        raise ArgumentError, "callback is required" unless callback
+      end
+    end
+
+    def resolve_time(value)
+      Deftones::Music::Time.parse(value || 0)
+    end
+
+    def due_events(limit)
+      events = @timeline.values.select { |event| event[:time] <= limit }
+      events.sort_by { |event| event[:time] }
+    end
+
+    def flush_until(time)
+      limit = resolve_time(time)
+      due_events(limit).each do |event|
+        invoke(event[:callback], event[:time])
+      end
+      @timeline.delete_if { |_id, event| event[:time] <= limit }
+    end
+
+    def invoke(callback, time)
+      callback.arity.zero? ? callback.call : callback.call(time)
+    end
+  end
+end

data/lib/deftones/dsp/biquad.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Deftones
+  module DSP
+    class Biquad
+      TYPES = %i[lowpass highpass bandpass notch allpass peaking lowshelf highshelf].freeze
+
+      def initialize
+        reset!
+        @coefficients = [1.0, 0.0, 0.0, 0.0, 0.0]
+      end
+
+      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
+        sin_omega = Math.sin(omega)
+        cos_omega = Math.cos(omega)
+        alpha = sin_omega / (2.0 * [q.to_f, 0.001].max)
+        a = 10.0**(gain_db.to_f / 40.0)
+
+        b0, b1, b2, a0, a1, a2 =
+          case type
+          when :lowpass
+            lowpass_coefficients(cos_omega, alpha)
+          when :highpass
+            highpass_coefficients(cos_omega, alpha)
+          when :bandpass
+            [alpha, 0.0, -alpha, 1.0 + alpha, -2.0 * cos_omega, 1.0 - alpha]
+          when :notch
+            [1.0, -2.0 * cos_omega, 1.0, 1.0 + alpha, -2.0 * cos_omega, 1.0 - alpha]
+          when :allpass
+            [1.0 - alpha, -2.0 * cos_omega, 1.0 + alpha, 1.0 + alpha, -2.0 * cos_omega, 1.0 - alpha]
+          when :peaking
+            peaking_coefficients(cos_omega, alpha, a)
+          when :lowshelf
+            shelf_coefficients(:low, cos_omega, sin_omega, a)
+          when :highshelf
+            shelf_coefficients(:high, cos_omega, sin_omega, a)
+          end
+
+        @coefficients = normalize(b0, b1, b2, a0, a1, a2)
+      end
+
+      def process_sample(sample)
+        b0, b1, b2, a1, a2 = @coefficients
+        output = (b0 * sample) + (b1 * @x1) + (b2 * @x2) - (a1 * @y1) - (a2 * @y2)
+        @x2 = @x1
+        @x1 = sample
+        @y2 = @y1
+        @y1 = output
+        output
+      end
+
+      def reset!
+        @x1 = 0.0
+        @x2 = 0.0
+        @y1 = 0.0
+        @y2 = 0.0
+      end
+
+      private
+
+      def lowpass_coefficients(cos_omega, alpha)
+        [
+          (1.0 - cos_omega) / 2.0,
+          1.0 - cos_omega,
+          (1.0 - cos_omega) / 2.0,
+          1.0 + alpha,
+          -2.0 * cos_omega,
+          1.0 - alpha
+        ]
+      end
+
+      def highpass_coefficients(cos_omega, alpha)
+        [
+          (1.0 + cos_omega) / 2.0,
+          -(1.0 + cos_omega),
+          (1.0 + cos_omega) / 2.0,
+          1.0 + alpha,
+          -2.0 * cos_omega,
+          1.0 - alpha
+        ]
+      end
+
+      def peaking_coefficients(cos_omega, alpha, amplitude)
+        [
+          1.0 + (alpha * amplitude),
+          -2.0 * cos_omega,
+          1.0 - (alpha * amplitude),
+          1.0 + (alpha / amplitude),
+          -2.0 * cos_omega,
+          1.0 - (alpha / amplitude)
+        ]
+      end
+
+      def shelf_coefficients(kind, cos_omega, sin_omega, amplitude)
+        sqrt_a = Math.sqrt(amplitude)
+        alpha = sin_omega / Math.sqrt(2.0)
+        common = 2.0 * sqrt_a * alpha
+
+        if kind == :low
+          [
+            amplitude * ((amplitude + 1.0) - ((amplitude - 1.0) * cos_omega) + common),
+            2.0 * amplitude * ((amplitude - 1.0) - ((amplitude + 1.0) * cos_omega)),
+            amplitude * ((amplitude + 1.0) - ((amplitude - 1.0) * cos_omega) - common),
+            (amplitude + 1.0) + ((amplitude - 1.0) * cos_omega) + common,
+            -2.0 * ((amplitude - 1.0) + ((amplitude + 1.0) * cos_omega)),
+            (amplitude + 1.0) + ((amplitude - 1.0) * cos_omega) - common
+          ]
+        else
+          [
+            amplitude * ((amplitude + 1.0) + ((amplitude - 1.0) * cos_omega) + common),
+            -2.0 * amplitude * ((amplitude - 1.0) + ((amplitude + 1.0) * cos_omega)),
+            amplitude * ((amplitude + 1.0) + ((amplitude - 1.0) * cos_omega) - common),
+            (amplitude + 1.0) - ((amplitude - 1.0) * cos_omega) + common,
+            2.0 * ((amplitude - 1.0) - ((amplitude + 1.0) * cos_omega)),
+            (amplitude + 1.0) - ((amplitude - 1.0) * cos_omega) - common
+          ]
+        end
+      end
+
+      def normalize(b0, b1, b2, a0, a1, a2)
+        [b0 / a0, b1 / a0, b2 / a0, a1 / a0, a2 / a0]
+      end
+    end
+  end
+end

data/lib/deftones/dsp/delay_line.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Deftones
+  module DSP
+    class DelayLine
+      def initialize(max_delay_samples)
+        @buffer = Array.new([max_delay_samples.to_i + 2, 2].max, 0.0)
+        @write_index = 0
+      end
+
+      def read(delay_samples)
+        fractional_read(delay_samples.to_f)
+      end
+
+      def write(sample)
+        @buffer[@write_index] = sample
+        @write_index = (@write_index + 1) % @buffer.length
+        sample
+      end
+
+      def tap(delay_samples, input_sample: 0.0, feedback: 0.0)
+        delayed_sample = read(delay_samples)
+        write(input_sample + (delayed_sample * feedback))
+        delayed_sample
+      end
+
+      private
+
+      def fractional_read(delay_samples)
+        read_position = @write_index - delay_samples
+        read_position += @buffer.length while read_position.negative?
+
+        base_index = read_position.floor % @buffer.length
+        next_index = (base_index + 1) % @buffer.length
+        fraction = read_position - read_position.floor
+
+        Helpers.lerp(@buffer[base_index], @buffer[next_index], fraction)
+      end
+    end
+  end
+end

data/lib/deftones/dsp/helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Deftones
+  module DSP
+    module Helpers
+      module_function
+
+      def clamp(value, min_value, max_value)
+        [[value, min_value].max, max_value].min
+      end
+
+      def lerp(from, to, progress)
+        from + ((to - from) * progress)
+      end
+
+      def mix(dry, wet, wet_amount)
+        (dry * (1.0 - wet_amount)) + (wet * wet_amount)
+      end
+
+      def soft_clip(value, drive = 1.0)
+        Math.tanh(value * drive)
+      end
+    end
+  end
+end

data/lib/deftones/effect/auto_filter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class AutoFilter < Core::Effect
+      include ModulationControl
+
+      FilterProxy = Struct.new(:type, :q, :rolloff, keyword_init: true)
+
+      attr_accessor :frequency, :octaves, :depth, :base_frequency, :type
+      attr_reader :filter
+
+      def initialize(
+        frequency: 1.0,
+        base_frequency: 200.0,
+        octaves: 2.5,
+        depth: 1.0,
+        type: :sine,
+        filter_type: :lowpass,
+        q: 0.8,
+        filter: nil,
+        context: Deftones.context,
+        **options
+      )
+        super(context: context, wet: 1.0, **options)
+        @frequency = frequency.to_f
+        @base_frequency = base_frequency.to_f
+        @octaves = octaves.to_f
+        @depth = depth.to_f
+        @type = normalize_modulation_type(type)
+        @filter = resolve_filter(filter, filter_type: filter_type, q: q)
+        @phase = 0.0
+        @biquads = []
+        initialize_modulation_control
+      end
+
+      def q
+        @filter.q
+      end
+
+      def q=(value)
+        @filter.q = value.to_f
+      end
+
+      alias baseFrequency base_frequency
+
+      def baseFrequency=(value)
+        self.base_frequency = value
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, _cache)
+        ensure_biquads(input_block.channels)
+        output = Array.new(input_block.channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          phase = modulation_phase_for(current_time)
+          modulation = unipolar_modulation_value(phase, default: 0.5) * @depth.clamp(0.0, 1.0)
+          cutoff = @base_frequency * (2.0**(modulation * @octaves))
+          input_block.channel_data.each_with_index do |channel, channel_index|
+            biquad = @biquads[channel_index]
+            biquad.update(
+              type: @filter.type,
+              frequency: cutoff,
+              q: @filter.q,
+              gain_db: 0.0,
+              sample_rate: context.sample_rate
+            )
+            output[channel_index][index] = biquad.process_sample(channel[index])
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def resolve_filter(filter, filter_type:, q:)
+        return filter if filter.respond_to?(:type) && filter.respond_to?(:q)
+
+        FilterProxy.new(type: filter_type.to_sym, q: q.to_f, rolloff: -12)
+      end
+
+      def ensure_biquads(channels)
+        required = [channels.to_i, 1].max
+        while @biquads.length < required
+          @biquads << DSP::Biquad.new
+        end
+      end
+    end
+  end
+end

data/lib/deftones/effect/auto_panner.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class AutoPanner < Core::Effect
+      include ModulationControl
+
+      attr_accessor :frequency, :depth, :type
+
+      def initialize(frequency: 2.0, depth: 0.5, type: :sine, context: Deftones.context, **options)
+        super(context: context, wet: 1.0, **options)
+        @frequency = frequency.to_f
+        @depth = depth.to_f
+        @type = normalize_modulation_type(type)
+        @phase = 0.0
+        initialize_modulation_control
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, _cache)
+        output = Array.new(2) { Array.new(num_frames, 0.0) }
+        stereo_input = input_block.fit_channels(2)
+        mono_input = input_block.mono
+
+        num_frames.times do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          phase = modulation_phase_for(current_time)
+          modulation = bipolar_modulation_value(phase, default: 0.0) * @depth.clamp(0.0, 1.0)
+          if input_block.channels == 1
+            sample = mono_input[index]
+            output[0][index] = sample * left_gain(modulation)
+            output[1][index] = sample * right_gain(modulation)
+            next
+          end
+
+          output[0][index] = stereo_input.channel_data[0][index] * left_gain(modulation)
+          output[1][index] = stereo_input.channel_data[1][index] * right_gain(modulation)
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def left_gain(pan)
+        Math.cos(angle_for(pan))
+      end
+
+      def right_gain(pan)
+        Math.sin(angle_for(pan))
+      end
+
+      def angle_for(pan)
+        ((pan.to_f.clamp(-1.0, 1.0) + 1.0) * Math::PI) * 0.25
+      end
+    end
+  end
+end

data/lib/deftones/effect/auto_wah.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class AutoWah < Core::Effect
+      FollowerSettings = Struct.new(:attack, :release, keyword_init: true)
+
+      attr_accessor :base_frequency, :octaves, :q, :sensitivity, :gain
+      attr_reader :follower
+
+      def initialize(
+        base_frequency: 200.0,
+        octaves: 4.0,
+        sensitivity: 0.0,
+        q: 2.0,
+        gain: 2.0,
+        follower: {},
+        context: Deftones.context,
+        **options
+      )
+        super(context: context, wet: 1.0, **options)
+        @base_frequency = base_frequency.to_f
+        @octaves = octaves.to_f
+        @sensitivity = sensitivity.to_f
+        @q = q.to_f
+        @gain = gain.to_f
+        @envelopes = []
+        @filters = []
+        @follower = resolve_follower(follower)
+      end
+
+      private
+
+      def process_effect(input_buffer, num_frames, _start_frame, _cache, channel_index: 0)
+        ensure_tracking_state(channel_index)
+        envelope = @envelopes[channel_index]
+        filter = @filters[channel_index]
+
+        Array.new(num_frames) do |index|
+          sample = input_buffer[index]
+          envelope = track_envelope(sample.abs, envelope)
+          openness = openness_for(envelope)
+          cutoff = @base_frequency * (2.0**(@octaves * openness))
+          filter.update(type: :bandpass, frequency: cutoff, q: @q, gain_db: 0.0, sample_rate: context.sample_rate)
+          filter.process_sample(sample) * output_gain(openness)
+        end
+      ensure
+        @envelopes[channel_index] = envelope
+      end
+
+      def track_envelope(level, current_envelope)
+        smoothing =
+          if level >= current_envelope
+            follower_coefficient(@follower.attack)
+          else
+            follower_coefficient(@follower.release)
+          end
+        (smoothing * current_envelope) + ((1.0 - smoothing) * level)
+      end
+
+      def follower_coefficient(duration)
+        return 0.0 if duration.to_f <= 0.0
+
+        Math.exp(-1.0 / (duration.to_f * context.sample_rate))
+      end
+
+      def openness_for(level)
+        level_db = level.positive? ? Deftones.gain_to_db(level) : -100.0
+        threshold = [@sensitivity.to_f, -99.0].max
+        return level.clamp(0.0, 1.0) if threshold >= 0.0
+
+        ((level_db - threshold) / -threshold).clamp(0.0, 1.0)
+      end
+
+      def output_gain(openness)
+        1.0 + ((@gain - 1.0) * openness)
+      end
+
+      def resolve_follower(follower)
+        return follower if follower.is_a?(FollowerSettings)
+
+        settings = follower.respond_to?(:to_h) ? follower.to_h : {}
+        FollowerSettings.new(
+          attack: settings.fetch(:attack, 0.3).to_f,
+          release: settings.fetch(:release, 0.5).to_f
+        )
+      end
+
+      def ensure_tracking_state(channel_index)
+        required = [channel_index.to_i, 0].max
+        @envelopes.fill(0.0, @envelopes.length..required)
+        while @filters.length <= required
+          @filters << DSP::Biquad.new
+        end
+      end
+    end
+  end
+end

data/lib/deftones/effect/bit_crusher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class BitCrusher < Core::Effect
+      attr_accessor :bits, :downsample
+
+      def initialize(bits: 8, downsample: 2, **options)
+        super(**options)
+        @bits = bits.to_i
+        @downsample = [downsample.to_i, 1].max
+        @hold_counters = []
+        @held_samples = []
+      end
+
+      private
+
+      def process_effect(input_buffer, _num_frames, _start_frame, _cache, channel_index: 0)
+        step = 2.0 / (2**@bits)
+        ensure_state(channel_index)
+
+        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)
+          end
+          @hold_counters[channel_index] += 1
+          @held_samples[channel_index]
+        end
+      end
+
+      def ensure_state(channel_index)
+        required = [channel_index.to_i, 0].max
+        @hold_counters.fill(0, @hold_counters.length..required)
+        @held_samples.fill(0.0, @held_samples.length..required)
+      end
+    end
+  end
+end

data/lib/deftones/effect/chebyshev.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Chebyshev < Core::Effect
+      attr_accessor :order
+
+      def initialize(order: 3, **options)
+        super(**options)
+        @order = [order.to_i, 1].max
+      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) }
+      end
+
+      def chebyshev(value, order)
+        return value if order == 1
+
+        previous = value
+        current = (2.0 * value * value) - 1.0
+        return current if order == 2
+
+        3.upto(order) do
+          next_value = (2.0 * value * current) - previous
+          previous = current
+          current = next_value
+        end
+        current
+      end
+    end
+  end
+end

data/lib/deftones/effect/chorus.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Chorus < Core::Effect
+      include ModulationControl
+
+      attr_accessor :frequency, :depth, :delay_time, :feedback, :spread, :type
+
+      def initialize(
+        frequency: 1.5,
+        depth: 0.003,
+        delay_time: 0.015,
+        feedback: 0.0,
+        spread: 180.0,
+        type: :sine,
+        context: Deftones.context,
+        **options
+      )
+        super(context: context, **options)
+        @frequency = frequency.to_f
+        @depth = depth.to_f
+        @delay_time = delay_time.to_f
+        @feedback = feedback.to_f
+        @spread = spread.to_f
+        @type = normalize_modulation_type(type)
+        @phase = 0.0
+        @delay_lines = []
+        initialize_modulation_control
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, _cache)
+        output_channels = [input_block.channels, 2].max
+        source = input_block.fit_channels(output_channels)
+        ensure_delay_lines(output_channels)
+        output = Array.new(output_channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          base_phase = modulation_phase_for(current_time)
+
+          output_channels.times do |channel_index|
+            phase = base_phase.nil? ? nil : base_phase + channel_phase_offset(channel_index, output_channels)
+            modulation = unipolar_modulation_value(phase, default: 0.5)
+            delay = (@delay_time + (@depth * modulation)) * context.sample_rate
+            output[channel_index][index] = @delay_lines[channel_index].tap(
+              delay,
+              input_sample: source.channel_data[channel_index][index],
+              feedback: @feedback
+            )
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def ensure_delay_lines(channels)
+        required = [channels.to_i, 1].max
+        while @delay_lines.length < required
+          @delay_lines << DSP::DelayLine.new((0.1 * context.sample_rate).ceil)
+        end
+      end
+
+      def channel_phase_offset(channel_index, channels)
+        return 0.0 if channels <= 1 || channel_index.zero?
+
+        (@spread / 360.0) * (channel_index.to_f / [channels - 1, 1].max)
+      end
+    end
+  end
+end