deftones 0.1.0 → 1.0.0

data/lib/deftones/effect/oversampling.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Effects
+    module Oversampling
+      OVERSAMPLE_FACTORS = [1, 2, 4].freeze
+
+      attr_reader :oversample
+
+      def oversample=(value)
+        normalized = value.to_i
+        raise ArgumentError, "Unsupported oversample factor: #{value}" unless OVERSAMPLE_FACTORS.include?(normalized)
+
+        @oversample = normalized
+        @oversample_previous = []
+      end
+
+      private
+
+      def process_oversampled(input_buffer, channel_index)
+        ensure_oversample_state(channel_index)
+        return input_buffer.map { |sample| yield sample } if @oversample == 1
+
+        input_buffer.map do |sample|
+          previous = @oversample_previous[channel_index]
+          current = sample.to_f
+          sum = 0.0
+          1.upto(@oversample) do |step|
+            position = step.to_f / @oversample
+            sum += yield Deftones::DSP::Helpers.lerp(previous, current, position)
+          end
+          @oversample_previous[channel_index] = current
+          sum / @oversample
+        end
+      end
+
+      def ensure_oversample_state(channel_index)
+        required = [channel_index.to_i, 0].max
+        @oversample_previous.fill(0.0, @oversample_previous.length..required)
+      end
+    end
+  end
+end

data/lib/deftones/effect/phaser.rb

@@ -5,7 +5,8 @@ module Deftones
     class Phaser < Core::Effect
       include ModulationControl
 
