deftones 0.1.0

data/lib/deftones/component/eq3.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class EQ3 < Core::AudioNode
+      attr_accessor :low, :mid, :high
+      attr_reader :low_frequency, :high_frequency
+
+      def initialize(low: 0.0, mid: 0.0, high: 0.0, low_frequency: 400.0,
+                     high_frequency: 2_500.0, context: Deftones.context)
+        super(context: context)
+        @low = low.to_f
+        @mid = mid.to_f
+        @high = high.to_f
+        @low_frequency = Core::Signal.new(value: low_frequency, units: :frequency, context: context)
+        @high_frequency = Core::Signal.new(value: high_frequency, units: :frequency, context: context)
+        @low_shelves = []
+        @mid_peaks = []
+        @high_shelves = []
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        update_filters(input_block.channels, start_frame)
+
+        Core::AudioBlock.from_channel_data(
+          input_block.channel_data.each_with_index.map do |channel, channel_index|
+            low_shelf = @low_shelves[channel_index]
+            mid_peak = @mid_peaks[channel_index]
+            high_shelf = @high_shelves[channel_index]
+
+            Array.new(num_frames) do |index|
+              sample = channel[index]
+              sample = low_shelf.process_sample(sample)
+              sample = mid_peak.process_sample(sample)
+              high_shelf.process_sample(sample)
+            end
+          end
+        )
+      end
+
+      private
+
+      def update_filters(channels, start_frame)
+        ensure_filter_banks(channels)
+        low_frequency = @low_frequency.process(1, start_frame).first
+        high_frequency = @high_frequency.process(1, start_frame).first
+
+        @low_shelves.each do |filter|
+          filter.update(type: :lowshelf, frequency: low_frequency, q: 0.707, gain_db: @low, sample_rate: context.sample_rate)
+        end
+        @mid_peaks.each do |filter|
+          filter.update(type: :peaking, frequency: Math.sqrt(low_frequency * high_frequency), q: 0.8, gain_db: @mid, sample_rate: context.sample_rate)
+        end
+        @high_shelves.each do |filter|
+          filter.update(type: :highshelf, frequency: high_frequency, q: 0.707, gain_db: @high, sample_rate: context.sample_rate)
+        end
+      end
+
+      def ensure_filter_banks(channels)
+        required = [channels.to_i, 1].max
+        while @low_shelves.length < required
+          @low_shelves << DSP::Biquad.new
+          @mid_peaks << DSP::Biquad.new
+          @high_shelves << DSP::Biquad.new
+        end
+      end
+    end
+  end
+end

data/lib/deftones/component/feedback_comb_filter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class FeedbackCombFilter < Core::AudioNode
+      attr_reader :delay_time, :resonance
+
+      def initialize(delay_time: 0.1, resonance: 0.5, max_delay: 1.0, context: Deftones.context)
+        super(context: context)
+        @delay_time = Core::Signal.new(value: delay_time, units: :time, context: context)
+        @resonance = Core::Signal.new(value: resonance, units: :number, context: context)
+        @max_delay_samples = [(max_delay.to_f * context.sample_rate).ceil, 2].max
+        @delay_lines = []
+      end
+
+      def delay_time=(value)
+        @delay_time.value = value
+      end
+
+      def resonance=(value)
+        @resonance.value = value
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        delay_times = @delay_time.process(num_frames, start_frame)
+        resonances = @resonance.process(num_frames, start_frame)
+        ensure_delay_lines(input_block.channels)
+
+        Core::AudioBlock.from_channel_data(
+          input_block.channel_data.each_with_index.map do |channel, channel_index|
+            delay_line = @delay_lines[channel_index]
+
+            Array.new(num_frames) do |index|
+              delayed = delay_line.read(delay_samples(delay_times[index]))
+              feedback = filtered_feedback(delayed, index, start_frame, channel_index)
+              delay_line.write(channel[index] + (feedback * clamp_resonance(resonances[index])))
+              delayed
+            end
+          end
+        )
+      end
+
+      def reset!
+        @delay_lines = []
+        self
+      end
+
+      private
+
+      def delay_samples(duration)
+        samples = duration.to_f * context.sample_rate
+        [[samples, 1.0].max, @max_delay_samples].min
+      end
+
+      def clamp_resonance(value)
+        value.to_f.clamp(-0.999, 0.999)
+      end
+
+      def filtered_feedback(sample, _index, _start_frame, _channel_index = 0)
+        sample
+      end
+
+      def ensure_delay_lines(channels)
+        required = [channels.to_i, 1].max
+        while @delay_lines.length < required
+          @delay_lines << DSP::DelayLine.new(@max_delay_samples)
+        end
+      end
+    end
+  end
+end

