deftones 0.1.0

data/lib/deftones/analysis/meter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Analysis
+    class Meter < Core::AudioNode
+      attr_accessor :normal_range
+
+      def initialize(smoothing: 0.8, normal_range: false, channels: 1, context: Deftones.context)
+        super(context: context)
+        @channels = [channels.to_i, 1].max
+        @peak_values = Array.new(@channels, 0.0)
+        @rms_values = Array.new(@channels, 0.0)
+        @normal_range = !!normal_range
+        self.smoothing = smoothing
+      end
+
+      def channels
+        @channels
+      end
+
+      def peak
+        @peak_values.length == 1 ? @peak_values.first : @peak_values.dup
+      end
+
+      def rms
+        @rms_values.length == 1 ? @rms_values.first : @rms_values.dup
+      end
+
+      def smoothing
+        @smoothing
+      end
+
+      def smoothing=(value)
+        @smoothing = Deftones::DSP::Helpers.clamp(value.to_f, 0.0, 1.0)
+      end
+
+      def get_value
+        values = @rms_values.map do |value|
+          if @normal_range
+            Deftones::DSP::Helpers.clamp(value, 0.0, 1.0)
+          else
+            Deftones.gain_to_db([value.abs, 1.0e-12].max)
+          end
+        end
+
+        values.length == 1 ? values.first : values
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, _start_frame, _cache)
+        analysis_block = input_block.fit_channels(@channels)
+
+        @channels.times do |channel_index|
+          segment = analysis_block.channel_data[channel_index].first(num_frames)
+          instantaneous_peak = segment.map(&:abs).max || 0.0
+          instantaneous_rms = Math.sqrt(segment.sum { |sample| sample * sample } / [segment.length, 1].max)
+          @peak_values[channel_index] = smooth(@peak_values[channel_index], instantaneous_peak)
+          @rms_values[channel_index] = smooth(@rms_values[channel_index], instantaneous_rms)
+        end
+
+        input_block
+      end
+
+      alias getValue get_value
+      alias normalRange normal_range
+
+      def normalRange=(value)
+        self.normal_range = value
+      end
+
+      private
+
+      def smooth(previous, current)
+        return current if @smoothing.zero?
+
+        (previous.to_f * @smoothing) + (current.to_f * (1.0 - @smoothing))
+      end
+    end
+  end
+end

data/lib/deftones/analysis/waveform.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Analysis
+    class Waveform < Core::AudioNode
+      class Snapshot
+        attr_reader :samples
+
+        def initialize(samples)
+          @samples = samples
+        end
+
+        def peak
+          @samples.map(&:abs).max || 0.0
+        end
+
+        def rms
+          return 0.0 if @samples.empty?
+
+          Math.sqrt(@samples.sum { |sample| sample * sample } / @samples.length)
+        end
+      end
+
+      def initialize(size: 1024, smoothing: 0.8, return_type: :float, normal_range: false, context: Deftones.context)
+        super(context: context)
+        @delegate = Analysis::Analyser.new(
+          size: size,
+          type: :waveform,
+          smoothing: smoothing,
+          return_type: return_type,
+          normal_range: normal_range,
+          context: context
+        )
+      end
+
+      def size
+        @delegate.size
+      end
+
+      def size=(value)
+        @delegate.size = value
+      end
+
+      def smoothing
+        @delegate.smoothing
+      end
+
+      def smoothing=(value)
+        @delegate.smoothing = value
+      end
+
+      def return_type
+        @delegate.return_type
+      end
+
+      def return_type=(value)
+        @delegate.return_type = value
+      end
+
+      def normal_range
+        @delegate.normal_range
+      end
+
+      def normal_range=(value)
+        @delegate.normal_range = value
+      end
+
+      def get_value
+        @delegate.get_value
+      end
+
+      alias getValue get_value
+      alias returnType return_type
+      alias normalRange normal_range
+
+      def returnType=(value)
+        self.return_type = value
+      end
+
+      def normalRange=(value)
+        self.normal_range = value
+      end
+
+      def process(input_buffer, num_frames, start_frame, cache)
+        @delegate.process(input_buffer, num_frames, start_frame, cache)
+      end
+
+      def multichannel_process?
+        true
+      end
+    end
+  end
+end

data/lib/deftones/component/amplitude_envelope.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class AmplitudeEnvelope < Envelope
+    end
+  end
+end

