deftones 0.1.0

data/lib/deftones/effect/distortion.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Distortion < Core::Effect
+      attr_accessor :amount
+
+      def initialize(amount: 0.5, **options)
+        super(**options)
+        @amount = amount.to_f
+      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) }
+      end
+    end
+  end
+end

data/lib/deftones/effect/feedback_delay.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class FeedbackDelay < Core::Effect
+      attr_reader :delay_time, :feedback
+
+      def initialize(delay_time: "8n", feedback: 0.3, max_delay: 2.0, context: Deftones.context, **options)
+        super(context: context, **options)
+        @delay_time = Core::Signal.new(value: delay_time, units: :time, context: context)
+        @feedback = Core::Signal.new(value: feedback, units: :number, context: context)
+        @max_delay_samples = (max_delay * context.sample_rate).ceil
+        @delay_lines = []
+      end
+
+      private
+
+      def process_effect(input_buffer, num_frames, start_frame, _cache, channel_index: 0)
+        delays = @delay_time.process(num_frames, start_frame)
+        feedbacks = @feedback.process(num_frames, start_frame)
+        delay_line = ensure_delay_line(channel_index)
+
+        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])
+        end
+      end
+
+      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_samples)
+        end
+        @delay_lines[required]
+      end
+    end
+  end
+end

data/lib/deftones/effect/freeverb.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Freeverb < Reverb
+      def initialize(decay: 0.82, pre_delay: 0.005, **options)
+        super(decay: decay, pre_delay: pre_delay, **options)
+      end
+    end
+  end
+end