data/lib/deftones/component/filter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Filter < Core::AudioNode
+      TYPES = DSP::Biquad::TYPES
+
+      attr_reader :detune, :frequency, :q, :gain
+      attr_accessor :type
+
+      def initialize(type: :lowpass, frequency: 350.0, q: 1.0, gain: 0.0, detune: 0.0, context: Deftones.context)
+        super(context: context)
+        @type = normalize_type(type)
+        @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
+        @q = Core::Signal.new(value: q, units: :number, context: context)
+        @gain = Core::Signal.new(value: gain, units: :number, context: context)
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        @biquads = []
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        update_filters(input_block.channels, start_frame)
+        Core::AudioBlock.from_channel_data(
+          input_block.channel_data.each_with_index.map do |channel, channel_index|
+            biquad = @biquads[channel_index]
+            Array.new(num_frames) { |index| biquad.process_sample(channel[index]) }
+          end
+        )
+      end
+
+      def reset!
+        @biquads.each(&:reset!)
+        self
+      end
+
+      private
+
+      def update_filters(channels, start_frame)
+        ensure_biquads(channels)
+        frequency = @frequency.process(1, start_frame).first
+        detune = @detune.process(1, start_frame).first
+        @biquads.each do |biquad|
+          biquad.update(
+            type: normalize_type(@type),
+            frequency: frequency * (2.0**(detune / 1200.0)),
+            q: @q.process(1, start_frame).first,
+            gain_db: @gain.process(1, start_frame).first * 24.0,
+            sample_rate: context.sample_rate
+          )
+        end
+      end
+
+      def ensure_biquads(channels)
+        required = [channels.to_i, 1].max
+        missing = required - @biquads.length
+        missing.times { @biquads << DSP::Biquad.new } if missing.positive?
+      end
+
+      def normalize_type(type)
+        normalized = type.to_sym
+        return normalized if TYPES.include?(normalized)
+
+        raise ArgumentError, "Unsupported filter type: #{type}"
+      end
+    end
+  end
+end

data/lib/deftones/component/follower.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Follower < Core::AudioNode
+      attr_reader :smoothing
+
+      def initialize(smoothing: 0.05, context: Deftones.context)
+        super(context: context)
+        @smoothing = Core::Signal.new(value: smoothing, units: :time, context: context)
+        @state = []
+      end
+
+      def smoothing=(value)
+        @smoothing.value = value
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        smoothing_values = @smoothing.process(num_frames, start_frame)
+        ensure_state(input_block.channels)
+        output_channels = input_block.channel_data.each_with_index.map do |channel, channel_index|
+          Array.new(num_frames) do |index|
+            coefficient = smoothing_coefficient(smoothing_values[index])
+            magnitude = channel[index].abs
+            @state[channel_index] += (1.0 - coefficient) * (magnitude - @state[channel_index])
+            @state[channel_index]
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output_channels)
+      end
+
+      def reset!
+        @state = []
+        self
+      end
+
+      private
+
+      def smoothing_coefficient(duration)
+        seconds = [duration.to_f, 1.0 / context.sample_rate].max
+        Math.exp(-1.0 / (seconds * context.sample_rate))
+      end
+
+      def ensure_state(channels)
+        required = [channels.to_i, 1].max
+        @state.fill(0.0, @state.length...required)
+      end
+    end
+  end
+end

