deftones 0.1.0 → 1.0.0

data/lib/deftones/event/transport.rb

@@ -12,7 +12,7 @@ module Deftones
         end
       end
 
-      def initialize(bpm: 120.0, time_signature: [4, 4], ppq: 192)
+      def initialize(bpm: 120.0, time_signature: [4, 4], ppq: 192, clock: nil)
         @bpm = Core::Signal.new(
           value: bpm,
           units: :number,
@@ -27,9 +27,13 @@ module Deftones
         @swing = 0.0
         @swing_subdivision = "8n"
         @timeline = {}
+        @state_timeline = []
+        @clock = clock
         @next_id = 0
+        @next_state_id = 0
         @started_at = 0.0
         @position_seconds = 0.0
+        @last_state_update_time = 0.0
       end
 
       def bpm
@@ -40,6 +44,15 @@ module Deftones
         @bpm.value = value
       end
 
+      def bpm_signal
+        @bpm
+      end
+
+      def set_bpm_at_time(value, time)
+        @bpm.set_value_at_time(value, resolve_time(time))
+        self
+      end
+
       def swing_subdivision
         @swing_subdivision
       end
@@ -53,23 +66,48 @@ module Deftones
       end
 
       def start(time = nil)
-        @state = :started
-        @started_at = resolve_time(time)
+        resolved_time = resolve_time(time)
+        if future_time?(resolved_time)
+          add_state_event(:started, resolved_time)
+        else
+          apply_start(resolved_time)
+        end
         self
       end
 
       def stop(time = nil)
-        @state = :stopped
-        @position_seconds = time.nil? ? seconds : resolve_time(time)
+        resolved_time = time.nil? ? clock_time : resolve_time(time)
+        if future_time?(resolved_time)
+          add_state_event(:stopped, resolved_time)
+        else
+          apply_stop(resolved_time)
+        end
         self
       end
 
       def pause(time = nil)
-        @state = :paused
-        @position_seconds = time.nil? ? seconds : resolve_time(time)
+        resolved_time = time.nil? ? clock_time : resolve_time(time)
+        if future_time?(resolved_time)
+          add_state_event(:paused, resolved_time)
+        else
+          apply_pause(resolved_time)
+        end
         self
       end
 
+      def state_at(time)
+        resolved_time = resolve_time(time)
+        effective_state = state_before_timeline
+
+        @state_timeline.sort_by { |event| [event[:time], event[:id]] }.each do |event|
+          break if event[:time] > resolved_time
+
+          effective_state = event[:state]
+        end
+
+        effective_state
+      end
+
       def position
         seconds_to_position(@position_seconds)
       end
@@ -92,12 +130,19 @@ module Deftones
       end
 
       def seconds
+        apply_due_state_events(clock_time)
         return @position_seconds unless @state == :started
 
-        [Deftones.now - @started_at, 0.0].max
+        [clock_time - @started_at, 0.0].max
+      end
+
+      def bpm_at(time)
+        @bpm.get_value_at_time(resolve_time(time))
       end
 
       def schedule(time, &block)
+        raise ArgumentError, "Transport callback is required" unless block
+
         add_event(kind: :once, time: resolve_time(time), callback: block)
       end
 
@@ -106,9 +151,14 @@ module Deftones
       end
 
       def schedule_repeat(interval, start_time: 0, duration: nil, &block)
+        raise ArgumentError, "Transport callback is required" unless block
+
+        resolved_interval = resolve_time(interval)
+        raise ArgumentError, "repeat interval must be positive" unless resolved_interval.positive?
+
         add_event(
           kind: :repeat,
-          interval: resolve_time(interval),
+          interval: resolved_interval,
           start_time: resolve_time(start_time),
           duration: duration.nil? ? nil : resolve_time(duration),
           callback: block
@@ -189,7 +239,23 @@ module Deftones
 
       def prepare_render(duration)
         render_duration = resolve_time(duration)
-        due_events(render_duration).each do |event|
+        cursor = 0.0
+
+        while cursor < render_duration
+          window_end = [cursor + 1.0, render_duration].min
+          prepare_render_window(cursor, window_end)
+          cursor = window_end
+        end
+        self
+      end
+
+      def prepare_render_window(start_time, end_time)
+        window_start = resolve_time(start_time)
+        window_end = resolve_time(end_time)
+        return self if window_end < window_start
+
+        apply_due_state_events(window_end)
+        due_events(window_start, window_end).each do |event|
           event[:callback].call(event[:time])
         end
         self
@@ -204,29 +270,67 @@ module Deftones
         event_id
       end
 
-      def due_events(duration)
+      def add_state_event(state, time)
+        event_id = @next_state_id
+        @state_timeline << { id: event_id, state: state, time: time }
+        @next_state_id += 1
+        event_id
+      end
+
+      def due_events(window_start, window_end)
+        return looped_due_events(window_start, window_end) if loop_active?
+
         events = @timeline.flat_map do |_id, event|
-          event[:kind] == :repeat ? materialize_repeat_event(event, duration) : materialize_one_shot(event, duration)
+          event[:kind] == :repeat ? materialize_repeat_event(event, window_start, window_end) : materialize_one_shot(event, window_start, window_end)
         end
         events.sort_by { |event| event[:time] }
       end
 
-      def materialize_one_shot(event, duration)
-        return [] if event[:time] > duration
+      def looped_due_events(window_start, window_end)
+        loop_start_seconds = resolve_time(@loop_start)
+        loop_end_seconds = resolve_time(@loop_end)
+        span = loop_end_seconds - loop_start_seconds
+        return [] unless span.positive?
+
+        first_iteration = [(window_start - loop_end_seconds) / span, 0.0].max.floor
+        last_iteration = [(window_end - loop_start_seconds) / span, 0.0].max.ceil
+        (first_iteration..last_iteration).flat_map do |iteration|
+          offset = iteration * span
+          due_events_without_loop(loop_start_seconds, loop_end_seconds).filter_map do |event|
+            global_time = event[:time] + offset
+            next unless time_in_window?(global_time, window_start, window_end)
+
+            event.merge(time: global_time)
+          end
+        end.sort_by { |event| event[:time] }
+      end
+
+      def due_events_without_loop(window_start, window_end)
+        @timeline.flat_map do |_id, event|
+          if event[:kind] == :repeat
+            materialize_repeat_event(event, window_start, window_end)
+          else
+            materialize_one_shot(event, window_start, window_end)
+          end
+        end
+      end
+
+      def materialize_one_shot(event, window_start, window_end)
+        return [] unless time_in_window?(event[:time], window_start, window_end)
 
         [{ time: apply_swing(event[:time], event[:time]), callback: event[:callback] }]
       end
 
-      def materialize_repeat_event(event, duration)
+      def materialize_repeat_event(event, window_start, window_end)
         interval = [event[:interval], 1.0e-6].max
-        limit = event[:duration] ? [event[:start_time] + event[:duration], duration].min : duration
+        limit = event[:duration] ? [event[:start_time] + event[:duration], window_end].min : window_end
         events = []
-        occurrence = 0
-        current_time = event[:start_time]
+        occurrence = first_repeat_occurrence(event[:start_time], interval, window_start)
+        current_time = event[:start_time] + (occurrence * interval)
 
         while current_time <= limit
           actual_time = apply_swing(current_time, interval, occurrence)
-          events << { time: actual_time, callback: event[:callback] }
+          events << { time: actual_time, callback: event[:callback] } if time_in_window?(actual_time, window_start, window_end)
           current_time += interval
           occurrence += 1
         end
@@ -234,6 +338,69 @@ module Deftones
         events
       end
 
+      def first_repeat_occurrence(start_time, interval, window_start)
+        return 0 if window_start <= start_time
+
+        ((window_start - start_time) / interval).floor + 1
+      end
+
+      def loop_active?
+        @loop && (resolve_time(@loop_end) - resolve_time(@loop_start)).positive?
+      end
+
+      def future_time?(time)
+        return false unless @clock
+
+        time > clock_time
+      end
+
+      def apply_due_state_events(up_to_time)
+        due, pending = @state_timeline.partition { |event| event[:time] <= up_to_time }
+        @state_timeline = pending
+        due.sort_by { |event| [event[:time], event[:id]] }.each do |event|
+          case event[:state]
+          when :started then apply_start(event[:time])
+          when :stopped then apply_stop(event[:time])
+          when :paused then apply_pause(event[:time])
+          end
+        end
+      end
+
+      def apply_start(time)
+        @state = :started
+        @started_at = time - @position_seconds
+        @last_state_update_time = time
+      end
+
+      def apply_stop(time)
+        @position_seconds = state_position_at(time)
+        @state = :stopped
+        @last_state_update_time = time
+      end
+
+      def apply_pause(time)
+        @position_seconds = state_position_at(time)
+        @state = :paused
+        @last_state_update_time = time
+      end
+
+      def state_position_at(time)
+        return @position_seconds unless @state == :started
+
+        [time - @started_at, 0.0].max
+      end
+
+      def state_before_timeline
+        @state
+      end
+
+      def time_in_window?(time, window_start, window_end)
+        return false if time > window_end
+        return time >= window_start if window_start.zero?
+
+        time > window_start
+      end
+
       def apply_swing(time, interval, occurrence = 0)
         return time if @swing.zero?
         return time if resolve_time(@swing_subdivision) != interval
@@ -248,6 +415,12 @@ module Deftones
         Deftones::Music::Time.parse(value, bpm: bpm, time_signature: time_signature, ppq: @ppq)
       end
 
+      def clock_time
+        return @clock.current_time if @clock&.respond_to?(:current_time)
+
+        Deftones.now
+      end
+
       def seconds_to_position(seconds)
         beats_per_measure = Array(@time_signature).first || 4
         beat_duration = 60.0 / bpm
@@ -259,18 +432,67 @@ module Deftones
       end
 
       def seconds_to_ticks(seconds)
-        ((seconds.to_f / (60.0 / bpm)) * @ppq).round
+        (beats_between(0.0, seconds.to_f) * @ppq).round
       end
 
       def ticks_to_seconds(ticks)
-        (ticks.to_f / @ppq) * (60.0 / bpm)
+        target_beats = ticks.to_f / @ppq
+        return target_beats * (60.0 / bpm) unless tempo_automated?
+
+        upper = [target_beats * (60.0 / [bpm, 1.0].max), 1.0e-6].max
+        upper *= 2.0 while beats_between(0.0, upper) < target_beats
+        lower = 0.0
+        40.times do
+          midpoint = (lower + upper) * 0.5
+          if beats_between(0.0, midpoint) < target_beats
+            lower = midpoint
+          else
+            upper = midpoint
+          end
+        end
+        upper
+      end
+
+      def beats_between(start_time, end_time)
+        from = start_time.to_f
+        to = end_time.to_f
+        return 0.0 if to <= from
+
+        integration_points(from, to).each_cons(2).sum do |left, right|
+          midpoint = (left + right) * 0.5
+          ((right - left) * bpm_at(midpoint)) / 60.0
+        end
+      end
+
+      def tempo_automated?
+        bpm_events.any?
+      end
+
+      def integration_points(start_time, end_time)
+        points = [start_time, end_time]
+        bpm_events.each do |event|
+          points << event[:time] if event[:time] && event[:time].between?(start_time, end_time)
+          points << event[:start_time] if event[:start_time] && event[:start_time].between?(start_time, end_time)
+          points << event[:end_time] if event[:end_time] && event[:end_time].between?(start_time, end_time)
+        end
+        points.uniq.sort
+      end
+
+      def bpm_events
+        @bpm.instance_variable_get(:@events) || []
       end
 
       public :seconds_to_position, :seconds_to_ticks, :ticks_to_seconds
+      public :beats_between
       alias scheduleOnce schedule_once
       alias scheduleRepeat schedule_repeat
+      alias prepareRenderWindow prepare_render_window
       alias setLoopPoints set_loop_points
       alias nextSubdivision next_subdivision
+      alias bpmAt bpm_at
+      alias bpmSignal bpm_signal
+      alias setBpmAtTime set_bpm_at_time
+      alias stateAt state_at
     end
   end
 end

data/lib/deftones/instrument/poly_synth.rb

@@ -3,13 +3,19 @@
 module Deftones
   module Instrument
     class PolySynth < Core::Instrument
-      attr_reader :voice_pool
+      VOICE_STEALING_POLICIES = %i[oldest newest quietest released_first].freeze
+      RETRIGGER_POLICIES = %i[restart ignore].freeze
 
-      def initialize(voice_class = Synth, voices: 8, context: Deftones.context, **voice_options)
+      attr_reader :voice_pool, :voice_stealing, :retrigger
+
+      def initialize(voice_class = Synth, voices: 8, voice_stealing: :oldest, retrigger: :restart,
+                     context: Deftones.context, **voice_options)
         super(context: context)
         @voice_class = voice_class
         @voice_pool = Array.new(voices) { @voice_class.new(context: context, **voice_options) }
         @voice_pool.each { |voice| voice >> @output }
+        @voice_stealing = normalize_voice_stealing(voice_stealing)
+        @retrigger = normalize_retrigger(retrigger)
         @active_voices = {}
       end
 
@@ -29,20 +35,35 @@ module Deftones
       end
 
       def trigger_attack(note, time = nil, velocity = 1.0)
-        voice = allocate_voice(note)
+        scheduled_time = resolve_time(time)
+        return self if @active_voices.key?(note) && @retrigger == :ignore
+
+        voice = allocate_voice(note, scheduled_time)
         @active_voices.delete(note)
-        @active_voices[note] = voice
-        voice.trigger_attack(note, resolve_time(time), velocity)
+        @active_voices[note] = {
+          voice: voice,
+          attacked_at: scheduled_time,
+          released_at: nil,
+          velocity: velocity.to_f
+        }
+        voice.trigger_attack(note, scheduled_time, velocity)
         self
       end
 
       def trigger_release(note, time = nil)
-        voice = @active_voices.delete(note)
-        voice&.trigger_release(resolve_time(time))
+        entry = @active_voices[note]
+        return self unless entry
+
+        scheduled_time = resolve_time(time)
+        entry[:released_at] = scheduled_time
+        entry[:voice].trigger_release(scheduled_time)
         self
       end
 
-      def set(**params)
+      def set(strict: false, **params)
+        unknown = params.keys.reject { |key| @voice_pool.all? { |voice| voice.respond_to?(:"#{key}=") } }
+        raise ArgumentError, "Unknown parameter(s): #{unknown.join(', ')}" if strict && unknown.any?
+
         @voice_pool.each do |voice|
           params.each do |key, value|
             writer = :"#{key}="
@@ -54,7 +75,7 @@ module Deftones
 
       def release_all(time = nil)
         scheduled_time = resolve_time(time)
-        @active_voices.each_value { |voice| voice.trigger_release(scheduled_time) }
+        @active_voices.each_value { |entry| entry[:voice].trigger_release(scheduled_time) }
         @active_voices.clear
         self
       end
@@ -64,7 +85,7 @@ module Deftones
       end
 
       def loaded?
-        true
+        !disposed?
       end
 
       alias loaded loaded?
@@ -74,16 +95,61 @@ module Deftones
         @voice_pool.any?(&:active?)
       end
 
+      def active_notes
+        @active_voices.keys
+      end
+
+      def active_voice_count
+        @active_voices.length
+      end
+
       private
 
-      def allocate_voice(note)
-        return @active_voices[note] if @active_voices.key?(note)
+      def allocate_voice(note, time)
+        cleanup_inactive_voices!
+        return @active_voices[note][:voice] if @active_voices.key?(note)
 
-        available_voice = @voice_pool.find { |voice| !@active_voices.value?(voice) }
+        active_voice_ids = @active_voices.values.map { |entry| entry[:voice].object_id }
+        available_voice = @voice_pool.find { |voice| !active_voice_ids.include?(voice.object_id) }
         return available_voice if available_voice
 
-        _, stolen_voice = @active_voices.shift
-        stolen_voice
+        stolen_note, stolen_entry = steal_voice_entry(time)
+        @active_voices.delete(stolen_note)
+        stolen_entry[:voice]
+      end
+
+      def steal_voice_entry(time)
+        case @voice_stealing
+        when :newest
+          @active_voices.max_by { |_, entry| entry[:attacked_at] }
+        when :quietest
+          @active_voices.min_by { |_, entry| entry[:velocity] }
+        when :released_first
+          released = @active_voices.select { |_, entry| entry[:released_at] && entry[:released_at] <= time }
+          return released.min_by { |_, entry| entry[:released_at] } if released.any?
+
+          @active_voices.min_by { |_, entry| entry[:attacked_at] }
+        else
+          @active_voices.min_by { |_, entry| entry[:attacked_at] }
+        end
+      end
+
+      def cleanup_inactive_voices!
+        @active_voices.delete_if { |_, entry| entry[:released_at] && !entry[:voice].active? }
+      end
+
+      def normalize_voice_stealing(policy)
+        normalized = policy.to_sym
+        return normalized if VOICE_STEALING_POLICIES.include?(normalized)
+
+        raise ArgumentError, "Unsupported voice stealing policy: #{policy}"
+      end
+
+      def normalize_retrigger(policy)
+        normalized = policy.to_sym
+        return normalized if RETRIGGER_POLICIES.include?(normalized)
+
+        raise ArgumentError, "Unsupported retrigger policy: #{policy}"
       end
 
       def resolve_time(time)

data/lib/deftones/instrument/sampler.rb

@@ -3,13 +3,19 @@
 module Deftones
   module Instrument
     class Sampler < Core::Instrument
-      attr_reader :samples, :voices
+      attr_reader :choke_group, :release, :samples, :voices
+      attr_reader :one_shot
 
-      def initialize(samples:, max_voices: 8, context: Deftones.context)
+      def initialize(samples:, max_voices: 8, release: 0.0, one_shot: false, choke_group: nil,
+                     context: Deftones.context)
         super(context: context)
         @samples = samples.transform_keys(&:to_s)
         @max_voices = max_voices
+        @release = release.to_f
+        @one_shot = !!one_shot
+        @choke_group = choke_group
         @voices = []
+        rebuild_root_note_cache
       end
 
       def play(notes, duration: "8n", at: nil, velocity: 1.0)
@@ -22,17 +28,21 @@ module Deftones
 
       def trigger_attack(note, time = nil, velocity = 1.0)
         buffer_note, buffer = closest_sample(note)
+        scheduled_time = resolve_time(time)
+        choke_matching_voices(scheduled_time)
         playback_rate = Deftones::Music::Note.to_frequency(note) / Deftones::Music::Note.to_frequency(buffer_note)
-        player = Source::Player.new(buffer: buffer, playback_rate: playback_rate, context: context)
+        player = Source::Player.new(buffer: buffer, playback_rate: playback_rate, fade_out: @release, context: context)
         gain = Core::Gain.new(gain: velocity, context: context)
         player >> gain >> @output
-        player.start(resolve_time(time))
-        @voices << { note: note, player: player }
-        @voices.shift if @voices.length > @max_voices
+        player.start(scheduled_time)
+        @voices << { note: note, player: player, choke_group: @choke_group }
+        steal_oldest_voice(scheduled_time) if @voices.length > @max_voices
         self
       end
 
       def trigger_release(note, time = nil)
+        return self if @one_shot
+
         voice = @voices.find { |entry| entry[:note] == note }
         voice&.fetch(:player)&.stop(resolve_time(time))
         self
@@ -47,6 +57,7 @@ module Deftones
 
       def add(note, buffer)
         @samples[note.to_s] = buffer.is_a?(Deftones::IO::Buffer) ? buffer : Deftones::IO::Buffer.load(buffer)
+        rebuild_root_note_cache
         self
       end
 
@@ -58,18 +69,20 @@ module Deftones
         @samples.key?(note.to_s)
       end
 
-      def release_all(time = nil)
+      def release_all(time = nil, force: false)
         scheduled_time = resolve_time(time)
+        return self if @one_shot && !force
+
         @voices.each { |voice| voice[:player].stop(scheduled_time) }
         self
       end
 
       def loaded?
-        true
+        !disposed?
       end
 
       def dispose
-        release_all(context.current_time)
+        release_all(context.current_time, force: true)
         @voices.clear
         super
       end
@@ -77,13 +90,43 @@ module Deftones
       alias loaded loaded?
       alias triggerAttackRelease trigger_attack_release
       alias releaseAll release_all
+      alias oneShot one_shot
 
       private
 
       def closest_sample(note)
+        raise ArgumentError, "Sampler requires at least one sample" if @samples.empty?
+
         target_midi = Deftones::Music::Note.to_midi(note)
         @samples.min_by do |sample_note, _|
-          (Deftones::Music::Note.to_midi(sample_note) - target_midi).abs
+          (@root_note_cache.fetch(sample_note) - target_midi).abs
+        end
+      end
+
+      def steal_oldest_voice(time)
+        stolen = @voices.shift
+        return unless stolen
+
+        player = stolen[:player]
+        player.stop(time)
+        player.dispose
+      end
+
+      def choke_matching_voices(time)
+        return unless @choke_group
+
+        @voices.delete_if do |voice|
+          next false unless voice[:choke_group] == @choke_group
+
+          voice[:player].stop(time)
+          voice[:player].dispose
+          true
+        end
+      end
+
+      def rebuild_root_note_cache
+        @root_note_cache = @samples.each_key.to_h do |sample_note|
+          [sample_note, Deftones::Music::Note.to_midi(sample_note)]
         end
       end