data/lib/deftones/effect/frequency_shifter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class FrequencyShifter < Core::Effect
+      DEFAULT_KERNEL_SIZE = 31
+
+      attr_accessor :frequency
+
+      def initialize(frequency: 30.0, context: Deftones.context, **options)
+        super(context: context, **options)
+        @frequency = frequency.to_f
+        @phase = 0.0
+        @kernel = self.class.send(:hilbert_kernel, DEFAULT_KERNEL_SIZE)
+        @delay = (@kernel.length / 2.0).floor
+        @histories = []
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, _start_frame, _cache)
+        ensure_histories(input_block.channels)
+        output = Array.new(input_block.channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          phase = @phase
+          input_block.channel_data.each_with_index do |channel, channel_index|
+            analytic = analytic_components(channel[index], channel_index)
+            output[channel_index][index] = shift_analytic_signal(*analytic, phase)
+          end
+          advance_phase
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def analytic_components(sample, channel_index)
+        history = @histories[channel_index]
+        history.unshift(sample)
+        history.pop
+        delayed = history[@delay] || 0.0
+        quadrature = @kernel.each_with_index.sum(0.0) do |coefficient, index|
+          coefficient * (history[index] || 0.0)
+        end
+        [delayed, quadrature]
+      end
+
+      def shift_analytic_signal(in_phase, quadrature, phase)
+        radians = 2.0 * Math::PI * phase
+        cosine = Math.cos(radians)
+        sine = Math.sin(radians)
+        if @frequency.negative?
+          (in_phase * cosine) + (quadrature * sine)
+        else
+          (in_phase * cosine) - (quadrature * sine)
+        end
+      end
+
+      def advance_phase
+        @phase = (@phase + (shift_frequency / context.sample_rate)) % 1.0
+      end
+
+      def shift_frequency
+        @frequency.abs
+      end
+
+      def ensure_histories(channels)
+        required = [channels.to_i, 1].max
+        while @histories.length < required
+          @histories << Array.new(@kernel.length, 0.0)
+        end
+      end
+
+      def self.hilbert_kernel(size)
+        raise ArgumentError, "kernel size must be odd" if size.even?
+
+        center = size / 2
+        Array.new(size) do |index|
+          offset = index - center
+          next 0.0 if offset.zero? || offset.even?
+
+          coefficient = 2.0 / (Math::PI * offset)
+          window = 0.54 - (0.46 * Math.cos((2.0 * Math::PI * index) / (size - 1)))
+          coefficient * window
+        end
+      end
+    end
+  end
+end

data/lib/deftones/effect/jc_reverb.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class JCReverb < Reverb
+      def initialize(decay: 0.6, pre_delay: 0.003, **options)
+        super(decay: decay, pre_delay: pre_delay, **options)
+      end
+    end
+  end
+end

data/lib/deftones/effect/modulation_control.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    module ModulationControl
+      def start(time = nil)
+        return schedule_modulation_event(:start, time) if synced?
+
+        @modulation_start_time = resolve_modulation_time(time)
+        @modulation_stop_time = nil if @modulation_stop_time && @modulation_stop_time <= @modulation_start_time
+        self
+      end
+
+      def stop(time = nil)
+        return schedule_modulation_event(:stop, time) if synced?
+
+        @modulation_stop_time = resolve_modulation_time(time)
+        self
+      end
+
+      def restart(time = nil)
+        stop(time)
+        start(time)
+      end
+
+      def cancel_stop
+        clear_modulation_event(:stop)
+        @modulation_stop_time = nil
+        self
+      end
+
+      def state(time = context.current_time)
+        modulation_active_at?(resolve_modulation_time(time)) ? :started : :stopped
+      end
+
+      def sync
+        @modulation_synced = true
+        self
+      end
+
+      def unsync
+        @modulation_synced = false
+        clear_modulation_event(:start)
+        clear_modulation_event(:stop)
+        self
+      end
+
+      def synced?
+        !!@modulation_synced
+      end
+
+      def dispose
+        unsync
+        super
+      end
+
+      alias cancelStop cancel_stop
+
+      private
+
+      def initialize_modulation_control
+        @modulation_start_time = Float::INFINITY
+        @modulation_stop_time = nil
+        @modulation_synced = false
+        @modulation_transport_event_ids = {}
+      end
+
+      def modulation_phase_for(current_time)
+        return nil unless modulation_active_at?(current_time)
+
+        current_phase = @phase
+        @phase = (@phase + (modulation_frequency / context.sample_rate)) % 1.0
+        current_phase
+      end
+
+      def modulation_frequency
+        @frequency.to_f
+      end
+
+      def modulation_sample_for(phase, type = modulation_type)
+        normalized_phase = phase.to_f % 1.0
+
+        case normalize_modulation_type(type)
+        when :square
+          normalized_phase < 0.5 ? 1.0 : -1.0
+        when :triangle
+          normalized_phase < 0.5 ? ((4.0 * normalized_phase) - 1.0) : (3.0 - (4.0 * normalized_phase))
+        when :sawtooth
+          (2.0 * normalized_phase) - 1.0
+        else
+          Math.sin(2.0 * Math::PI * normalized_phase)
+        end
+      end
+
+      def unipolar_modulation_value(phase, default: 0.0)
+        return default if phase.nil?
+
+        (modulation_sample_for(phase) + 1.0) * 0.5
+      end
+
+      def bipolar_modulation_value(phase, default: 0.0)
+        return default if phase.nil?
+
+        modulation_sample_for(phase)
+      end
+
+      def modulation_active_at?(time)
+        time >= @modulation_start_time && (@modulation_stop_time.nil? || time < @modulation_stop_time)
+      end
+
+      def resolve_modulation_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+
+      def resolve_modulation_transport_time(time)
+        return Deftones.transport.seconds if time.nil?
+
+        time
+      end
+
+      def schedule_modulation_event(kind, time)
+        clear_modulation_event(kind)
+        @modulation_transport_event_ids[kind] = Deftones.transport.schedule(resolve_modulation_transport_time(time)) do |scheduled_time|
+          if kind == :start
+            @modulation_start_time = scheduled_time
+            @modulation_stop_time = nil if @modulation_stop_time && @modulation_stop_time <= @modulation_start_time
+          else
+            @modulation_stop_time = scheduled_time
+          end
+        end
+        self
+      end
+
+      def clear_modulation_event(kind)
+        event_id = @modulation_transport_event_ids.delete(kind)
+        return self unless event_id
+
+        Deftones.transport.clear(event_id)
+        self
+      end
+
+      def modulation_type
+        return :sine unless respond_to?(:type)
+
+        normalize_modulation_type(type)
+      end
+
+      def normalize_modulation_type(type)
+        normalized = type.to_sym
+        normalized = :sawtooth if normalized == :ramp
+        return normalized if %i[sine square triangle sawtooth].include?(normalized)
+
+        raise ArgumentError, "Unsupported modulation type: #{type}"
+      end
+    end
+  end
+end

data/lib/deftones/effect/phaser.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Phaser < Core::Effect
+      include ModulationControl
+
+      attr_accessor :frequency, :octaves, :q, :base_frequency, :stages, :type
+
+      def initialize(
+        frequency: 0.5,
+        octaves: 3.0,
+        q: 0.8,
+        base_frequency: 300.0,
+        stages: 4,
+        type: :sine,
+        context: Deftones.context,
+        **options
+      )
+        super(context: context, **options)
+        @frequency = frequency.to_f
+        @octaves = octaves.to_f
+        @q = q.to_f
+        @base_frequency = base_frequency.to_f
+        @stages = stages.to_i
+        @type = normalize_modulation_type(type)
+        @phase = 0.0
+        @filters = []
+        initialize_modulation_control
+      end
+
+      def stages=(value)
+        @stages = [value.to_i, 1].max
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, _cache)
+        filter_banks = stage_filters(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)
+          input_block.channel_data.each_with_index do |channel, channel_index|
+            output[channel_index][index] = filter_banks[channel_index].each_with_index.reduce(channel[index]) do |sample, (filter, stage_index)|
+              stage_position = @stages == 1 ? 0.0 : (stage_index.to_f / (@stages - 1)) - 0.5
+              cutoff = @base_frequency * (2.0**((modulation * @octaves) + (stage_position * 0.5)))
+              filter.update(type: :notch, frequency: cutoff, q: @q, gain_db: 0.0, sample_rate: context.sample_rate)
+              filter.process_sample(sample)
+            end
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def stage_filters(channels)
+        required_channels = [channels.to_i, 1].max
+        while @filters.length < required_channels
+          @filters << Array.new(@stages) { DSP::Biquad.new }
+        end
+
+        @filters.map! do |bank|
+          bank.length == @stages ? bank : Array.new(@stages) { DSP::Biquad.new }
+        end
+        @filters
+      end
+    end
+  end
+end

