deftones 0.1.0

data/lib/deftones/component/mono.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Mono < Core::AudioNode
+    end
+  end
+end

data/lib/deftones/component/multiband_compressor.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class MultibandCompressor < Core::AudioNode
+      attr_reader :high, :high_frequency, :input, :low, :low_frequency, :mid, :output, :q, :split
+
+      def initialize(low_frequency: 400.0, high_frequency: 2_500.0, q: 1.0, low: {}, mid: {}, high: {},
+                     context: Deftones.context)
+        super(context: context)
+        @split = MultibandSplit.new(
+          low_frequency: low_frequency,
+          high_frequency: high_frequency,
+          q: q,
+          context: context
+        )
+        @input = @split.input
+        @output = self
+        @low = Compressor.new(context: context, **compressor_options(low))
+        @mid = Compressor.new(context: context, **compressor_options(mid))
+        @high = Compressor.new(context: context, **compressor_options(high))
+        @split.low >> @low
+        @split.mid >> @mid
+        @split.high >> @high
+      end
+
+      def low_frequency
+        @split.low_frequency
+      end
+
+      def high_frequency
+        @split.high_frequency
+      end
+
+      def q
+        @split.q
+      end
+
+      def render(num_frames, start_frame = 0, cache = {})
+        render_block(num_frames, start_frame, cache).mono
+      end
+
+      def render_block(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)
+
+        low_buffer = @low.send(:render_block, num_frames, start_frame, cache)
+        mid_buffer = @mid.send(:render_block, num_frames, start_frame, cache)
+        high_buffer = @high.send(:render_block, num_frames, start_frame, cache)
+        channels = [low_buffer.channels, mid_buffer.channels, high_buffer.channels].max
+        output_buffer = Core::AudioBlock.silent(num_frames, channels)
+        output_buffer.mix!(low_buffer).mix!(mid_buffer).mix!(high_buffer)
+
+        cache[cache_key] = output_buffer
+        output_buffer.dup
+      end
+
+      private
+
+      def compressor_options(options)
+        {
+          threshold: options.fetch(:threshold, -24.0),
+          ratio: options.fetch(:ratio, 3.0),
+          attack: options.fetch(:attack, 0.01),
+          release: options.fetch(:release, 0.1)
+        }
+      end
+    end
+  end
+end

data/lib/deftones/component/multiband_split.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class MultibandSplit < Core::AudioNode
+      attr_reader :input, :high, :high_frequency, :low, :low_frequency, :mid, :output, :q
+
+      def initialize(low_frequency: 400.0, high_frequency: 2_500.0, q: 1.0, context: Deftones.context)
+        super(context: context)
+        @input = Core::Gain.new(context: context)
+        @output = self
+        @low_frequency = Core::Signal.new(value: low_frequency, units: :frequency, context: context)
+        @high_frequency = Core::Signal.new(value: high_frequency, units: :frequency, context: context)
+        @q = Core::Signal.new(value: q, units: :number, context: context)
+        @low = OutputTap.new(parent: self, band: :low, context: context)
+        @mid = OutputTap.new(parent: self, band: :mid, context: context)
+        @high = OutputTap.new(parent: self, band: :high, context: context)
+        @low_filters = []
+        @mid_highpasses = []
+        @mid_lowpasses = []
+        @high_filters = []
+      end
+
+      def render(num_frames, start_frame = 0, cache = {})
+        render_block(num_frames, start_frame, cache).mono
+      end
+
+      def render_band(band, num_frames, start_frame = 0, cache = {})
+        render_band_block(band, num_frames, start_frame, cache).mono
+      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)
+
+        bands = render_bands_block(num_frames, start_frame, cache)
+        channels = bands[:low].channels
+        output = Core::AudioBlock.silent(num_frames, channels)
+        output.mix!(bands[:low]).mix!(bands[:mid]).mix!(bands[:high])
+
+        cache[cache_key] = output
+        output.dup
+      end
+
+      def render_band_block(band, num_frames, start_frame = 0, cache = {})
+        render_bands_block(num_frames, start_frame, cache).fetch(band).dup
+      end
+
+      def reset!
+        [@low_filters, @mid_highpasses, @mid_lowpasses, @high_filters].each do |filters|
+          filters.each(&:reset!)
+        end
+        self
+      end
+
+      private
+
+      def render_bands_block(num_frames, start_frame, cache)
+        cache_key = [object_id, :bands_block, start_frame, num_frames]
+        return cache.fetch(cache_key) if cache.key?(cache_key)
+
+        input_block = @input.send(:render_block, num_frames, start_frame, cache)
+        update_filters(input_block.channels, start_frame)
+
+        low = Array.new(input_block.channels) { Array.new(num_frames, 0.0) }
+        mid = Array.new(input_block.channels) { Array.new(num_frames, 0.0) }
+        high = Array.new(input_block.channels) { Array.new(num_frames, 0.0) }
+
+        input_block.channel_data.each_with_index do |channel, channel_index|
+          num_frames.times do |index|
+            sample = channel[index]
+            low[channel_index][index] = @low_filters[channel_index].process_sample(sample)
+            mid[channel_index][index] =
+              @mid_lowpasses[channel_index].process_sample(@mid_highpasses[channel_index].process_sample(sample))
+            high[channel_index][index] = @high_filters[channel_index].process_sample(sample)
+          end
+        end
+
+        cache[cache_key] = {
+          low: Core::AudioBlock.from_channel_data(low),
+          mid: Core::AudioBlock.from_channel_data(mid),
+          high: Core::AudioBlock.from_channel_data(high)
+        }
+      end
+
+      def update_filters(channels, start_frame)
+        ensure_filter_banks(channels)
+        current_low_frequency = @low_frequency.process(1, start_frame).first
+        current_high_frequency = @high_frequency.process(1, start_frame).first
+        current_q = @q.process(1, start_frame).first
+
+        @low_filters.each do |filter|
+          filter.update(type: :lowpass, frequency: current_low_frequency, q: current_q, gain_db: 0.0, sample_rate: context.sample_rate)
+        end
+        @mid_highpasses.each do |filter|
+          filter.update(type: :highpass, frequency: current_low_frequency, q: current_q, gain_db: 0.0, sample_rate: context.sample_rate)
+        end
+        @mid_lowpasses.each do |filter|
+          filter.update(type: :lowpass, frequency: current_high_frequency, q: current_q, gain_db: 0.0, sample_rate: context.sample_rate)
+        end
+        @high_filters.each do |filter|
+          filter.update(type: :highpass, frequency: current_high_frequency, q: current_q, gain_db: 0.0, sample_rate: context.sample_rate)
+        end
+      end
+
+      def ensure_filter_banks(channels)
+        required = [channels.to_i, 1].max
+        while @low_filters.length < required
+          @low_filters << DSP::Biquad.new
+          @mid_highpasses << DSP::Biquad.new
+          @mid_lowpasses << DSP::Biquad.new
+          @high_filters << DSP::Biquad.new
+        end
+      end
+
+      class OutputTap < Core::AudioNode
+        def initialize(parent:, band:, context: Deftones.context)
+          super(context: context)
+          @parent = parent
+          @band = band
+        end
+
+        def render(num_frames, start_frame = 0, cache = {})
+          @parent.render_band(@band, num_frames, start_frame, cache)
+        end
+
+        def render_block(num_frames, start_frame = 0, cache = {})
+          @parent.render_band_block(@band, num_frames, start_frame, cache)
+        end
+      end
+    end
+  end
+end

