deftones 0.1.0

data/lib/deftones/music/ticks.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Music
+    class Ticks
+      attr_reader :value, :transport
+
+      def initialize(value, transport: Deftones.transport)
+        @value = value
+        @transport = transport
+        @disposed = false
+      end
+
+      def to_i
+        self.class.parse(
+          value,
+          bpm: transport.bpm,
+          time_signature: transport.time_signature,
+          ppq: transport.ppq
+        ).round
+      end
+
+      def to_seconds
+        transport.ticks_to_seconds(to_i)
+      end
+
+      def to_ticks
+        to_i
+      end
+
+      def to_bars_beats_sixteenths
+        transport.seconds_to_position(to_seconds)
+      end
+
+      def to_frequency
+        1.0 / [to_seconds, 1.0e-6].max
+      end
+
+      def to_midi
+        Note.to_midi(Note.from_frequency(to_frequency))
+      end
+
+      def to_milliseconds
+        to_seconds * 1000.0
+      end
+
+      def to_samples(sample_rate = Deftones.context.sample_rate)
+        UnitHelpers.samples_for_seconds(to_seconds, sample_rate)
+      end
+
+      def to_notation
+        UnitHelpers.closest_notation(to_seconds, transport: transport)
+      end
+
+      def quantize(subdiv, percent = 1.0)
+        quantized_seconds = UnitHelpers.quantize_seconds(to_seconds, subdiv, transport: transport, percent: percent)
+        transport.seconds_to_ticks(quantized_seconds).round
+      end
+
+      def from_type(type)
+        @value =
+          if type.respond_to?(:to_ticks)
+            type.to_ticks
+          elsif type.respond_to?(:value_of)
+            type.value_of
+          else
+            type
+          end
+        self
+      end
+
+      def dispose
+        @disposed = true
+        self
+      end
+
+      def disposed?
+        @disposed
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      alias toString to_s
+
+      def value_of
+        to_i
+      end
+
+      class << self
+        def parse(value, bpm: Deftones.transport.bpm, time_signature: Deftones.transport.time_signature,
+                  ppq: Deftones.transport.ppq)
+          return value.to_f if value.is_a?(Numeric)
+
+          string_value = value.to_s
+          direct_ticks = string_value.match(/\A(-?\d+(?:\.\d+)?)i\z/i)
+          return direct_ticks[1].to_f if direct_ticks
+
+          seconds = Time.parse(value, bpm: bpm, time_signature: time_signature, ppq: ppq)
+          (seconds / (60.0 / bpm.to_f)) * ppq.to_f
+        end
+      end
+    end
+  end
+end