data/lib/deftones/component/biquad_filter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    BiquadFilter = Filter
+  end
+end

data/lib/deftones/component/channel.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Channel < Core::AudioNode
+      @buses = Hash.new { |hash, key| hash[key] = {} }
+
+      class << self
+        attr_reader :buses
+      end
+
+      attr_reader :input, :output, :pan_vol, :solo
+
+      def initialize(pan: 0.0, volume: 0.0, solo: false, muted: false, mute: nil, context: Deftones.context)
+        super(context: context)
+        muted = mute unless mute.nil?
+        @pan_vol = PanVol.new(pan: pan, volume: volume, context: context)
+        @solo = Solo.new(solo: solo, muted: muted, context: context)
+        @input = @pan_vol.input
+        @output = @solo
+        @sends = []
+        @pan_vol.output >> @solo
+      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
+
+      def pan
+        @pan_vol.panner.pan
+      end
+
+      def pan=(value)
+        @pan_vol.panner.pan = value
+      end
+
+      def volume
+        @pan_vol.volume.volume
+      end
+
+      def volume=(value)
+        @pan_vol.volume.volume = value
+      end
+
+      def mute
+        @solo.mute
+      end
+
+      def mute=(value)
+        @solo.mute = value
+      end
+
+      def mute?
+        @solo.mute?
+      end
+
+      def muted
+        mute
+      end
+
+      def muted=(value)
+        self.mute = value
+      end
+
+      def solo?
+        @solo.solo?
+      end
+
+      def solo=(value)
+        @solo.solo = value
+      end
+
+      def send(name, volume = 0.0)
+        send_gain = Core::Gain.new(gain: Deftones.db_to_gain(volume), context: context)
+        @output >> send_gain >> bus(name)
+        @sends << send_gain
+        send_gain
+      end
+
+      def receive(name)
+        bus(name) >> @input
+        self
+      end
+
+      def dispose
+        @sends.each(&:dispose)
+        @sends.clear
+        @pan_vol.dispose
+        @solo.dispose
+        super
+      end
+
+      alias panVol pan_vol
+      alias solo solo?
+      alias muted? muted
+
+      private
+
+      def bus(name)
+        registry = self.class.buses[context.object_id]
+        registry[name.to_sym] ||= Core::Gain.new(gain: 1.0, context: context)
+      end
+    end
+  end
+end

data/lib/deftones/component/compressor.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Compressor < Core::AudioNode
+      attr_accessor :threshold, :ratio, :attack, :release
+
+      def initialize(threshold: -18.0, ratio: 4.0, attack: 0.01, release: 0.1, context: Deftones.context)
+        super(context: context)
+        @threshold = threshold.to_f
+        @ratio = ratio.to_f
+        @attack = attack.to_f
+        @release = release.to_f
+        @gain_db = []
+      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| compress(channel[index], channel_index) }
+          end
+        )
+      end
+
+      private
+
+      def compress(sample, channel_index)
+        level = [sample.abs, 1.0e-9].max
+        level_db = 20.0 * Math.log10(level)
+        target_gain_db =
+          if level_db > @threshold
+            compressed_db = @threshold + ((level_db - @threshold) / [@ratio, 1.0].max)
+            compressed_db - level_db
+          else
+            0.0
+          end
+
+        current_gain_db = @gain_db[channel_index]
+        smoothing = target_gain_db < current_gain_db ? attack_smoothing : release_smoothing
+        current_gain_db += (target_gain_db - current_gain_db) * smoothing
+        @gain_db[channel_index] = current_gain_db
+        sample * (10.0**(current_gain_db / 20.0))
+      end
+
+      def attack_smoothing
+        1.0 / [(@attack * context.sample_rate), 1.0].max
+      end
+
+      def release_smoothing
+        1.0 / [(@release * context.sample_rate), 1.0].max
+      end
+
+      def ensure_gain_state(channels)
+        required = [channels.to_i, 1].max
+        @gain_db.fill(0.0, @gain_db.length...required)
+      end
+    end
+  end
+end