data/lib/deftones/effect/ping_pong_delay.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class PingPongDelay < FeedbackDelay
+      def initialize(max_delay: 2.0, **options)
+        super(max_delay: max_delay, **options)
+        @left_delay_line = DSP::DelayLine.new(@max_delay_samples)
+        @right_delay_line = DSP::DelayLine.new(@max_delay_samples)
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, _cache)
+        delays = @delay_time.process(num_frames, start_frame)
+        feedbacks = @feedback.process(num_frames, start_frame)
+        source = input_block.fit_channels(2)
+        left = Array.new(num_frames, 0.0)
+        right = Array.new(num_frames, 0.0)
+
+        num_frames.times do |index|
+          delay_samples = delays[index] * context.sample_rate
+          feedback = feedbacks[index].to_f.clamp(-0.999, 0.999)
+          left_tap = @left_delay_line.read(delay_samples)
+          right_tap = @right_delay_line.read(delay_samples)
+          input_left = input_block.channels == 1 ? input_block.mono[index] : source.channel_data[0][index]
+          input_right = input_block.channels == 1 ? 0.0 : source.channel_data[1][index]
+
+          @left_delay_line.write(input_left + (right_tap * feedback))
+          @right_delay_line.write(input_right + (left_tap * feedback))
+
+          left[index] = left_tap
+          right[index] = right_tap
+        end
+
+        Core::AudioBlock.from_channel_data([left, right])
+      end
+    end
+  end
+end

