deftones 0.1.0

data/lib/deftones/effect/stereo_widener.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class StereoWidener < Core::Effect
+      attr_accessor :width
+
+      def initialize(width: 0.5, context: Deftones.context, **options)
+        super(context: context, **options)
+        @width = width.to_f
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, _start_frame, _cache)
+        stereo_input = input_block.fit_channels(2)
+        width = @width.to_f.clamp(0.0, 1.0)
+        left = Array.new(num_frames)
+        right = Array.new(num_frames)
+
+        num_frames.times do |index|
+          left_sample = stereo_input.channel_data[0][index]
+          right_sample = stereo_input.channel_data[1][index]
+          mid = (left_sample + right_sample) * (1.0 - width)
+          side = (left_sample - right_sample) * width
+          left[index] = mid + side
+          right[index] = mid - side
+        end
+
+        Core::AudioBlock.from_channel_data([left, right])
+      end
+    end
+  end
+end

data/lib/deftones/effect/tremolo.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Tremolo < Core::Effect
+      include ModulationControl
+
+      attr_accessor :frequency, :depth, :spread, :type
+
+      def initialize(frequency: 5.0, depth: 0.8, spread: 0.0, type: :sine, context: Deftones.context, **options)
+        super(context: context, wet: 1.0, **options)
+        @frequency = frequency.to_f
+        @depth = depth.to_f
+        @spread = spread.to_f
+        @type = normalize_modulation_type(type)
+        @phase = 0.0
+        initialize_modulation_control
+      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)
+        output = Array.new(output_channels) { Array.new(num_frames, 0.0) }
+
+        num_frames.times do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          base_phase = modulation_phase_for(current_time)
+
+          output_channels.times do |channel_index|
+            phase = base_phase.nil? ? nil : base_phase + channel_phase_offset(channel_index, output_channels)
+            output[channel_index][index] = source.channel_data[channel_index][index] * channel_gain_for_phase(phase)
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def channel_phase_offset(channel_index, channels)
+        return 0.0 if channels <= 1
+
+        (@spread / 360.0) * (channel_index.to_f / [channels - 1, 1].max)
+      end
+
+      def channel_gain_for_phase(phase)
+        modulation = unipolar_modulation_value(phase, default: 1.0)
+        1.0 - (@depth * (1.0 - modulation))
+      end
+    end
+  end
+end

data/lib/deftones/effect/vibrato.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    class Vibrato < Core::Effect
+      include ModulationControl
+
+      attr_accessor :frequency, :depth, :type
+
+      def initialize(frequency: 5.0, depth: 0.002, type: :sine, context: Deftones.context, **options)
+        super(context: context, wet: 1.0, **options)
+        @frequency = frequency.to_f
+        @depth = depth.to_f
+        @type = normalize_modulation_type(type)
+        @phase = 0.0
+        @delay_lines = []
+        initialize_modulation_control
+      end
+
+      private
+
+      def process_effect_block(input_block, num_frames, start_frame, _cache)
+        ensure_delay_lines(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)
+          delay_samples = (0.01 + (@depth * modulation)) * context.sample_rate
+          input_block.channel_data.each_with_index do |channel, channel_index|
+            output[channel_index][index] = @delay_lines[channel_index].tap(delay_samples, input_sample: channel[index])
+          end
+        end
+
+        Core::AudioBlock.from_channel_data(output)
+      end
+
+      def ensure_delay_lines(channels)
+        required = [channels.to_i, 1].max
+        while @delay_lines.length < required
+          @delay_lines << DSP::DelayLine.new((0.05 * context.sample_rate).ceil)
+        end
+      end
+    end
+  end
+end

data/lib/deftones/event/callback_behavior.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Event
+    module CallbackBehavior
+      attr_accessor :humanize, :mute, :playback_rate, :probability
+      attr_reader :state
+
+      def mute?
+        @mute
+      end
+
+      alias playbackRate playback_rate
+
+      def playbackRate=(value)
+        self.playback_rate = value
+      end
+
+      private
+
+      def initialize_callback_behavior(probability: 1.0, humanize: false, mute: false, playback_rate: 1.0)
+        @probability = probability.to_f
+        @humanize = humanize
+        @mute = !!mute
+        @playback_rate = playback_rate.to_f
+        @state = :stopped
+      end
+
+      def mark_started
+        @state = :started
+      end
+
+      def mark_stopped
+        @state = :stopped
+      end
+
+      def callback_interval(value)
+        base = Deftones::Music::Time.parse(value)
+        rate = @playback_rate.zero? ? 1.0 : @playback_rate.abs
+        base / rate
+      end
+
+      def callback_time(value)
+        Deftones::Music::Time.parse(value)
+      end
+
+      def callback_permitted?
+        return false if @mute
+
+        rand <= @probability
+      end
+
+      def humanized_time(time)
+        return time unless @humanize
+
+        amount = @humanize == true ? 0.01 : Deftones::Music::Time.parse(@humanize)
+        time + (((rand * 2.0) - 1.0) * amount)
+      end
+    end
+  end
+end