data/lib/deftones/component/frequency_envelope.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class FrequencyEnvelope < Envelope
+      attr_accessor :base_frequency, :octaves
+
+      def initialize(base_frequency: 440.0, octaves: 2.0, **options)
+        super(**options)
+        @base_frequency = base_frequency.to_f
+        @octaves = octaves.to_f
+      end
+
+      def values(num_frames, start_frame = 0)
+        Array.new(num_frames) do |index|
+          time = sample_time(start_frame + index)
+          consume_events(time)
+          @current_value = envelope_value_at(time)
+          @base_frequency * (2.0**(@current_value * @octaves))
+        end
+      end
+    end
+  end
+end

data/lib/deftones/component/gate.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Gate < Core::AudioNode
+      attr_accessor :threshold, :release
+
+      def initialize(threshold: -40.0, release: 0.05, context: Deftones.context)
+        super(context: context)
+        @threshold = threshold.to_f
+        @release = release.to_f
+        @gain = []
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, _start_frame, _cache)
+        ensure_gain_state(input_block.channels)
+        Core::AudioBlock.from_channel_data(
+          input_block.channel_data.each_with_index.map do |channel, channel_index|
+            Array.new(num_frames) { |index| gate(channel[index], channel_index) }
+          end
+        )
+      end
+
+      private
+
+      def gate(sample, channel_index)
+        level_db = 20.0 * Math.log10([sample.abs, 1.0e-9].max)
+        target = level_db >= @threshold ? 1.0 : 0.0
+        smoothing = 1.0 / [(@release * context.sample_rate), 1.0].max
+        gain = @gain[channel_index]
+        gain += (target - gain) * smoothing
+        @gain[channel_index] = gain
+        sample * gain
+      end
+
+      def ensure_gain_state(channels)
+        required = [channels.to_i, 1].max
+        @gain.fill(0.0, @gain.length...required)
+      end
+    end
+  end
+end

data/lib/deftones/component/lfo.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class LFO < Source::Oscillator
+      attr_reader :amplitude, :units
+      attr_accessor :convert
+
+      def initialize(
+        frequency: 1.0,
+        min: 0.0,
+        max: 1.0,
+        amplitude: 1.0,
+        units: :number,
+        convert: true,
+        type: :sine,
+        context: Deftones.context
+      )
+        super(type: type, frequency: frequency, context: context)
+        @units = units.to_sym
+        @convert = !!convert
+        @amplitude = Core::Param.new(value: amplitude, units: :number, context: context)
+        self.min = min
+        self.max = max
+      end
+
+      def min
+        @min
+      end
+
+      def min=(value)
+        @min = coerce_range_value(value)
+      end
+
+      def max
+        @max
+      end
+
+      def max=(value)
+        @max = coerce_range_value(value)
+      end
+
+      def units=(value)
+        @units = value.to_sym
+      end
+
+      def get_defaults
+        {
+          frequency: 1.0,
+          min: 0.0,
+          max: 1.0,
+          amplitude: 1.0,
+          units: :number,
+          convert: true,
+          type: :sine
+        }
+      end
+
+      def process(_input_buffer, num_frames, start_frame, cache)
+        waveform = super
+        amplitudes = @amplitude.process(num_frames, start_frame)
+        midpoint = (@min + @max) * 0.5
+        half_range = (@max - @min) * 0.5
+
+        Array.new(num_frames) do |index|
+          depth = amplitudes[index].clamp(0.0, 1.0)
+          midpoint + (waveform[index] * half_range * depth)
+        end
+      end
+
+      def values(num_frames, start_frame = 0, cache = {})
+        render(num_frames, start_frame, cache)
+      end
+
+      alias getDefaults get_defaults
+
+      private
+
+      def coerce_range_value(value)
+        return value.value_of if value.respond_to?(:value_of) && !convert
+
+        signal = Core::Signal.new(value: 0.0, units: units, context: context)
+        signal.convert = convert
+        signal.send(:coerce_value, value)
+      end
+    end
+  end
+end