-      attr_accessor :frequency, :octaves, :q, :base_frequency, :stages, :type
+      attr_accessor :frequency, :octaves, :q, :base_frequency, :type
+      attr_reader :stages
 
       def initialize(
         frequency: 0.5,

data/lib/deftones/effect/pitch_shift.rb

@@ -3,8 +3,7 @@
 module Deftones
   module Effects
     class PitchShift < Core::Effect
-      attr_reader :delay_time, :feedback
-      attr_accessor :pitch
+      attr_reader :delay_time, :feedback, :pitch
       attr_reader :window_size
 
       def initialize(

data/lib/deftones/effect/reverb.rb

@@ -4,18 +4,46 @@ module Deftones
   module Effects
     class Reverb < Core::Effect
       attr_accessor :decay, :pre_delay
+      attr_reader :damping, :freeze, :wet_normalization, :width
 
-      def initialize(decay: 0.7, pre_delay: 0.01, context: Deftones.context, **options)
+      def initialize(decay: 0.7, pre_delay: 0.01, damping: 0.0, freeze: false, wet_normalization: false,
+                     width: 1.0, context: Deftones.context, **options)
         super(context: context, **options)
         @decay = decay.to_f
         @pre_delay = pre_delay.to_f
+        self.damping = damping
+        self.freeze = freeze
+        self.wet_normalization = wet_normalization
+        self.width = width
         @comb_times = [0.0297, 0.0371, 0.0411, 0.0437]
         @allpass_times = [0.005, 0.0017]
         @comb_lines = []
+        @comb_damping_state = []
         @allpass_lines = []
         @pre_delay_lines = []
       end
 
+      def damping=(value)
+        @damping = value.to_f.clamp(0.0, 1.0)
+      end
+
+      def freeze=(value)
+        @freeze = !!value
+      end
+
+      def wet_normalization=(value)
+        @wet_normalization = !!value
+      end
+
+      def width=(value)
+        @width = value.to_f.clamp(0.0, 1.0)
+      end
+
+      alias dampening damping
+      alias dampening= damping=
+      alias wetNormalization wet_normalization
+      alias wetNormalization= wet_normalization=
+
       private
 
       def process_effect_block(input_block, num_frames, start_frame, cache)
@@ -23,9 +51,9 @@ module Deftones
         source = input_block.fit_channels(output_channels)
 
         Core::AudioBlock.from_channel_data(
-          source.channel_data.each_with_index.map do |channel, channel_index|
+          apply_stereo_width(source.channel_data.each_with_index.map do |channel, channel_index|
             process_effect(channel, num_frames, start_frame, cache, channel_index: channel_index)
-          end
+          end)
         )
       end
 
@@ -40,23 +68,37 @@ module Deftones
         Array.new(num_frames) do |index|
           dry = input_buffer[index]
           delayed = pre_delay_line.tap(@pre_delay * context.sample_rate, input_sample: dry)
+          feedback = effective_decay
+          comb_input = @freeze ? 0.0 : delayed
           comb_sum = comb_lines.each_with_index.sum do |line, comb_index|
-            line.tap(comb_times[comb_index] * context.sample_rate, input_sample: delayed, feedback: @decay)
+            process_comb(line, comb_times[comb_index] * context.sample_rate, comb_input, feedback, channel_index,
+                         comb_index)
           end / comb_lines.length.to_f
 
-          allpass_lines.each_with_index.reduce(comb_sum) do |sample, (line, allpass_index)|
+          wet_sample = allpass_lines.each_with_index.reduce(comb_sum) do |sample, (line, allpass_index)|
             tap = line.read(allpass_times[allpass_index] * context.sample_rate)
             line.write(sample + (tap * 0.5))
             tap - (sample * 0.5)
           end
+          normalize_wet_sample(wet_sample, feedback)
         end
       end
 
+      def process_comb(line, delay_samples, input_sample, feedback, channel_index, comb_index)
+        delayed_sample = line.read(delay_samples)
+        previous = @comb_damping_state[channel_index][comb_index]
+        filtered = DSP::Helpers.lerp(delayed_sample, previous, @damping)
+        @comb_damping_state[channel_index][comb_index] = filtered
+        line.write(input_sample + (filtered * feedback))
+        filtered
+      end
+
       def ensure_delay_network(channel_index)
         required = [channel_index.to_i, 0].max
         while @pre_delay_lines.length <= required
           @pre_delay_lines << DSP::DelayLine.new((0.1 * context.sample_rate).ceil)
           @comb_lines << @comb_times.map { |seconds| DSP::DelayLine.new((seconds * context.sample_rate).ceil + 2) }
+          @comb_damping_state << Array.new(@comb_times.length, 0.0)
           @allpass_lines << @allpass_times.map { |seconds| DSP::DelayLine.new((seconds * context.sample_rate).ceil + 2) }
         end
       end
@@ -66,6 +108,32 @@ module Deftones
 
         times.map { |time| time + (offset * channel_index) }
       end
+
+      def apply_stereo_width(channel_data)
+        return channel_data if channel_data.length < 2 || @width >= 1.0
+
+        left = channel_data[0]
+        right = channel_data[1]
+        widened_left = []
+        widened_right = []
+        left.each_index do |index|
+          mid = (left[index] + right[index]) * 0.5
+          side = (left[index] - right[index]) * 0.5 * @width
+          widened_left << (mid + side)
+          widened_right << (mid - side)
+        end
+        [widened_left, widened_right] + channel_data.drop(2)
+      end
+
+      def effective_decay
+        @freeze ? 0.995 : @decay.to_f.clamp(0.0, 0.995)
+      end
+
+      def normalize_wet_sample(sample, feedback)
+        return sample unless @wet_normalization
+
+        sample * (1.0 - ([feedback.abs, 0.95].min * 0.35))
+      end
     end
   end
 end

data/lib/deftones/event/callback_behavior.rb

@@ -18,11 +18,13 @@ module Deftones
 
       private
 
-      def initialize_callback_behavior(probability: 1.0, humanize: false, mute: false, playback_rate: 1.0)
+      def initialize_callback_behavior(probability: 1.0, humanize: false, mute: false, playback_rate: 1.0,
+                                       seed: nil, rng: nil)
         @probability = probability.to_f
         @humanize = humanize
         @mute = !!mute
         @playback_rate = playback_rate.to_f
+        @rng = rng || (seed.nil? ? Random : Random.new(seed))
         @state = :stopped
       end
 
@@ -46,15 +48,17 @@ module Deftones
 
       def callback_permitted?
         return false if @mute
+        return true if @probability >= 1.0
+        return false if @probability <= 0.0
 
-        rand <= @probability
+        @rng.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)
+        time + (((@rng.rand * 2.0) - 1.0) * amount)
       end
     end
   end

data/lib/deftones/event/loop.rb

@@ -8,7 +8,10 @@ module Deftones
       attr_reader :interval, :iterations
 
       def initialize(interval:, iterations: nil, transport: Deftones.transport,
-                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0, &callback)
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0,
+                     seed: nil, rng: nil, &callback)
+        raise ArgumentError, "callback is required" unless callback
+
         @interval = interval
         @iterations = iterations
         @transport = transport
@@ -18,7 +21,9 @@ module Deftones
           probability: probability,
           humanize: humanize,
           mute: mute,
-          playback_rate: playback_rate
+          playback_rate: playback_rate,
+          seed: seed,
+          rng: rng
         )
       end
 

data/lib/deftones/event/part.rb

@@ -6,8 +6,11 @@ module Deftones
       include CallbackBehavior
 
       def initialize(events:, transport: Deftones.transport,
-                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0, &callback)
-        @events = events
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0,
+                     seed: nil, rng: nil, &callback)
+        raise ArgumentError, "callback is required" unless callback
+
+        @events = normalize_events(events)
         @transport = transport
         @callback = callback
         @event_ids = []
@@ -15,7 +18,9 @@ module Deftones
           probability: probability,
           humanize: humanize,
           mute: mute,
-          playback_rate: playback_rate
+          playback_rate: playback_rate,
+          seed: seed,
+          rng: rng
         )
       end
 
@@ -46,6 +51,16 @@ module Deftones
         cancel
         self
       end