data/lib/deftones/effect/pitch_shift.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class PitchShift < Core::Effect
+      attr_reader :delay_time, :feedback
+      attr_accessor :pitch
+      attr_reader :window_size
+
+      def initialize(
+        pitch: nil,
+        semitones: 0.0,
+        window: 0.1,
+        window_size: nil,
+        delay_time: nil,
+        feedback: 0.0,
+        context: Deftones.context,
+        **options
+      )
+        super(context: context, **options)
+        @pitch = pitch.nil? ? semitones.to_f : pitch.to_f
+        @window_size = resolve_window_size(window_size || window)
+        @delay_time = Core::Signal.new(
+          value: delay_time.nil? ? default_delay_time : delay_time,
+          units: :time,
+          context: context
+        )
+        @feedback = Core::Signal.new(value: feedback, units: :number, context: context)
+        @phase = 0.0
+        @delay_lines = []
+        @max_delay_samples = 0
+        ensure_delay_line_capacity!(1, @delay_time.value.to_f, pitch_ratio)
+      end
+
+      def semitones
+        @pitch
+      end
+
+      def semitones=(value)
+        self.pitch = value
+      end
+
+      def pitch=(value)
+        @pitch = value.to_f
+        ensure_delay_line_capacity!([@delay_lines.length, 1].max, @delay_time.value.to_f, pitch_ratio)
+      end
+
+      def window_size=(value)
+        @window_size = resolve_window_size(value)
+        ensure_delay_line_capacity!([@delay_lines.length, 1].max, @delay_time.value.to_f, pitch_ratio)
+      end
+
+      alias delayTime delay_time
+      alias windowSize window_size
+
+      def windowSize=(value)
+        self.window_size = value
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, _cache)
+        delays = @delay_time.process(num_frames, start_frame)
+        feedbacks = @feedback.process(num_frames, start_frame)
+        ratio = pitch_ratio
+        ensure_delay_line_capacity!(input_block.channels, delays.max.to_f, ratio)
+        output = Array.new(input_block.channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          delay_seconds = delays[index].to_f
+          feedback = feedbacks[index].to_f.clamp(-0.999, 0.999)
+          phase = @phase
+          input_block.channel_data.each_with_index do |channel, channel_index|
+            sample = shifted_sample(@delay_lines[channel_index], delay_seconds, ratio, phase)
+            @delay_lines[channel_index].write(channel[index] + (sample * feedback))
+            output[channel_index][index] = sample
+          end
+          advance_phase
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def shifted_sample(delay_line, delay_seconds, ratio, phase)
+        primary_phase = phase
+        secondary_phase = (phase + 0.5) % 1.0
+        primary = shifted_head_sample(delay_line, primary_phase, delay_seconds, ratio)
+        secondary = shifted_head_sample(delay_line, secondary_phase, delay_seconds, ratio)
+        (primary * head_gain(primary_phase)) + (secondary * head_gain(secondary_phase))
+      end
+
+      def shifted_head_sample(delay_line, phase, delay_seconds, ratio)
+        delay_samples = head_delay_samples(phase, delay_seconds, ratio)
+        delay_line.read(delay_samples)
+      end
+
+      def head_delay_samples(phase, delay_seconds, ratio)
+        base_delay = [delay_seconds, context.sample_time].max * context.sample_rate
+        sweep = sweep_span_samples(ratio)
+        offset = if ratio >= 1.0
+                   (1.0 - phase) * sweep
+                 else
+                   phase * sweep
+                 end
+
+        [base_delay + offset, 1.0].max
+      end
+
+      def head_gain(phase)
+        Math.sin(Math::PI * phase)**2
+      end
+
+      def advance_phase
+        @phase = (@phase + phase_step) % 1.0
+      end
+
+      def phase_step
+        1.0 / (@window_size * context.sample_rate)
+      end
+
+      def pitch_ratio
+        2.0**(@pitch.to_f / 12.0)
+      end
+
+      def sweep_span_samples(ratio)
+        @window_size * context.sample_rate * (1.0 - ratio).abs
+      end
+
+      def required_delay_samples(delay_seconds, ratio)
+        (
+          ([delay_seconds, context.sample_time].max * context.sample_rate) +
+          sweep_span_samples(ratio) +
+          (@window_size * context.sample_rate)
+        ).ceil + 2
+      end
+
+      def ensure_delay_line_capacity!(channels, delay_seconds, ratio)
+        required = [required_delay_samples(delay_seconds, ratio), 2].max
+        required_channels = [channels.to_i, 1].max
+        needs_resize = required > @max_delay_samples || @delay_lines.length < required_channels
+        return unless needs_resize
+
+        @max_delay_samples = required
+        @delay_lines = Array.new(required_channels) { DSP::DelayLine.new(@max_delay_samples) }
+      end
+
+      def resolve_window_size(value)
+        [value.to_f, context.sample_time * 2.0].max
+      end
+
+      def default_delay_time
+        @window_size * 0.5
+      end
+    end
+  end
+end

data/lib/deftones/effect/reverb.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Reverb < Core::Effect
+      attr_accessor :decay, :pre_delay
+
+      def initialize(decay: 0.7, pre_delay: 0.01, context: Deftones.context, **options)
+        super(context: context, **options)
+        @decay = decay.to_f
+        @pre_delay = pre_delay.to_f
+        @comb_times = [0.0297, 0.0371, 0.0411, 0.0437]
+        @allpass_times = [0.005, 0.0017]
+        @comb_lines = []
+        @allpass_lines = []
+        @pre_delay_lines = []
+      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)
+
+        Core::AudioBlock.from_channel_data(
+          source.channel_data.each_with_index.map do |channel, channel_index|
+            process_effect(channel, num_frames, start_frame, cache, channel_index: channel_index)
+          end
+        )
+      end
+
+      def process_effect(input_buffer, num_frames, _start_frame, _cache, channel_index: 0)
+        ensure_delay_network(channel_index)
+        pre_delay_line = @pre_delay_lines[channel_index]
+        comb_lines = @comb_lines[channel_index]
+        allpass_lines = @allpass_lines[channel_index]
+        comb_times = channel_times(@comb_times, channel_index, 0.00037)
+        allpass_times = channel_times(@allpass_times, channel_index, 0.00011)
+
+        Array.new(num_frames) do |index|
+          dry = input_buffer[index]
+          delayed = pre_delay_line.tap(@pre_delay * context.sample_rate, input_sample: dry)
+          comb_sum = comb_lines.each_with_index.sum do |line, comb_index|
+            line.tap(comb_times[comb_index] * context.sample_rate, input_sample: delayed, feedback: @decay)
+          end / comb_lines.length.to_f
+
+          allpass_lines.each_with_index.reduce(comb_sum) do |sample, (line, allpass_index)|
+            tap = line.read(allpass_times[allpass_index] * context.sample_rate)
+            line.write(sample + (tap * 0.5))
+            tap - (sample * 0.5)
+          end
+        end
+      end
+
+      def ensure_delay_network(channel_index)
+        required = [channel_index.to_i, 0].max
+        while @pre_delay_lines.length <= required
+          @pre_delay_lines << DSP::DelayLine.new((0.1 * context.sample_rate).ceil)
+          @comb_lines << @comb_times.map { |seconds| DSP::DelayLine.new((seconds * context.sample_rate).ceil + 2) }
+          @allpass_lines << @allpass_times.map { |seconds| DSP::DelayLine.new((seconds * context.sample_rate).ceil + 2) }
+        end
+      end
+
+      def channel_times(times, channel_index, offset)
+        return times if channel_index.zero?
+
+        times.map { |time| time + (offset * channel_index) }
+      end
+    end
+  end
+end