data/lib/deftones/component/limiter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Limiter < Compressor
+      def initialize(threshold: -1.0, ratio: 20.0, attack: 0.001, release: 0.05, **options)
+        super(threshold: threshold, ratio: ratio, attack: attack, release: release, **options)
+      end
+    end
+  end
+end

data/lib/deftones/component/lowpass_comb_filter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class LowpassCombFilter < FeedbackCombFilter
+      attr_reader :dampening
+
+      def initialize(dampening: 3_000.0, **options)
+        super(**options)
+        @dampening = Core::Signal.new(value: dampening, units: :frequency, context: context)
+        @filter_state = []
+      end
+
+      def dampening=(value)
+        @dampening.value = value
+      end
+
+      def reset!
+        @filter_state = []
+        super
+      end
+
+      private
+
+      def filtered_feedback(sample, index, start_frame, channel_index = 0)
+        ensure_filter_state(channel_index + 1)
+        coefficient = feedback_coefficient(@dampening.process(1, start_frame + index).first)
+        @filter_state[channel_index] += (1.0 - coefficient) * (sample - @filter_state[channel_index])
+        @filter_state[channel_index]
+      end
+
+      def feedback_coefficient(frequency)
+        normalized = [[frequency.to_f, 1.0].max, (context.sample_rate * 0.49)].min
+        Math.exp((-2.0 * Math::PI * normalized) / context.sample_rate)
+      end
+
+      def ensure_filter_state(channels)
+        required = [channels.to_i, 1].max
+        @filter_state.fill(0.0, @filter_state.length...required)
+      end
+    end
+  end
+end

data/lib/deftones/component/merge.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Merge < Core::AudioNode
+      attr_reader :input, :output, :left, :right
+
+      def initialize(context: Deftones.context)
+        super(context: context)
+        @left = Core::Gain.new(context: context)
+        @right = Core::Gain.new(context: context)
+        @input = @left
+        @output = self
+      end
+
+      def render(num_frames, start_frame = 0, cache = {})
+        cache_key = [object_id, start_frame, num_frames]
+        return cache.fetch(cache_key).dup if cache.key?(cache_key)
+
+        left_buffer = @left.render(num_frames, start_frame, cache)
+        right_buffer = @right.render(num_frames, start_frame, cache)
+        output_buffer = Array.new(num_frames) do |index|
+          (left_buffer[index] + right_buffer[index]) * 0.5
+        end
+
+        cache[cache_key] = output_buffer
+        output_buffer.dup
+      end
+
+      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)
+
+        left_block = @left.send(:render_block, num_frames, start_frame, cache)
+        right_block = @right.send(:render_block, num_frames, start_frame, cache)
+        output_block = Core::AudioBlock.from_channel_data([
+          left_block.mono,
+          right_block.mono
+        ])
+        cache[cache_key] = output_block
+        output_block.dup
+      end
+    end
+  end
+end

data/lib/deftones/component/mid_side_compressor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class MidSideCompressor < Core::AudioNode
+      attr_reader :input, :merge, :mid, :output, :side, :split
+
+      def initialize(mid: {}, side: {}, context: Deftones.context)
+        super(context: context)
+        @split = MidSideSplit.new(context: context)
+        @merge = MidSideMerge.new(context: context)
+        @input = @split
+        @output = @merge
+        @mid = build_compressor(mid, context)
+        @side = build_compressor(side, context)
+        @split.mid >> @mid >> @merge.mid
+        @split.side >> @side >> @merge.side
+      end
+
+      def render(num_frames, start_frame = 0, cache = {})
+        @output.render(num_frames, start_frame, cache)
+      end
+
+      def render_block(num_frames, start_frame = 0, cache = {})
+        @output.send(:render_block, num_frames, start_frame, cache)
+      end
+
+      private
+
+      def build_compressor(definition, context)
+        return definition if definition.is_a?(Compressor)
+
+        Compressor.new(
+          threshold: definition.fetch(:threshold, -24.0),
+          ratio: definition.fetch(:ratio, 3.0),
+          attack: definition.fetch(:attack, 0.01),
+          release: definition.fetch(:release, 0.1),
+          context: context
+        )
+      end
+    end
+  end
+end

