deftones 0.1.0

data/lib/deftones/event/transport.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Event
+    class Transport
+      attr_accessor :loop, :loop_start, :loop_end, :swing
+      attr_reader :ppq, :state, :time_signature
+
+      TimingContext = Struct.new(:sample_rate) do
+        def current_time
+          0.0
+        end
+      end
+
+      def initialize(bpm: 120.0, time_signature: [4, 4], ppq: 192)
+        @bpm = Core::Signal.new(
+          value: bpm,
+          units: :number,
+          context: TimingContext.new(Deftones::Context::DEFAULT_SAMPLE_RATE)
+        )
+        @ppq = ppq.to_i
+        @state = :stopped
+        self.time_signature = time_signature
+        @loop = false
+        @loop_start = 0.0
+        @loop_end = 0.0
+        @swing = 0.0
+        @swing_subdivision = "8n"
+        @timeline = {}
+        @next_id = 0
+        @started_at = 0.0
+        @position_seconds = 0.0
+      end
+
+      def bpm
+        @bpm.value
+      end
+
+      def bpm=(value)
+        @bpm.value = value
+      end
+
+      def swing_subdivision
+        @swing_subdivision
+      end
+
+      def swing_subdivision=(value)
+        @swing_subdivision = value
+      end
+
+      def ppq=(value)
+        @ppq = [value.to_i, 1].max
+      end
+
+      def start(time = nil)
+        @state = :started
+        @started_at = resolve_time(time)
+        self
+      end
+
+      def stop(time = nil)
+        @state = :stopped
+        @position_seconds = time.nil? ? seconds : resolve_time(time)
+        self
+      end
+
+      def pause(time = nil)
+        @state = :paused
+        @position_seconds = time.nil? ? seconds : resolve_time(time)
+        self
+      end
+
+      def position
+        seconds_to_position(@position_seconds)
+      end
+
+      def position=(value)
+        @position_seconds = resolve_time(value)
+      end
+
+      def seconds=(value)
+        @position_seconds = resolve_time(value)
+      end
+
+      def ticks
+        seconds_to_ticks(@position_seconds)
+      end
+
+      def ticks=(value)
+        parsed_ticks = Deftones::Music::Ticks.parse(value, bpm: bpm, time_signature: time_signature, ppq: @ppq)
+        @position_seconds = ticks_to_seconds(parsed_ticks)
+      end
+
+      def seconds
+        return @position_seconds unless @state == :started
+
+        [Deftones.now - @started_at, 0.0].max
+      end
+
+      def schedule(time, &block)
+        add_event(kind: :once, time: resolve_time(time), callback: block)
+      end
+
+      def schedule_once(time, &block)
+        schedule(time, &block)
+      end
+
+      def schedule_repeat(interval, start_time: 0, duration: nil, &block)
+        add_event(
+          kind: :repeat,
+          interval: resolve_time(interval),
+          start_time: resolve_time(start_time),
+          duration: duration.nil? ? nil : resolve_time(duration),
+          callback: block
+        )
+      end
+
+      def clear(event_id)
+        cancel(event_id: event_id)
+      end
+
+      def cancel(after_time = 0, event_id: nil)
+        return @timeline.delete(event_id) if event_id
+
+        threshold = resolve_time(after_time)
+        @timeline.delete_if do |_id, event|
+          event_time = event[:kind] == :repeat ? event[:start_time] : event[:time]
+          event_time >= threshold
+        end
+        self
+      end
+
+      def set_loop_points(start_time, end_time)
+        @loop_start = resolve_time(start_time)
+        @loop_end = resolve_time(end_time)
+        self
+      end
+
+      def toggle(time = nil)
+        @state == :started ? pause(time) : start(time)
+      end
+
+      def immediate
+        seconds
+      end
+
+      def progress
+        return nil unless @loop
+
+        loop_start_seconds = resolve_time(@loop_start)
+        loop_end_seconds = resolve_time(@loop_end)
+        span = loop_end_seconds - loop_start_seconds
+        return nil unless span.positive?
+
+        ((seconds - loop_start_seconds) % span) / span
+      end
+
+      def next_subdivision(subdivision)
+        interval = resolve_time(subdivision)
+        return nil unless interval.positive?
+
+        current = seconds
+        (((current / interval).floor) + 1) * interval
+      end
+
+      def time_signature=(signature)
+        @time_signature =
+          case signature
+          when Array then signature.map(&:to_i)
+          else [signature.to_i, 4]
+          end
+      end
+
+      def timeSignature
+        time_signature
+      end
+
+      def timeSignature=(signature)
+        self.time_signature = signature
+      end
+
+      def swingSubdivision
+        swing_subdivision
+      end
+
+      def swingSubdivision=(value)
+        self.swing_subdivision = value
+      end
+
+      def prepare_render(duration)
+        render_duration = resolve_time(duration)
+        due_events(render_duration).each do |event|
+          event[:callback].call(event[:time])
+        end
+        self
+      end
+
+      private
+
+      def add_event(payload)
+        event_id = @next_id
+        @timeline[event_id] = payload
+        @next_id += 1
+        event_id
+      end
+
+      def due_events(duration)
+        events = @timeline.flat_map do |_id, event|
+          event[:kind] == :repeat ? materialize_repeat_event(event, duration) : materialize_one_shot(event, duration)
+        end
+        events.sort_by { |event| event[:time] }
+      end
+
+      def materialize_one_shot(event, duration)
+        return [] if event[:time] > duration
+
+        [{ time: apply_swing(event[:time], event[:time]), callback: event[:callback] }]
+      end
+
+      def materialize_repeat_event(event, duration)
+        interval = [event[:interval], 1.0e-6].max
+        limit = event[:duration] ? [event[:start_time] + event[:duration], duration].min : duration
+        events = []
+        occurrence = 0
+        current_time = event[:start_time]
+
+        while current_time <= limit
+          actual_time = apply_swing(current_time, interval, occurrence)
+          events << { time: actual_time, callback: event[:callback] }
+          current_time += interval
+          occurrence += 1
+        end
+
+        events
+      end
+
+      def apply_swing(time, interval, occurrence = 0)
+        return time if @swing.zero?
+        return time if resolve_time(@swing_subdivision) != interval
+        return time if occurrence.even?
+
+        time + (interval * 0.5 * @swing)
+      end
+
+      def resolve_time(value)
+        return @position_seconds if value.nil?
+
+        Deftones::Music::Time.parse(value, bpm: bpm, time_signature: time_signature, ppq: @ppq)
+      end
+
+      def seconds_to_position(seconds)
+        beats_per_measure = Array(@time_signature).first || 4
+        beat_duration = 60.0 / bpm
+        total_beats = seconds.to_f / beat_duration
+        bars = (total_beats / beats_per_measure).floor
+        beats = (total_beats % beats_per_measure).floor
+        sixteenths = (((total_beats - total_beats.floor) / 0.25).round) % 4
+        "#{bars}:#{beats}:#{sixteenths}"
+      end
+
+      def seconds_to_ticks(seconds)
+        ((seconds.to_f / (60.0 / bpm)) * @ppq).round
+      end
+
+      def ticks_to_seconds(ticks)
+        (ticks.to_f / @ppq) * (60.0 / bpm)
+      end
+
+      public :seconds_to_position, :seconds_to_ticks, :ticks_to_seconds
+      alias scheduleOnce schedule_once
+      alias scheduleRepeat schedule_repeat
+      alias setLoopPoints set_loop_points
+      alias nextSubdivision next_subdivision
+    end
+  end
+end