data/lib/deftones/event/loop.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Event
+    class Loop
+      include CallbackBehavior
+
+      attr_reader :interval, :iterations
+
+      def initialize(interval:, iterations: nil, transport: Deftones.transport,
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0, &callback)
+        @interval = interval
+        @iterations = iterations
+        @transport = transport
+        @callback = callback
+        @event_id = nil
+        initialize_callback_behavior(
+          probability: probability,
+          humanize: humanize,
+          mute: mute,
+          playback_rate: playback_rate
+        )
+      end
+
+      def start(time = 0)
+        count = 0
+        scaled_interval = callback_interval(@interval)
+        duration = @iterations ? (scaled_interval * (@iterations - 1)) : nil
+        @event_id = @transport.schedule_repeat(scaled_interval, start_time: time, duration: duration) do |scheduled_time|
+          @callback.call(humanized_time(scheduled_time)) if callback_permitted?
+          count += 1
+        end
+        mark_started
+        self
+      end
+
+      def stop(_time = nil)
+        cancel
+      end
+
+      def cancel
+        @transport.cancel(event_id: @event_id) if @event_id
+        @event_id = nil
+        mark_stopped
+        self
+      end
+
+      def dispose
+        cancel
+      end
+    end
+  end
+end

data/lib/deftones/event/part.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Event
+    class Part
+      include CallbackBehavior
+
+      def initialize(events:, transport: Deftones.transport,
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0, &callback)
+        @events = events
+        @transport = transport
+        @callback = callback
+        @event_ids = []
+        initialize_callback_behavior(
+          probability: probability,
+          humanize: humanize,
+          mute: mute,
+          playback_rate: playback_rate
+        )
+      end
+
+      def start(time = 0)
+        offset = callback_time(time)
+        @event_ids = @events.map do |event|
+          event_time = offset + callback_interval(event.fetch(:time, 0))
+          @transport.schedule(event_time) do |scheduled_time|
+            @callback.call(humanized_time(scheduled_time), event) if callback_permitted?
+          end
+        end
+        mark_started
+        self
+      end
+
+      def stop(_time = nil)
+        cancel
+      end
+
+      def cancel
+        @event_ids.each { |event_id| @transport.cancel(event_id: event_id) }
+        @event_ids.clear
+        mark_stopped
+        self
+      end
+
+      def dispose
+        cancel
+        self
+      end
+    end
+  end
+end

data/lib/deftones/event/pattern.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Event
+    class Pattern
+      include CallbackBehavior
+
+      PATTERNS = %i[up down up_down random].freeze
+
+      def initialize(values:, pattern: :up, interval: "4n", transport: Deftones.transport,
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0, &callback)
+        @values = values
+        @pattern = normalize_pattern(pattern)
+        @interval = interval
+        @transport = transport
+        @callback = callback
+        @event_id = nil
+        @index = 0
+        @direction = 1
+        initialize_callback_behavior(
+          probability: probability,
+          humanize: humanize,
+          mute: mute,
+          playback_rate: playback_rate
+        )
+      end
+
+      def start(time = 0)
+        @event_id = @transport.schedule_repeat(callback_interval(@interval), start_time: time) do |scheduled_time|
+          @callback.call(humanized_time(scheduled_time), next_value) if callback_permitted?
+        end
+        mark_started
+        self
+      end
+
+      def stop(_time = nil)
+        cancel
+      end
+
+      def cancel
+        @transport.cancel(event_id: @event_id) if @event_id
+        @event_id = nil
+        mark_stopped
+        self
+      end
+
+      def dispose
+        cancel
+      end
+
+      private
+
+      def next_value
+        case @pattern
+        when :up
+          ordered_value
+        when :down
+          descending_value
+        when :up_down
+          bounce_value
+        when :random
+          @values.sample
+        end
+      end
+
+      def ordered_value
+        value = @values[@index % @values.length]
+        @index += 1
+        value
+      end
+
+      def descending_value
+        value = @values.reverse[@index % @values.length]
+        @index += 1
+        value
+      end
+
+      def bounce_value
+        value = @values[@index]
+        @direction = -1 if @index >= @values.length - 1
+        @direction = 1 if @index <= 0
+        @index += @direction
+        value
+      end
+
+      def normalize_pattern(pattern)
+        normalized = pattern.to_sym
+        return normalized if PATTERNS.include?(normalized)
+
+        raise ArgumentError, "Unsupported pattern: #{pattern}"
+      end
+    end
+  end
+end