data/lib/deftones/component/convolver.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Convolver < Core::Effect
+      attr_reader :buffer
+      attr_accessor :normalize
+
+      def initialize(source = nil, wet: 1.0, normalize: false, context: Deftones.context, &onload)
+        super(wet: wet, context: context)
+        @normalize = normalize
+        @buffer = nil
+        @kernels = [[1.0]]
+        @histories = []
+        load(source, &onload) if source
+      end
+
+      def buffer=(value)
+        load(value)
+      end
+
+      def load(source)
+        @buffer = coerce_buffer(source)
+        @kernels = normalize_kernels(@buffer.to_array)
+        @histories = []
+        yield self if block_given?
+        self
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, _start_frame, _cache)
+        return input_block if passthrough?
+
+        output_channels = [input_block.channels, @kernels.length].max
+        source = input_block.fit_channels([input_block.channels, 1].max)
+        output = Array.new(output_channels) { Array.new(num_frames, 0.0) }
+
+        output_channels.times do |channel_index|
+          kernel = @kernels[channel_index % @kernels.length]
+          history = ensure_history(channel_index, kernel.length).dup
+          input_channel = source.channel_data[[channel_index, source.channels - 1].min]
+
+          output[channel_index] = Array.new(num_frames) do |frame_index|
+            history << input_channel[frame_index]
+            sample = convolve(history, kernel)
+            history.shift while history.length > kernel.length
+            sample
+          end
+
+          @histories[channel_index] = history
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def passthrough?
+        @buffer.nil? || (@kernels.length == 1 && @kernels.first.length == 1 && @kernels.first.first == 1.0)
+      end
+
+      def convolve(history, kernel)
+        kernel.each_with_index.sum do |coefficient, offset|
+          history_index = history.length - 1 - offset
+          next 0.0 if history_index.negative?
+
+          coefficient * history[history_index]
+        end
+      end
+
+      def coerce_buffer(source)
+        return source if source.is_a?(IO::Buffer)
+
+        IO::Buffer.load(source)
+      end
+
+      def normalize_kernels(channel_arrays)
+        kernels = channel_arrays.map { |channel| channel.map(&:to_f) }.reject(&:empty?)
+        return [[1.0]] if kernels.empty?
+        return kernels unless @normalize
+
+        peak = kernels.flatten.map(&:abs).max || 0.0
+        return kernels if peak.zero?
+
+        kernels.map { |kernel| kernel.map { |sample| sample / peak } }
+      end
+
+      def ensure_history(channel_index, kernel_length)
+        required = [channel_index.to_i, 0].max
+        while @histories.length <= required
+          @histories << Array.new([kernel_length - 1, 0].max, 0.0)
+        end
+        if @histories[required].length != [kernel_length - 1, 0].max
+          @histories[required] = Array.new([kernel_length - 1, 0].max, 0.0)
+        end
+        @histories[required]
+      end
+    end
+  end
+end

data/lib/deftones/component/cross_fade.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class CrossFade < Core::AudioNode
+      attr_reader :input, :output, :a, :b, :fade
+
+      def initialize(fade: 0.5, context: Deftones.context)
+        super(context: context)
+        @a = Core::Gain.new(context: context)
+        @b = Core::Gain.new(context: context)
+        @fade = Core::Signal.new(value: fade, units: :number, context: context)
+        @input = @a
+        @output = self
+      end
+
+      def fade=(value)
+        @fade.value = value
+      end
+
+      def left
+        @a
+      end
+
+      def right
+        @b
+      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)
+
+        fades = @fade.process(num_frames, start_frame)
+        a_buffer = @a.render(num_frames, start_frame, cache)
+        b_buffer = @b.render(num_frames, start_frame, cache)
+        output_buffer = Array.new(num_frames) do |index|
+          DSP::Helpers.mix(a_buffer[index], b_buffer[index], fades[index].clamp(0.0, 1.0))
+        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)
+
+        fades = @fade.process(num_frames, start_frame)
+        a_block = @a.send(:render_block, num_frames, start_frame, cache)
+        b_block = @b.send(:render_block, num_frames, start_frame, cache)
+        channels = [a_block.channels, b_block.channels].max
+        mixed = Core::AudioBlock.from_channel_data(
+          Array.new(channels) do |channel_index|
+            a_channel = a_block.fit_channels(channels).channel(channel_index)
+            b_channel = b_block.fit_channels(channels).channel(channel_index)
+            Array.new(num_frames) do |index|
+              DSP::Helpers.mix(a_channel[index], b_channel[index], fades[index].clamp(0.0, 1.0))
+            end
+          end
+        )
+
+        cache[cache_key] = mixed
+        mixed.dup
+      end
+    end
+  end
+end