data/lib/deftones/component/one_pole_filter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class OnePoleFilter < Core::AudioNode
+      TYPES = %i[lowpass highpass].freeze
+
+      attr_reader :frequency
+      attr_accessor :type
+
+      def initialize(frequency: 880.0, type: :lowpass, context: Deftones.context)
+        super(context: context)
+        @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
+        @type = normalize_type(type)
+        @lowpass_state = []
+      end
+
+      def frequency=(value)
+        @frequency.value = value
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        frequencies = @frequency.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|
+            input_sample = channel[index]
+            coefficient = coefficient_for(frequencies[index])
+            @lowpass_state[channel_index] += (1.0 - coefficient) * (input_sample - @lowpass_state[channel_index])
+
+            if normalize_type(@type) == :lowpass
+              @lowpass_state[channel_index]
+            else
+              input_sample - @lowpass_state[channel_index]
+            end
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output_channels)
+      end
+
+      def reset!
+        @lowpass_state = []
+        self
+      end
+
+      private
+
+      def coefficient_for(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 normalize_type(type)
+        normalized = type.to_sym
+        return normalized if TYPES.include?(normalized)
+
+        raise ArgumentError, "Unsupported one pole filter type: #{type}"
+      end
+
+      def ensure_state(channels)
+        required = [channels.to_i, 1].max
+        @lowpass_state.fill(0.0, @lowpass_state.length...required)
+      end
+    end
+  end
+end

data/lib/deftones/component/pan_vol.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class PanVol < Core::AudioNode
+      attr_reader :input, :output, :panner, :volume
+
+      def initialize(pan: 0.0, volume: 0.0, context: Deftones.context)
+        super(context: context)
+        @panner = Panner.new(pan: pan, context: context)
+        @volume = Volume.new(volume: volume, context: context)
+        @input = @panner
+        @output = @volume
+        @panner >> @volume
+      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
+    end
+  end
+end

data/lib/deftones/component/panner.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Panner < Core::AudioNode
+      attr_reader :pan
+
+      def initialize(pan: 0.0, context: Deftones.context)
+        super(context: context)
+        @pan = Core::Signal.new(value: pan, units: :number, context: context)
+      end
+
+      def pan=(value)
+        @pan.value = value
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        pans = @pan.process(num_frames, start_frame)
+        return process_mono_input(input_block, num_frames, pans) if input_block.channels == 1
+
+        stereo_input = input_block.fit_channels(2)
+        left = Array.new(num_frames)
+        right = Array.new(num_frames)
+
+        num_frames.times do |index|
+          left[index] = stereo_input.channel_data[0][index] * stereo_left_gain(pans[index])
+          right[index] = stereo_input.channel_data[1][index] * stereo_right_gain(pans[index])
+        end
+
+        Core::AudioBlock.from_channel_data([left, right])
+      end
+
+      private
+
+      def process_mono_input(input_block, num_frames, pans)
+        mono_input = input_block.mono
+
+        Core::AudioBlock.from_channel_data([
+          Array.new(num_frames) { |index| mono_input[index] * left_gain(pans[index]) },
+          Array.new(num_frames) { |index| mono_input[index] * right_gain(pans[index]) }
+        ])
+      end
+
+      def stereo_left_gain(pan)
+        normalized = pan.to_f.clamp(-1.0, 1.0)
+        return 1.0 if normalized <= 0.0
+
+        Math.cos(normalized * Math::PI * 0.5)
+      end
+
+      def stereo_right_gain(pan)
+        normalized = pan.to_f.clamp(-1.0, 1.0)
+        return 1.0 if normalized >= 0.0
+
+        Math.cos(normalized.abs * Math::PI * 0.5)
+      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