data/lib/deftones/event/sequence.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Event
+    class Sequence
+      include Enumerable
+      include CallbackBehavior
+
+      def initialize(notes:, subdivision: "4n", loop: true, transport: Deftones.transport,
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0, &callback)
+        @notes = notes
+        @subdivision = subdivision
+        @loop = loop
+        @transport = transport
+        @callback = callback
+        @event_id = nil
+        @current_step = 0
+        initialize_callback_behavior(
+          probability: probability,
+          humanize: humanize,
+          mute: mute,
+          playback_rate: playback_rate
+        )
+      end
+
+      def start(time = 0)
+        @current_step = 0
+        scaled_subdivision = callback_interval(@subdivision)
+        duration = @loop ? nil : (scaled_subdivision * (@notes.length - 1))
+        @event_id = @transport.schedule_repeat(scaled_subdivision, start_time: time, duration: duration) do |scheduled_time|
+          process_step(scheduled_time)
+          @current_step += 1
+        end
+        mark_started
+        self
+      end
+
+      def stop(_time = nil)
+        cancel
+      end
+
+      def cancel
+        @transport.cancel(event_id: @event_id) if @event_id
+        @event_id = nil
+        mark_stopped
+        self
+      end
+
+      def dispose
+        cancel
+      end
+
+      def [](index)
+        @notes[index]
+      end
+
+      def []=(index, value)
+        @notes[index] = value
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+
+        @notes.each(&block)
+      end
+
+      private
+
+      def process_step(scheduled_time)
+        note = @notes[@current_step % @notes.length]
+        return if note.nil?
+        return unless callback_permitted?
+
+        if note.is_a?(Array)
+          sub_duration = callback_interval(@subdivision) / note.length.to_f
+          note.each_with_index do |nested_note, index|
+            next if nested_note.nil?
+
+            @callback.call(humanized_time(scheduled_time + (sub_duration * index)), nested_note)
+          end
+        else
+          @callback.call(humanized_time(scheduled_time), note)
+        end
+      end
+    end
+  end
+end

data/lib/deftones/event/tone_event.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Event
+    class ToneEvent
+      include CallbackBehavior
+
+      attr_accessor :loop, :loop_start, :loop_end, :probability
+
+      def initialize(transport: Deftones.transport, probability: 1.0, loop: false,
+                     loop_start: 0.0, loop_end: nil, humanize: false, mute: false, playback_rate: 1.0, &callback)
+        @transport = transport
+        @callback = callback
+        @loop = loop
+        @loop_start = loop_start
+        @loop_end = loop_end
+        @event_id = nil
+        initialize_callback_behavior(
+          probability: probability,
+          humanize: humanize,
+          mute: mute,
+          playback_rate: playback_rate
+        )
+      end
+
+      def start(time = 0)
+        start_time = resolve_time(time)
+
+        @event_id =
+          if @loop && @loop_end
+            interval = callback_interval(resolve_time(@loop_end) - resolve_time(@loop_start))
+            @transport.schedule_repeat(interval, start_time: start_time + resolve_time(@loop_start)) do |scheduled_time|
+              @callback.call(humanized_time(scheduled_time)) if callback_permitted?
+            end
+          else
+            @transport.schedule(start_time) do |scheduled_time|
+              @callback.call(humanized_time(scheduled_time)) if callback_permitted?
+            end
+          end
+        mark_started
+        self
+      end
+
+      def stop(_time = nil)
+        cancel
+      end
+
+      def cancel
+        @transport.cancel(event_id: @event_id) if @event_id
+        @event_id = nil
+        mark_stopped
+        self
+      end
+
+      def dispose
+        cancel
+      end
+
+      alias loopStart loop_start
+      alias loopEnd loop_end
+
+      def loopStart=(value)
+        self.loop_start = value
+      end
+
+      def loopEnd=(value)
+        self.loop_end = value
+      end
+
+      private
+
+      def resolve_time(value)
+        Deftones::Music::Time.parse(value)
+      end
+    end
+  end
+end