+
+      private
+
+      def normalize_events(events)
+        Array(events).map do |event|
+          next { time: event[0], value: event[1] } if event.is_a?(Array)
+
+          event
+        end
+      end
     end
   end
 end

data/lib/deftones/event/pattern.rb

@@ -5,11 +5,23 @@ module Deftones
     class Pattern
       include CallbackBehavior
 
-      PATTERNS = %i[up down up_down random].freeze
+      PATTERNS = %i[up down up_down down_up alternate_up alternate_down random random_walk].freeze
+      PATTERN_ALIASES = {
+        upDown: :up_down,
+        downUp: :down_up,
+        alternateUp: :alternate_up,
+        alternateDown: :alternate_down,
+        randomWalk: :random_walk
+      }.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
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0,
+                     seed: nil, rng: nil, &callback)
+        raise ArgumentError, "callback is required" unless callback
+
+        @values = Array(values)
+        raise ArgumentError, "Pattern values must not be empty" if @values.empty?
+
         @pattern = normalize_pattern(pattern)
         @interval = interval
         @transport = transport
@@ -21,7 +33,9 @@ module Deftones
           probability: probability,
           humanize: humanize,
           mute: mute,
-          playback_rate: playback_rate
+          playback_rate: playback_rate,
+          seed: seed,
+          rng: rng
         )
       end
 
@@ -58,8 +72,16 @@ module Deftones
           descending_value
         when :up_down
           bounce_value
+        when :down_up
+          descending_bounce_value
+        when :alternate_up
+          alternate_value(:up)
+        when :alternate_down
+          alternate_value(:down)
         when :random
-          @values.sample
+          @values[@rng.rand(@values.length)]
+        when :random_walk
+          random_walk_value
         end
       end
 
@@ -83,8 +105,31 @@ module Deftones
         value
       end
 
+      def descending_bounce_value
+        value = @values.reverse[@index]
+        @direction = -1 if @index >= @values.length - 1
+        @direction = 1 if @index <= 0
+        @index += @direction
+        value
+      end
+
+      def alternate_value(start_direction)
+        cycle = @index / @values.length
+        offset = @index % @values.length
+        @index += 1
+        descending = start_direction == :down ? cycle.even? : cycle.odd?
+        descending ? @values.reverse[offset] : @values[offset]
+      end
+
+      def random_walk_value
+        value = @values[@index]
+        @direction = [-1, 1][@rng.rand(2)]
+        @index = (@index + @direction).clamp(0, @values.length - 1)
+        value
+      end
+
       def normalize_pattern(pattern)
-        normalized = pattern.to_sym
+        normalized = PATTERN_ALIASES.fetch(pattern.to_sym, pattern.to_sym)
         return normalized if PATTERNS.include?(normalized)
 
         raise ArgumentError, "Unsupported pattern: #{pattern}"

data/lib/deftones/event/sequence.rb

@@ -7,8 +7,13 @@ module Deftones
       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
+                     probability: 1.0, humanize: false, mute: false, playback_rate: 1.0,
+                     seed: nil, rng: nil, &callback)
+        raise ArgumentError, "callback is required" unless callback
+
+        @notes = Array(notes)
+        raise ArgumentError, "Sequence notes must not be empty" if @notes.empty?
+
         @subdivision = subdivision
         @loop = loop
         @transport = transport
@@ -19,7 +24,9 @@ module Deftones
           probability: probability,
           humanize: humanize,
           mute: mute,
-          playback_rate: playback_rate
+          playback_rate: playback_rate,
+          seed: seed,
+          rng: rng
         )
       end
 
@@ -76,12 +83,19 @@ module Deftones
           note.each_with_index do |nested_note, index|
             next if nested_note.nil?
 
-            @callback.call(humanized_time(scheduled_time + (sub_duration * index)), nested_note)
+            process_note(humanized_time(scheduled_time + (sub_duration * index)), nested_note)
           end
         else
-          @callback.call(humanized_time(scheduled_time), note)
+          process_note(humanized_time(scheduled_time), note)
         end
       end
+
+      def process_note(time, note)
+        payload = note.is_a?(Hash) ? note : { note: note }
+        return if payload.fetch(:probability, 1.0).to_f < @rng.rand
+
+        @callback.call(time, payload.fetch(:note, payload[:value]), payload)
+      end
     end
   end
 end

data/lib/deftones/event/tone_event.rb

@@ -8,7 +8,10 @@ module Deftones
       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)
+                     loop_start: 0.0, loop_end: nil, humanize: false, mute: false, playback_rate: 1.0,
+                     seed: nil, rng: nil, &callback)
+        raise ArgumentError, "callback is required" unless callback
+
         @transport = transport
         @callback = callback
         @loop = loop
@@ -19,7 +22,9 @@ module Deftones
           probability: probability,
           humanize: humanize,
           mute: mute,
-          playback_rate: playback_rate
+          playback_rate: playback_rate,
+          seed: seed,
+          rng: rng
         )
       end