data/lib/deftones/component/envelope.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Component
+    class Envelope < Core::AudioNode
+      STATES = %i[idle attack decay sustain release].freeze
+
+      attr_accessor :attack, :decay, :sustain, :release
+      attr_reader :state
+
+      def initialize(attack: 0.01, decay: 0.1, sustain: 0.5, release: 1.0, context: Deftones.context)
+        super(context: context)
+        @attack = attack.to_f
+        @decay = decay.to_f
+        @sustain = sustain.to_f
+        @release = release.to_f
+        @state = :idle
+        @events = []
+        @current_value = 0.0
+        @velocity = 1.0
+        @stage_started_at = 0.0
+        @stage_from_value = 0.0
+      end
+
+      def trigger_attack(time = nil, velocity = 1.0)
+        schedule_event(:attack, resolve_time(time), velocity.to_f)
+      end
+
+      def trigger_release(time = nil)
+        schedule_event(:release, resolve_time(time), nil)
+      end
+
+      def trigger_attack_release(duration, time = nil, velocity = 1.0)
+        attack_time = resolve_time(time)
+        trigger_attack(attack_time, velocity)
+        trigger_release(attack_time + Deftones::Music::Time.parse(duration))
+      end
+
+      def active?
+        @state != :idle || !@events.empty?
+      end
+
+      def idle?
+        !active?
+      end
+
+      def multichannel_process?
+        true
+      end
+
+      def process(input_block, num_frames, start_frame, _cache)
+        values = Array.new(num_frames) do |index|
+          time = sample_time(start_frame + index)
+          consume_events(time)
+          @current_value = envelope_value_at(time)
+          @current_value
+        end
+
+        Core::AudioBlock.from_channel_data(
+          input_block.channel_data.map do |channel|
+            Array.new(num_frames) { |index| channel[index] * values[index] }
+          end
+        )
+      end
+
+      private
+
+      def schedule_event(type, time, velocity)
+        @events << { type: type, time: time, velocity: velocity }
+        @events.sort_by! { |event| event[:time] }
+        self
+      end
+
+      def consume_events(time)
+        while @events.any? && @events.first[:time] <= time
+          event = @events.shift
+
+          case event[:type]
+          when :attack
+            @state = :attack
+            @velocity = event[:velocity] || 1.0
+            @stage_started_at = event[:time]
+            @stage_from_value = @current_value
+          when :release
+            @state = :release
+            @stage_started_at = event[:time]
+            @stage_from_value = @current_value
+          end
+        end
+      end
+
+      def envelope_value_at(time)
+        case @state
+        when :idle
+          0.0
+        when :attack
+          attack_value(time)
+        when :decay
+          decay_value(time)
+        when :sustain
+          @velocity * @sustain
+        when :release
+          release_value(time)
+        else
+          0.0
+        end
+      end
+
+      def attack_value(time)
+        return transition_to(:decay, @velocity, time) if @attack <= 0.0
+
+        progress = (time - @stage_started_at) / @attack
+        return transition_to(:decay, @velocity, @stage_started_at + @attack) if progress >= 1.0
+
+        lerp(@stage_from_value, @velocity, progress)
+      end
+
+      def decay_value(time)
+        sustain_level = @velocity * @sustain
+        return transition_to(:sustain, sustain_level, time) if @decay <= 0.0
+
+        progress = (time - @stage_started_at) / @decay
+        return transition_to(:sustain, sustain_level, @stage_started_at + @decay) if progress >= 1.0
+
+        lerp(@velocity, sustain_level, progress)
+      end
+
+      def release_value(time)
+        return transition_to(:idle, 0.0, time) if @release <= 0.0
+
+        progress = (time - @stage_started_at) / @release
+        return transition_to(:idle, 0.0, @stage_started_at + @release) if progress >= 1.0
+
+        lerp(@stage_from_value, 0.0, progress)
+      end
+
+      def transition_to(next_state, value, time)
+        @state = next_state
+        @stage_started_at = time
+        @stage_from_value = value
+        @current_value = value
+        value
+      end
+
+      def lerp(from, to, progress)
+        from + ((to - from) * progress.clamp(0.0, 1.0))
+      end
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+
+      def sample_time(frame_index)
+        frame_index.to_f / context.sample_rate
+      end
+    end
+  end
+end