deftones 0.1.0

data/lib/deftones/source/fm_oscillator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class FMOscillator < Core::Source
+      attr_reader :frequency, :harmonicity, :modulation_index, :detune
+
+      def initialize(frequency: 440.0, harmonicity: 2.0, modulation_index: 5.0,
+                     detune: 0.0, phase: 0.0, context: Deftones.context)
+        super(context: context)
+        @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
+        @harmonicity = Core::Signal.new(value: harmonicity, units: :number, context: context)
+        @modulation_index = Core::Signal.new(value: modulation_index, units: :number, context: context)
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        @carrier_phase = phase.to_f % 1.0
+        @modulator_phase = phase.to_f % 1.0
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        frequencies = @frequency.process(num_frames, start_frame)
+        harmonicities = @harmonicity.process(num_frames, start_frame)
+        modulation_indices = @modulation_index.process(num_frames, start_frame)
+        detunes = @detune.process(num_frames, start_frame)
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          next 0.0 unless active_at?(current_time)
+
+          carrier_frequency = frequencies[index] * (2.0**(detunes[index].to_f / 1200.0))
+          modulator_frequency = carrier_frequency * harmonicities[index]
+          modulation = Math.sin(2.0 * Math::PI * @modulator_phase) * modulation_indices[index]
+          sample = Math.sin((2.0 * Math::PI * @carrier_phase) + modulation)
+
+          @carrier_phase = (@carrier_phase + (carrier_frequency / context.sample_rate)) % 1.0
+          @modulator_phase = (@modulator_phase + (modulator_frequency / context.sample_rate)) % 1.0
+          sample
+        end
+      end
+
+      alias modulationIndex modulation_index
+    end
+  end
+end