data/lib/deftones/music/time.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Music
+    class Time
+      attr_reader :value, :transport
+
+      def initialize(value, transport: Deftones.transport)
+        @value = value
+        @transport = transport
+        @disposed = false
+      end
+
+      def to_seconds
+        self.class.parse(
+          value,
+          bpm: transport.bpm,
+          time_signature: transport.time_signature,
+          ppq: transport.ppq
+        )
+      end
+
+      def to_ticks
+        transport.seconds_to_ticks(to_seconds)
+      end
+
+      def to_bars_beats_sixteenths
+        transport.seconds_to_position(to_seconds)
+      end
+
+      def to_frequency
+        1.0 / [to_seconds, 1.0e-6].max
+      end
+
+      def to_midi
+        Note.to_midi(Note.from_frequency(to_frequency))
+      end
+
+      def to_milliseconds
+        to_seconds * 1000.0
+      end
+
+      def to_samples(sample_rate = Deftones.context.sample_rate)
+        UnitHelpers.samples_for_seconds(to_seconds, sample_rate)
+      end
+
+      def to_notation
+        UnitHelpers.closest_notation(to_seconds, transport: transport)
+      end
+
+      def quantize(subdiv, percent = 1.0)
+        UnitHelpers.quantize_seconds(to_seconds, subdiv, transport: transport, percent: percent)
+      end
+
+      def from_type(type)
+        @value = type.respond_to?(:value_of) ? type.value_of : type
+        self
+      end
+
+      def dispose
+        @disposed = true
+        self
+      end
+
+      def disposed?
+        @disposed
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      alias toString to_s
+
+      def value_of
+        to_seconds
+      end
+
+      SYMBOL_MAP = {
+        whole: "1n",
+        half: "2n",
+        quarter: "4n",
+        eighth: "8n",
+        sixteenth: "16n",
+        quarter_triplet: "4t",
+        eighth_triplet: "8t",
+        dotted_quarter: "4n.",
+        dotted_eighth: "8n.",
+        measure: "1m"
+      }.freeze
+
+      class << self
+        def parse(value, bpm: Deftones.transport.bpm, time_signature: Deftones.transport.time_signature,
+                  ppq: Deftones.transport.ppq)
+          case value
+          when Numeric
+            value.to_f
+          when Symbol
+            parse(SYMBOL_MAP.fetch(value), bpm: bpm, time_signature: time_signature, ppq: ppq)
+          when String
+            return evaluate_expression(value, bpm: bpm, time_signature: time_signature, ppq: ppq) if arithmetic_expression?(value)
+
+            parse_literal(value, bpm: bpm, time_signature: time_signature, ppq: ppq)
+          when /\A(\d+)n\z/
+            parse_literal(value, bpm: bpm, time_signature: time_signature, ppq: ppq)
+          else
+            return value.to_seconds if value.respond_to?(:to_seconds)
+          end
+        rescue KeyError, ArgumentError
+          raise ArgumentError, "Unknown time format: #{value}"
+        end
+
+        private
+
+        def parse_literal(value, bpm:, time_signature:, ppq:)
+          case value
+          when /\A(\d+)n\z/
+            beats = 4.0 / Regexp.last_match(1).to_f
+            beats * beat_duration(bpm)
+          when /\A(\d+)t\z/
+            beats = (4.0 / Regexp.last_match(1).to_f) * (2.0 / 3.0)
+            beats * beat_duration(bpm)
+          when /\A(\d+)n\.\z/
+            parse("#{Regexp.last_match(1)}n", bpm: bpm, time_signature: time_signature, ppq: ppq) * 1.5
+          when /\A(\d+)m\z/i
+            measures = Regexp.last_match(1).to_f
+            beats_per_measure = Array(time_signature).first || 4
+            measures * beats_per_measure * beat_duration(bpm)
+          when /\A(\d+):(\d+):(\d+)\z/
+            bars = Regexp.last_match(1).to_f
+            beats = Regexp.last_match(2).to_f
+            sixteenths = Regexp.last_match(3).to_f
+            beats_per_measure = Array(time_signature).first || 4
+            ((bars * beats_per_measure) + beats + (sixteenths * 0.25)) * beat_duration(bpm)
+          when /\A(\d+(?:\.\d+)?)hz\z/i
+            1.0 / Regexp.last_match(1).to_f
+          when /\A(-?\d+(?:\.\d+)?)i\z/i
+            (Regexp.last_match(1).to_f / ppq.to_f) * beat_duration(bpm)
+          else
+            Float(value)
+          end
+        end
+
+        def arithmetic_expression?(value)
+          value.match?(/[+\-*\/()]/) && !value.match?(/\A-?\d+(?:\.\d+)?\z/)
+        end
+
+        def beat_duration(bpm)
+          60.0 / bpm.to_f
+        end
+
+        def evaluate_expression(value, bpm:, time_signature:, ppq:)
+          compute_rpn(to_rpn(tokenize(value)), bpm: bpm, time_signature: time_signature, ppq: ppq)
+        end
+
+        def tokenize(expression)
+          expression.scan(/\d+:\d+:\d+|\d+(?:\.\d+)?hz|-?\d+(?:\.\d+)?i|\d+n\.?|\d+t|\d+m|[()+\-*\/]|\d+(?:\.\d+)?/)
+        end
+
+        def to_rpn(tokens)
+          output = []
+          operators = []
+
+          tokens.each do |token|
+            if operator?(token)
+              while operators.any? && operator?(operators.last) && precedence(operators.last) >= precedence(token)
+                output << operators.pop
+              end
+              operators << token
+            elsif token == "("
+              operators << token
+            elsif token == ")"
+              output << operators.pop until operators.last == "("
+              operators.pop
+            else
+              output << token
+            end
+          end
+
+          output.concat(operators.reverse)
+        end
+
+        def compute_rpn(tokens, bpm:, time_signature:, ppq:)
+          stack = []
+
+          tokens.each do |token|
+            if operator?(token)
+              right = stack.pop
+              left = stack.pop
+              stack << left.public_send(token, right)
+            else
+              stack << parse_literal(token, bpm: bpm, time_signature: time_signature, ppq: ppq)
+            end
+          end
+
+          stack.first
+        end
+
+        def operator?(token)
+          %w[+ - * /].include?(token)
+        end
+
+        def precedence(token)
+          %w[* /].include?(token) ? 2 : 1
+        end
+      end
+    end
+  end
+end