data/lib/deftones/component/mid_side_merge.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class MidSideMerge < Core::AudioNode
+      SQRT_ONE_HALF = Math.sqrt(0.5)
+
+      attr_reader :input, :output, :mid, :side
+
+      def initialize(context: Deftones.context)
+        super(context: context)
+        @mid = Core::Gain.new(context: context)
+        @side = Core::Gain.new(context: context)
+        @input = @mid
+        @output = self
+      end
+
+      def render(num_frames, start_frame = 0, cache = {})
+        cache_key = [object_id, start_frame, num_frames]
+        return cache.fetch(cache_key).dup if cache.key?(cache_key)
+
+        mid_buffer = @mid.render(num_frames, start_frame, cache)
+        side_buffer = @side.render(num_frames, start_frame, cache)
+
+        output_buffer = Array.new(num_frames) do |index|
+          left = (mid_buffer[index] + side_buffer[index]) * SQRT_ONE_HALF
+          right = (mid_buffer[index] - side_buffer[index]) * SQRT_ONE_HALF
+          (left + right) * 0.5
+        end
+
+        cache[cache_key] = output_buffer
+        output_buffer.dup
+      end
+
+      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)
+
+        mid_block = @mid.send(:render_block, num_frames, start_frame, cache)
+        side_block = @side.send(:render_block, num_frames, start_frame, cache)
+        mid = mid_block.mono
+        side = side_block.mono
+        output = Core::AudioBlock.from_channel_data([
+          Array.new(num_frames) { |index| (mid[index] + side[index]) * SQRT_ONE_HALF },
+          Array.new(num_frames) { |index| (mid[index] - side[index]) * SQRT_ONE_HALF }
+        ])
+
+        cache[cache_key] = output
+        output.dup
+      end
+    end
+  end
+end

data/lib/deftones/component/mid_side_split.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class MidSideSplit < Core::AudioNode
+      SQRT_TWO = Math.sqrt(2.0)
+
+      attr_reader :mid, :side
+
+      def initialize(context: Deftones.context)
+        super(context: context)
+        @mid = OutputTap.new(parent: self, mode: :mid, context: context)
+        @side = OutputTap.new(parent: self, mode: :side, context: context)
+      end
+
+      def render_output(mode, num_frames, start_frame = 0, cache = {})
+        render_output_block(mode, num_frames, start_frame, cache).mono
+      end
+
+      def render_output_block(mode, num_frames, start_frame = 0, cache = {})
+        input_block = send(:mix_source_blocks, num_frames, start_frame, cache).fit_channels(2)
+        left = input_block.channel(0)
+        right = input_block.channel(1)
+
+        output = case mode
+                 when :mid
+                   Array.new(num_frames) { |index| (left[index] + right[index]) / SQRT_TWO }
+                 when :side
+                   Array.new(num_frames) { |index| (left[index] - right[index]) / SQRT_TWO }
+                 else
+                   raise ArgumentError, "Unsupported mid/side output: #{mode}"
+                 end
+
+        Core::AudioBlock.from_channel_data([output])
+      end
+
+      class OutputTap < Core::AudioNode
+        def initialize(parent:, mode:, context: Deftones.context)
+          super(context: context)
+          @parent = parent
+          @mode = mode
+        end
+
+        def render_block(num_frames, start_frame = 0, cache = {})
+          @parent.render_output_block(@mode, num_frames, start_frame, cache)
+        end
+
+        def render(num_frames, start_frame = 0, cache = {})
+          @parent.render_output(@mode, num_frames, start_frame, cache)
+        end
+      end
+    end
+  end
+end