data/lib/deftones/source/grain_player.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class GrainPlayer < Player
+      attr_reader :detune
+      attr_accessor :grain_size, :overlap, :jitter
+
+      def initialize(grain_size: 0.05, overlap: 0.5, jitter: 0.002, detune: 0.0, **options)
+        super(**options)
+        @grain_size = grain_size.to_f
+        @overlap = overlap.to_f
+        @jitter = jitter.to_f
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        rates = @playback_rate.process(num_frames, start_frame)
+        detunes = @detune.process(num_frames, start_frame)
+        grain_duration = grain_duration_seconds
+        overlap_duration = overlap_duration_seconds(grain_duration)
+        grain_interval = grain_interval_seconds(grain_duration, overlap_duration)
+        active_grains = active_grain_count(grain_duration, grain_interval)
+        return process_multichannel_buffer(num_frames, start_frame, rates, detunes, grain_duration, overlap_duration, grain_interval, active_grains) if multichannel_process?
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          notify_stop(current_time) if @stop_time && current_time >= @stop_time
+          next 0.0 unless active_at?(current_time)
+
+          rate = positive_rate(rates[index])
+          output = granular_sample(
+            current_time,
+            playback_rate: rate,
+            detune_ratio: detune_ratio(detunes[index]),
+            grain_duration: grain_duration,
+            overlap_duration: overlap_duration,
+            grain_interval: grain_interval,
+            active_grains: active_grains
+          )
+
+          if naturally_finished?(current_time, rate, grain_duration)
+            @stop_time ||= current_time
+            notify_stop(current_time)
+            next 0.0
+          end
+
+          output * envelope_gain(current_time)
+        end
+      end
+
+      private
+
+      def process_multichannel_buffer(num_frames, start_frame, rates, detunes, grain_duration, overlap_duration, grain_interval, active_grains)
+        output = Array.new(@buffer.channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          notify_stop(current_time) if @stop_time && current_time >= @stop_time
+          next unless active_at?(current_time)
+
+          rate = positive_rate(rates[index])
+          detune = detune_ratio(detunes[index])
+
+          @buffer.channels.times do |channel_index|
+            output[channel_index][index] = granular_sample(
+              current_time,
+              playback_rate: rate,
+              detune_ratio: detune,
+              grain_duration: grain_duration,
+              overlap_duration: overlap_duration,
+              grain_interval: grain_interval,
+              active_grains: active_grains,
+              channel_index: channel_index
+            )
+          end
+
+          if naturally_finished?(current_time, rate, grain_duration)
+            @stop_time ||= current_time
+            notify_stop(current_time)
+          else
+            gain = envelope_gain(current_time)
+            @buffer.channels.times do |channel_index|
+              output[channel_index][index] *= gain
+            end
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def granular_sample(current_time, playback_rate:, detune_ratio:, grain_duration:, overlap_duration:, grain_interval:,
+                          active_grains:, channel_index: nil)
+        current_grain = grain_index_at(current_time, grain_interval)
+        first_grain = [current_grain - active_grains, 0].max
+
+        (first_grain..current_grain).sum(0.0) do |grain_index|
+          grain_elapsed = current_time - grain_start_time(grain_index, grain_interval)
+          next 0.0 if grain_elapsed.negative? || grain_elapsed >= grain_duration
+
+          logical_position = grain_logical_position(grain_index, grain_elapsed, playback_rate, detune_ratio, grain_interval)
+          sample_position = resolve_buffer_position(logical_position)
+          next 0.0 if sample_position.negative?
+
+          sample =
+            if channel_index.nil?
+              @buffer.sample_at(sample_position)
+            else
+              @buffer.sample_at(sample_position, channel_index)
+            end
+          sample * grain_window_gain(grain_elapsed, grain_duration, overlap_duration)
+        end
+      end
+
+      def grain_duration_seconds
+        [@grain_size.to_f, context.sample_time].max
+      end
+
+      def overlap_duration_seconds(grain_duration)
+        @overlap.to_f.clamp(0.0, grain_duration)
+      end
+
+      def grain_interval_seconds(grain_duration, overlap_duration)
+        [grain_duration - overlap_duration, context.sample_time].max
+      end
+
+      def active_grain_count(grain_duration, grain_interval)
+        [(grain_duration / grain_interval).ceil + 1, 1].max
+      end
+
+      def grain_index_at(current_time, grain_interval)
+        ((current_time - @start_time) / grain_interval).floor
+      end
+
+      def grain_start_time(grain_index, grain_interval)
+        @start_time + (grain_index * grain_interval)
+      end
+
+      def grain_logical_position(grain_index, grain_elapsed, playback_rate, detune_ratio, grain_interval)
+        anchor = @seek_position + grain_anchor_offset(grain_index, playback_rate, grain_interval)
+        anchor + grain_jitter_offset(grain_index) + (grain_elapsed * @buffer.sample_rate * detune_ratio)
+      end
+
+      def grain_anchor_offset(grain_index, playback_rate, grain_interval)
+        grain_index * grain_interval * @buffer.sample_rate * playback_rate
+      end
+
+      def grain_jitter_offset(grain_index)
+        return 0.0 if @jitter.zero?
+
+        ((grain_random(grain_index) * 2.0) - 1.0) * @jitter * @buffer.sample_rate
+      end
+
+      def grain_random(grain_index)
+        Math.sin((grain_index + 1) * 12_989.0).abs % 1.0
+      end
+
+      def grain_window_gain(grain_elapsed, grain_duration, overlap_duration)
+        return 1.0 if overlap_duration <= 0.0
+
+        fade_in = (grain_elapsed / overlap_duration).clamp(0.0, 1.0)
+        fade_out = ((grain_duration - grain_elapsed) / overlap_duration).clamp(0.0, 1.0)
+        [fade_in, fade_out].min
+      end
+
+      def naturally_finished?(current_time, playback_rate, grain_duration)
+        return false if @loop
+        return false unless playback_rate.positive?
+
+        current_time >= natural_stop_time(playback_rate, grain_duration)
+      end
+
+      def natural_stop_time(playback_rate, grain_duration)
+        @start_time + (playable_frame_span / (@buffer.sample_rate * playback_rate)) + grain_duration
+      end
+
+      def playable_frame_span
+        return [@buffer.frames - @seek_position, 0.0].max unless @reverse
+
+        min_position = @loop_start * @buffer.sample_rate
+        max_position = loop_end_frame || (@buffer.frames - 1)
+        [max_position - min_position - @seek_position, 0.0].max
+      end
+
+      def positive_rate(value)
+        [value.to_f.abs, Float::EPSILON].max
+      end
+
+      def detune_ratio(cents)
+        2.0**(cents.to_f / 1200.0)
+      end
+    end
+  end
+end

data/lib/deftones/source/karplus_strong.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class KarplusStrong < Core::Source
+      def initialize(decay: 0.995, damping: 0.5, context: Deftones.context)
+        super(context: context)
+        @decay = decay.to_f
+        @damping = damping.to_f
+        @events = []
+        @buffer = []
+        @buffer_index = 0
+      end
+
+      def trigger(note, time = nil, velocity = 1.0)
+        @events << {
+          time: resolve_time(time),
+          frequency: Deftones::Music::Note.to_frequency(note),
+          velocity: velocity.to_f
+        }
+        @events.sort_by! { |event| event[:time] }
+        self
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        Array.new(num_frames) do |index|
+          time = (start_frame + index).to_f / context.sample_rate
+          consume_events(time)
+          next 0.0 if @buffer.empty?
+
+          current = @buffer[@buffer_index]
+          following = @buffer[(@buffer_index + 1) % @buffer.length]
+          @buffer[@buffer_index] = ((current + following) * 0.5 * @decay) + ((following - current) * @damping * 0.01)
+          @buffer_index = (@buffer_index + 1) % @buffer.length
+          current
+        end
+      end
+
+      private
+
+      def consume_events(time)
+        while @events.any? && @events.first[:time] <= time
+          event = @events.shift
+          delay_length = [1, (context.sample_rate / event[:frequency]).round].max
+          @buffer = Array.new(delay_length) { ((rand * 2.0) - 1.0) * event[:velocity] }
+          @buffer_index = 0
+        end
+      end
+    end
+  end
+end

data/lib/deftones/source/noise.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class Noise < Core::Source
+      TYPES = %i[white pink brown].freeze
+
+      attr_accessor :type, :fade_in, :fade_out
+      attr_reader :playback_rate
+
+      def initialize(type: :white, playback_rate: 1.0, fade_in: 0.0, fade_out: 0.0, context: Deftones.context)
+        super(context: context)
+        @type = normalize_type(type)
+        @playback_rate = playback_rate.to_f
+        @fade_in = fade_in.to_f
+        @fade_out = fade_out.to_f
+        @pink_state = 0.0
+        @brown_state = 0.0
+        @held_sample = next_noise_sample
+        @playback_phase = 0.0
+      end
+
+      def playback_rate=(value)
+        @playback_rate = value.to_f
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          next 0.0 unless active_at?(current_time)
+
+          next_sample * envelope_gain(current_time)
+        end
+      end
+
+      alias fadeIn fade_in
+      alias fadeIn= fade_in=
+      alias fadeOut fade_out
+      alias fadeOut= fade_out=
+
+      private
+
+      def next_sample
+        sample = @held_sample
+        advance_playback
+        sample
+      end
+
+      def advance_playback
+        @playback_phase += [@playback_rate, 1.0e-6].max
+        steps = @playback_phase.floor
+        return if steps <= 0
+
+        steps.times { @held_sample = next_noise_sample }
+        @playback_phase -= steps
+      end
+
+      def envelope_gain(current_time)
+        fade_in_gain(current_time) * fade_out_gain(current_time)
+      end
+
+      def fade_in_gain(current_time)
+        return 1.0 if @fade_in <= 0.0
+
+        ((current_time - @start_time) / @fade_in).clamp(0.0, 1.0)
+      end
+
+      def fade_out_gain(current_time)
+        return 1.0 unless @stop_time && @fade_out > 0.0
+
+        ((@stop_time - current_time) / @fade_out).clamp(0.0, 1.0)
+      end
+
+      def next_noise_sample
+        white = (rand * 2.0) - 1.0
+
+        case normalize_type(@type)
+        when :white
+          white
+        when :pink
+          @pink_state = (0.98 * @pink_state) + (0.02 * white)
+          @pink_state * 3.5
+        when :brown
+          @brown_state = Deftones::DSP::Helpers.clamp(@brown_state + (white * 0.02), -1.0, 1.0)
+        end
+      end
+
+      def normalize_type(type)
+        normalized = type.to_sym
+        return normalized if TYPES.include?(normalized)
+
+        raise ArgumentError, "Unsupported noise type: #{type}"
+      end
+
+      alias playbackRate playback_rate
+      alias playbackRate= playback_rate=
+    end
+  end
+end

data/lib/deftones/source/omni_oscillator.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class OmniOscillator < Core::Source
+      SNAPSHOT_OPTION_KEYS = %i[
+        count
+        detune
+        frequency
+        harmonicity
+        modulation_depth
+        modulation_frequency
+        modulation_index
+        phase
+        spread
+        type
+        width
+      ].freeze
+
+      TYPE_MAP = {
+        sine: Oscillator,
+        square: Oscillator,
+        triangle: Oscillator,
+        sawtooth: Oscillator,
+        pulse: PulseOscillator,
+        pwm: PWMOscillator,
+        fm: FMOscillator,
+        am: AMOscillator,
+        fat: FatOscillator
+      }.freeze
+
+      attr_reader :source
+      attr_accessor :type
+
+      def initialize(type: :sine, context: Deftones.context, **options)
+        super(context: context)
+        @type = type.to_sym
+        @options = options
+        rebuild_source
+      end
+
+      def type=(value)
+        @type = value.to_sym
+        rebuild_source
+      end
+
+      def frequency
+        @source.frequency if @source.respond_to?(:frequency)
+      end
+
+      def start(time = nil)
+        @source.start(time)
+        self
+      end
+
+      def stop(time = nil)
+        @source.stop(time)
+        self
+      end
+
+      def restart(time = nil)
+        @source.restart(time)
+        self
+      end
+
+      def cancel_stop
+        @source.cancel_stop
+        self
+      end
+
+      def sync
+        @source.sync
+        self
+      end
+
+      def unsync
+        @source.unsync
+        self
+      end
+
+      def synced?
+        @source.synced?
+      end
+
+      def state(time = context.current_time)
+        @source.state(time)
+      end
+
+      def onstop
+        @source.onstop
+      end
+
+      def onstop=(callback)
+        @source.onstop = callback
+      end
+
+      def process(_input_buffer, num_frames, start_frame, cache)
+        @source.render(num_frames, start_frame, cache)
+      end
+
+      alias cancelStop cancel_stop
+
+      def method_missing(method_name, *arguments, &block)
+        return super unless @source.respond_to?(method_name)
+
+        @source.public_send(method_name, *arguments, &block)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @source.respond_to?(method_name, include_private) || super
+      end
+
+      private
+
+      def rebuild_source
+        source_class = TYPE_MAP.fetch(@type) { Oscillator }
+        snapshot = snapshot_source(@source)
+        source_options = build_source_options(source_class, snapshot.fetch(:options, {}))
+        @source = source_class.new(**source_options)
+        apply_snapshot(@source, snapshot)
+      end
+
+      def build_source_options(source_class, snapshot_options)
+        allowed_keys = source_class.instance_method(:initialize).parameters.filter_map do |kind, name|
+          name if %i[key keyreq].include?(kind)
+        end
+
+        @options
+          .merge(snapshot_options)
+          .merge(context: context)
+          .then do |options|
+            options[:type] = @type if source_class == Oscillator
+            options.select { |key, _value| allowed_keys.include?(key) }
+          end
+      end
+
+      def snapshot_source(source)
+        return { options: {} } unless source
+
+        {
+          options: snapshot_source_options(source),
+          mute: source.respond_to?(:mute?) ? source.mute? : false,
+          onstop: source.respond_to?(:onstop) ? source.onstop : nil,
+          start_time: source.instance_variable_get(:@start_time),
+          stop_notified: source.instance_variable_get(:@stop_notified),
+          stop_time: source.instance_variable_get(:@stop_time),
+          synced: source.respond_to?(:synced?) ? source.synced? : false,
+          volume: source.respond_to?(:volume) ? source.volume.value : 0.0
+        }
+      end
+
+      def snapshot_source_options(source)
+        SNAPSHOT_OPTION_KEYS.each_with_object({}) do |key, options|
+          next unless source.respond_to?(key)
+
+          value = source.public_send(key)
+          options[key] = value.respond_to?(:value) ? value.value : value
+        end
+      end
+
+      def apply_snapshot(source, snapshot)
+        return source if snapshot.empty?
+
+        source.volume.value = snapshot[:volume] if source.respond_to?(:volume) && snapshot.key?(:volume)
+        source.mute = snapshot[:mute] if source.respond_to?(:mute=) && snapshot.key?(:mute)
+        source.onstop = snapshot[:onstop] if source.respond_to?(:onstop=) && snapshot.key?(:onstop)
+        source.instance_variable_set(:@start_time, snapshot[:start_time]) if snapshot.key?(:start_time)
+        source.instance_variable_set(:@stop_time, snapshot[:stop_time]) if snapshot.key?(:stop_time)
+        source.instance_variable_set(:@stop_notified, snapshot[:stop_notified]) if snapshot.key?(:stop_notified)
+        source.sync if snapshot[:synced] && source.respond_to?(:sync)
+        source
+      end
+    end
+  end
+end

data/lib/deftones/source/oscillator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class Oscillator < Core::Source
+      GENERATORS = {
+        sine: lambda { |phase|
+          Math.sin(2.0 * Math::PI * phase)
+        },
+        square: lambda { |phase|
+          phase < 0.5 ? 1.0 : -1.0
+        },
+        sawtooth: lambda { |phase|
+          (2.0 * phase) - 1.0
+        },
+        triangle: lambda { |phase|
+          (4.0 * (phase < 0.5 ? phase : 1.0 - phase)) - 1.0
+        }
+      }.freeze
+
+      attr_reader :frequency, :detune
+      attr_accessor :type
+
+      def initialize(type: :sine, frequency: 440.0, detune: 0.0, phase: 0.0, context: Deftones.context)
+        super(context: context)
+        @type = normalize_type(type)
+        @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
+        @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        self.phase = phase
+      end
+
+      def detune=(value)
+        @detune.value = value
+      end
+
+      def phase
+        @phase
+      end
+
+      def phase=(value)
+        @phase = value.to_f % 1.0
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        generator = GENERATORS.fetch(normalize_type(@type))
+        frequencies = @frequency.process(num_frames, start_frame)
+        detunes = @detune.process(num_frames, start_frame)
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          next 0.0 unless active_at?(current_time)
+
+          sample = generator.call(@phase)
+          frequency = frequencies[index] * detune_ratio(detunes[index])
+          @phase = (@phase + (frequency / context.sample_rate)) % 1.0
+          sample
+        end
+      end
+
+      private
+
+      def detune_ratio(cents)
+        2.0**(cents.to_f / 1200.0)
+      end
+
+      def normalize_type(type)
+        normalized = type.to_sym
+        return normalized if GENERATORS.key?(normalized)
+
+        raise ArgumentError, "Unsupported oscillator type: #{type}"
+      end
+    end
+  end
+end