data/lib/deftones/music/transport_time.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Music
+    class TransportTime
+      attr_reader :value, :transport
+
+      def initialize(value, transport: Deftones.transport)
+        @value = value
+        @transport = transport
+        @disposed = false
+      end
+
+      def to_seconds
+        self.class.parse(
+          value,
+          bpm: transport.bpm,
+          time_signature: transport.time_signature,
+          ppq: transport.ppq
+        )
+      end
+
+      def to_ticks
+        transport.seconds_to_ticks(to_seconds)
+      end
+
+      def to_bars_beats_sixteenths
+        transport.seconds_to_position(to_seconds)
+      end
+
+      def to_frequency
+        1.0 / [to_seconds, 1.0e-6].max
+      end
+
+      def to_midi
+        Note.to_midi(Note.from_frequency(to_frequency))
+      end
+
+      def to_milliseconds
+        to_seconds * 1000.0
+      end
+
+      def to_samples(sample_rate = Deftones.context.sample_rate)
+        UnitHelpers.samples_for_seconds(to_seconds, sample_rate)
+      end
+
+      def to_notation
+        UnitHelpers.closest_notation(to_seconds, transport: transport)
+      end
+
+      def quantize(subdiv, percent = 1.0)
+        UnitHelpers.quantize_seconds(to_seconds, subdiv, transport: transport, percent: percent)
+      end
+
+      def from_type(type)
+        @value =
+          if type.respond_to?(:to_bars_beats_sixteenths)
+            type.to_bars_beats_sixteenths
+          elsif type.respond_to?(:value_of)
+            type.value_of
+          else
+            type
+          end
+        self
+      end
+
+      def dispose
+        @disposed = true
+        self
+      end
+
+      def disposed?
+        @disposed
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      alias toString to_s
+
+      def value_of
+        to_seconds
+      end
+
+      class << self
+        def parse(value, bpm: Deftones.transport.bpm, time_signature: Deftones.transport.time_signature,
+                  ppq: Deftones.transport.ppq)
+          Time.parse(value, bpm: bpm, time_signature: time_signature, ppq: ppq)
+        end
+      end
+    end
+  end
+end