data/lib/deftones/instrument/am_synth.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class AMSynth < Core::Instrument
+      attr_reader :oscillator, :envelope
+
+      def initialize(harmonicity: 2.0, attack: 0.01, decay: 0.08, sustain: 0.4, release: 0.3,
+                     context: Deftones.context, &block)
+        super(context: context)
+        @oscillator = Source::AMOscillator.new(harmonicity: harmonicity, context: context)
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @oscillator.start(0.0)
+        @oscillator >> @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        @oscillator.frequency.set_value_at_time(note, scheduled_time)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        @envelope.trigger_release(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      private
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/duo_synth.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class DuoSynth < Core::Instrument
+      attr_reader :voice_a, :voice_b, :envelope
+
+      def initialize(type: :sawtooth, detune: 7.0, harmonicity: 1.5, attack: 0.01, decay: 0.12,
+                     sustain: 0.45, release: 0.4, context: Deftones.context, &block)
+        super(context: context)
+        @voice_a = Source::OmniOscillator.new(type: type, context: context)
+        @voice_b = Source::OmniOscillator.new(type: type, context: context)
+        @detune = detune.to_f
+        @harmonicity = harmonicity.to_f
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @voice_a.start(0.0)
+        @voice_b.start(0.0)
+        @voice_a >> @envelope
+        @voice_b >> @envelope
+        @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        frequency = Deftones::Music::Note.to_frequency(note)
+        @voice_a.frequency.set_value_at_time(frequency * detune_ratio(-@detune), scheduled_time)
+        @voice_b.frequency.set_value_at_time((frequency * @harmonicity) * detune_ratio(@detune), scheduled_time)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        @envelope.trigger_release(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      private
+
+      def detune_ratio(cents)
+        2.0**(cents.to_f / 1200.0)
+      end
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/fm_synth.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class FMSynth < Core::Instrument
+      attr_reader :oscillator, :envelope
+
+      def initialize(harmonicity: 2.0, modulation_index: 6.0, attack: 0.01, decay: 0.1,
+                     sustain: 0.4, release: 0.4, context: Deftones.context, &block)
+        super(context: context)
+        @oscillator = Source::FMOscillator.new(
+          harmonicity: harmonicity,
+          modulation_index: modulation_index,
+          context: context
+        )
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @oscillator.start(0.0)
+        @oscillator >> @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        @oscillator.frequency.set_value_at_time(note, scheduled_time)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        @envelope.trigger_release(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      private
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/membrane_synth.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class MembraneSynth < Core::Instrument
+      attr_reader :oscillator, :envelope
+
+      def initialize(pitch_decay: 0.05, octaves: 4.0, attack: 0.001, decay: 0.2,
+                     sustain: 0.0, release: 0.15, context: Deftones.context, &block)
+        super(context: context)
+        @pitch_decay = pitch_decay.to_f
+        @octaves = octaves.to_f
+        @oscillator = Source::Oscillator.new(type: :sine, context: context)
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @oscillator.start(0.0)
+        @oscillator >> @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        base_frequency = Deftones::Music::Note.to_frequency(note)
+        @oscillator.frequency.set_value_at_time(base_frequency * (2.0**@octaves), scheduled_time)
+        @oscillator.frequency.exponential_ramp_to(base_frequency, @pitch_decay)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        @envelope.trigger_release(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      private
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/metal_synth.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class MetalSynth < Core::Instrument
+      attr_reader :oscillator, :filter, :envelope
+
+      def initialize(harmonicity: 5.0, modulation_index: 12.0, attack: 0.001, decay: 0.08,
+                     sustain: 0.0, release: 0.06, context: Deftones.context, &block)
+        super(context: context)
+        @oscillator = Source::FMOscillator.new(
+          harmonicity: harmonicity,
+          modulation_index: modulation_index,
+          context: context
+        )
+        @filter = Component::Filter.new(type: :highpass, frequency: 2_500.0, q: 0.9, context: context)
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @oscillator.start(0.0)
+        @oscillator >> @filter >> @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "16n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        @oscillator.frequency.set_value_at_time(note, scheduled_time)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        @envelope.trigger_release(resolve_time(time))
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      private
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end

data/lib/deftones/instrument/mono_synth.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Instrument
+    class MonoSynth < Core::Instrument
+      attr_reader :oscillator, :filter, :envelope, :filter_envelope
+
+      def initialize(type: :sawtooth, filter_type: :lowpass, filter_frequency: 1_200.0, filter_q: 0.8,
+                     filter_octaves: 2.0, attack: 0.01, decay: 0.1, sustain: 0.4, release: 0.5,
+                     context: Deftones.context, &block)
+        super(context: context)
+        @oscillator = Source::OmniOscillator.new(type: type, context: context)
+        @filter = Component::Filter.new(
+          type: filter_type,
+          frequency: filter_frequency,
+          q: filter_q,
+          context: context
+        )
+        @envelope = Component::AmplitudeEnvelope.new(
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @filter_envelope = Component::FrequencyEnvelope.new(
+          base_frequency: filter_frequency,
+          octaves: filter_octaves,
+          attack: attack,
+          decay: decay,
+          sustain: sustain,
+          release: release,
+          context: context
+        )
+        @oscillator.start(0.0)
+        @oscillator >> @filter >> @envelope >> @output
+        block&.call(self)
+      end
+
+      def play(note, duration: "8n", at: nil, velocity: 1.0)
+        trigger_attack_release(note, duration, at, velocity)
+      end
+
+      def trigger_attack(note, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        frequency = Deftones::Music::Note.to_frequency(note)
+        @oscillator.frequency.set_value_at_time(frequency, scheduled_time)
+        shape_filter(scheduled_time, velocity)
+        @envelope.trigger_attack(scheduled_time, velocity)
+        self
+      end
+
+      def trigger_release(time = nil)
+        scheduled_time = resolve_time(time)
+        @filter.frequency.linear_ramp_to(@filter_envelope.base_frequency, @envelope.release)
+        @envelope.trigger_release(scheduled_time)
+        self
+      end
+
+      def trigger_attack_release(note, duration, time = nil, velocity = 1.0)
+        scheduled_time = resolve_time(time)
+        trigger_attack(note, scheduled_time, velocity)
+        trigger_release(scheduled_time + Deftones::Music::Time.parse(duration))
+        self
+      end
+
+      def active?
+        @envelope.active?
+      end
+
+      private
+
+      def shape_filter(time, velocity)
+        peak = @filter_envelope.base_frequency * (2.0**(@filter_envelope.octaves * velocity))
+        sustain_level = @filter_envelope.base_frequency * (1.0 + (@filter_envelope.sustain * velocity))
+        @filter.frequency.set_value_at_time(@filter_envelope.base_frequency, time)
+        @filter.frequency.linear_ramp_to(peak, @filter_envelope.attack)
+        @filter.frequency.linear_ramp_to(sustain_level, @filter_envelope.decay)
+      end
+
+      def resolve_time(time)
+        return context.current_time if time.nil?
+
+        Deftones::Music::Time.parse(time)
+      end
+    end
+  end
+end