data/lib/deftones/music/unit_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Music
+    module UnitHelpers
+      NOTATION_CANDIDATES = %w[1m 1n 2n. 2n 4n. 4n 8n. 8n 8t 16n. 16n 16t 32n 64n 128n].freeze
+
+      class << self
+        def closest_notation(seconds, transport:)
+          NOTATION_CANDIDATES.min_by do |notation|
+            duration = Time.parse(notation, bpm: transport.bpm, time_signature: transport.time_signature, ppq: transport.ppq)
+            (duration - seconds).abs
+          end
+        end
+
+        def quantize_seconds(seconds, subdivision, transport:, percent: 1.0)
+          quantum = Time.parse(subdivision, bpm: transport.bpm, time_signature: transport.time_signature, ppq: transport.ppq)
+          return seconds unless quantum.positive?
+
+          target = (seconds / quantum).round * quantum
+          seconds + ((target - seconds) * percent.to_f.clamp(0.0, 1.0))
+        end
+
+        def samples_for_seconds(seconds, sample_rate)
+          (seconds * sample_rate.to_f).round
+        end
+      end
+    end
+  end
+end

data/lib/deftones/offline_context.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Deftones
+  class OfflineContext < Context
+    attr_reader :channels, :duration, :total_frames
+
+    def initialize(duration:, channels: 2, sample_rate: DEFAULT_SAMPLE_RATE,
+                   buffer_size: DEFAULT_BUFFER_SIZE)
+      super(sample_rate: sample_rate, buffer_size: buffer_size, channels: channels, autostart: false)
+      @duration = duration.to_f
+      @total_frames = (@duration * sample_rate).ceil
+    end
+
+    def current_time
+      0.0
+    end
+
+    def state
+      "suspended"
+    end
+
+    def render
+      Deftones.transport.prepare_render(@duration)
+      Deftones.draw.prepare_render(@duration)
+      samples = Array.new(@total_frames * @channels, 0.0)
+      frames_processed = 0
+
+      while frames_processed < @total_frames
+        chunk_frames = [buffer_size, @total_frames - frames_processed].min
+        interleaved = render_block_frames(chunk_frames, frames_processed).fit_channels(@channels).interleaved
+        start_index = frames_processed * @channels
+
+        samples[start_index, interleaved.length] = interleaved
+        frames_processed += chunk_frames
+      end
+
+      IO::Buffer.new(samples, channels: @channels, sample_rate: sample_rate)
+    end
+
+    def render_to_file(path, format: nil)
+      rendered_buffer = render
+      rendered_buffer.save(path, format: format)
+      rendered_buffer
+    end
+  end
+end

data/lib/deftones/portaudio_support.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Deftones
+  module PortAudioSupport
+    class << self
+      def available?
+        !!defined?(PortAudio)
+      end
+
+      def acquire!
+        raise Deftones::MissingRealtimeBackendError, "PortAudio backend is unavailable" unless available?
+
+        PortAudio.init
+      rescue StandardError => error
+        raise Deftones::MissingRealtimeBackendError, error.message
+      end
+
+      def release
+        return unless available?
+
+        PortAudio.terminate
+      rescue StandardError
+        nil
+      end
+
+      def output_parameters(channels)
+        build_stream_parameters(direction: :output, channels: channels)
+      end
+
+      def input_parameters(channels, device_id: nil, label: nil)
+        build_stream_parameters(direction: :input, channels: channels, device_id: device_id, label: label)
+      end
+
+      def check_error!(result, fallback: nil)
+        PortAudio.check_error!(result)
+      rescue StandardError => error
+        raise Deftones::MissingRealtimeBackendError, fallback || error.message
+      end
+
+      private
+
+      def build_stream_parameters(direction:, channels:, device_id: nil, label: nil)
+        device =
+          resolve_device(direction: direction, device_id: device_id, label: label)
+
+        raise Deftones::MissingRealtimeBackendError, "No default #{direction} device available" unless device
+
+        {
+          device: device,
+          channels: channels,
+          format: :float32,
+          latency: suggested_latency(device, direction)
+        }
+      rescue StandardError => error
+        raise Deftones::MissingRealtimeBackendError, error.message
+      end
+
+      def resolve_device(direction:, device_id:, label:)
+        return default_device(direction) if device_id.nil? && label.nil?
+
+        devices =
+          if PortAudio::Device.respond_to?(:all)
+            Array(PortAudio::Device.all)
+          elsif PortAudio::Device.respond_to?(:devices)
+            Array(PortAudio::Device.devices)
+          else
+            []
+          end
+
+        matched = devices.find do |device|
+          matches_device_id?(device, device_id) || matches_device_label?(device, label)
+        end
+        return matched if matched
+
+        raise Deftones::MissingRealtimeBackendError, "No matching #{direction} device available"
+      end
+
+      def default_device(direction)
+        case direction
+        when :input then PortAudio::Device.default_input
+        when :output then PortAudio::Device.default_output
+        else raise ArgumentError, "Unsupported PortAudio direction: #{direction}"
+        end
+      end
+
+      def matches_device_id?(device, device_id)
+        return false if device_id.nil?
+
+        candidates = []
+        candidates << device.device_id if device.respond_to?(:device_id)
+        candidates << device.index if device.respond_to?(:index)
+        candidates << device.device_index if device.respond_to?(:device_index)
+        candidates.compact.any? { |candidate| candidate.to_s == device_id.to_s }
+      end
+
+      def matches_device_label?(device, label)
+        return false if label.nil?
+
+        candidates = []
+        candidates << device.label if device.respond_to?(:label)
+        candidates << device.name if device.respond_to?(:name)
+        candidates.compact.any? { |candidate| candidate.to_s == label.to_s }
+      end
+
+      def suggested_latency(device, direction)
+        direction == :input ? device.default_low_input_latency : device.default_low_output_latency
+      end
+    end
+  end
+end

data/lib/deftones/source/am_oscillator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class AMOscillator < Core::Source
+      attr_reader :frequency, :harmonicity, :detune
+
+      def initialize(frequency: 440.0, harmonicity: 2.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)
+        @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)
+        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]
+          carrier = Math.sin(2.0 * Math::PI * @carrier_phase)
+          modulator = (Math.sin(2.0 * Math::PI * @modulator_phase) + 1.0) * 0.5
+
+          @carrier_phase = (@carrier_phase + (carrier_frequency / context.sample_rate)) % 1.0
+          @modulator_phase = (@modulator_phase + (modulator_frequency / context.sample_rate)) % 1.0
+          carrier * modulator
+        end
+      end
+    end
+  end
+end

data/lib/deftones/source/fat_oscillator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Source
+    class FatOscillator < Core::Source
+      attr_reader :frequency
+      attr_accessor :count, :spread, :type
+
+      def initialize(type: :sawtooth, frequency: 440.0, count: 3, spread: 20.0, context: Deftones.context)
+        super(context: context)
+        @type = type.to_sym
+        @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
+        @count = count.to_i
+        @spread = spread.to_f
+        @phases = Array.new(@count, 0.0)
+      end
+
+      def process(_input_buffer, num_frames, start_frame, _cache)
+        frequencies = @frequency.process(num_frames, start_frame)
+        generator = Oscillator::GENERATORS.fetch(@type) { Oscillator::GENERATORS[:sawtooth] }
+
+        Array.new(num_frames) do |index|
+          current_time = (start_frame + index).to_f / context.sample_rate
+          next 0.0 unless active_at?(current_time)
+
+          detuned = detune_frequencies(frequencies[index])
+          samples = @phases.each_with_index.map do |phase, voice_index|
+            sample = generator.call(phase)
+            @phases[voice_index] = (phase + (detuned[voice_index] / context.sample_rate)) % 1.0
+            sample
+          end
+          samples.sum / samples.length.to_f
+        end
+      end
+
+      private
+
+      def detune_frequencies(base_frequency)
+        offsets = Array.new(@count) do |index|
+          position = @count == 1 ? 0.0 : (index.to_f / (@count - 1)) - 0.5
+          cents = position * @spread
+          base_frequency * (2.0**(cents / 1200.0))
+        end
+        @phases = Array.new(@count, 0.0) if @phases.length != @count
+        offsets
+      end
+    end
+  end
+end