deftones 0.1.0

data/lib/deftones/io/buffers.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Deftones
+  module IO
+    class Buffers
+      include Enumerable
+
+      def initialize(buffers = {})
+        @buffers = {}
+        @disposed = false
+        merge(buffers)
+      end
+
+      def add(name, buffer)
+        @buffers[key_for(name)] = normalize_buffer(buffer)
+        self
+      end
+
+      def get(name)
+        self[name]
+      end
+
+      def [](name)
+        @buffers[key_for(name)]
+      end
+
+      def fetch(name)
+        @buffers.fetch(key_for(name))
+      end
+
+      def has?(name)
+        @buffers.key?(key_for(name))
+      end
+
+      def loaded?
+        !@disposed
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block
+
+        @buffers.each(&block)
+      end
+
+      def keys
+        @buffers.keys
+      end
+
+      def to_h
+        @buffers.dup
+      end
+
+      def merge(buffers)
+        buffers.each { |name, buffer| add(name, buffer) }
+        self
+      end
+
+      def dispose
+        @buffers.clear
+        @disposed = true
+        self
+      end
+
+      alias loaded loaded?
+
+      private
+
+      def key_for(name)
+        name.to_sym
+      end
+
+      def normalize_buffer(buffer)
+        buffer.is_a?(Buffer) ? buffer : Buffer.load(buffer)
+      end
+    end
+  end
+end

data/lib/deftones/io/recorder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Deftones
+  module IO
+    class Recorder
+      attr_reader :state, :mime_type, :captured_buffer
+
+      MIME_TYPES = {
+        wav: "audio/wav",
+        mp3: "audio/mpeg",
+        ogg: "audio/ogg"
+      }.freeze
+
+      def initialize(context:, node: nil, mime_type: "audio/wav")
+        @context = context
+        @node = node || context.output
+        @captured_buffer = nil
+        @mime_type = mime_type
+        @state = :stopped
+        @started_at = nil
+        @recorded_duration = 0.0
+      end
+
+      def start
+        @captured_buffer = nil
+        @started_at = @context.current_time
+        @state = :started
+        self
+      end
+
+      def stop(path: nil, format: nil, duration: nil)
+        return @captured_buffer if @state == :stopped && @captured_buffer
+
+        @recorded_duration = duration || elapsed_duration
+        @captured_buffer = capture_buffer(duration: @recorded_duration)
+        @state = :stopped
+        save(path, format: resolve_format(format, path)) if path
+        @captured_buffer
+      end
+
+      def record(duration: nil, format: :wav, path: nil)
+        start
+        stop(path: path, format: format, duration: duration)
+      end
+
+      def save(path, format: :wav)
+        raise ArgumentError, "Nothing recorded yet" unless @captured_buffer
+
+        @captured_buffer.save(path, format: format)
+      end
+
+      def dispose
+        @captured_buffer = nil
+        @state = :stopped
+        @started_at = nil
+        @recorded_duration = 0.0
+        self
+      end
+
+      alias mimeType mime_type
+
+      private
+
+      def capture_buffer(duration:)
+        if @context.is_a?(Deftones::OfflineContext)
+          @context.render
+        else
+          seconds = [duration.to_f, 1.0 / @context.sample_rate].max
+          frames = (seconds * @context.sample_rate).ceil
+          block = @node.send(:render_block, frames, 0, {}).fit_channels(@context.channels)
+          Buffer.new(block.interleaved, channels: @context.channels, sample_rate: @context.sample_rate)
+        end
+      end
+
+      def elapsed_duration
+        return 0.0 unless @started_at
+
+        [@context.current_time - @started_at, 0.0].max
+      end
+
+      def resolve_format(format, path)
+        return format if format
+        return File.extname(path).delete_prefix(".").downcase.to_sym if path
+
+        MIME_TYPES.key(@mime_type) || :wav
+      end
+    end
+  end
+end

data/lib/deftones/listener.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Deftones
+  class Listener
+    attr_reader :forward_x, :forward_y, :forward_z, :position_x, :position_y, :position_z, :up_x, :up_y, :up_z
+
+    def initialize(context: Deftones.context)
+      @position_x = Core::Signal.new(value: 0.0, units: :number, context: context)
+      @position_y = Core::Signal.new(value: 0.0, units: :number, context: context)
+      @position_z = Core::Signal.new(value: 0.0, units: :number, context: context)
+      @forward_x = Core::Signal.new(value: 0.0, units: :number, context: context)
+      @forward_y = Core::Signal.new(value: 0.0, units: :number, context: context)
+      @forward_z = Core::Signal.new(value: -1.0, units: :number, context: context)
+      @up_x = Core::Signal.new(value: 0.0, units: :number, context: context)
+      @up_y = Core::Signal.new(value: 1.0, units: :number, context: context)
+      @up_z = Core::Signal.new(value: 0.0, units: :number, context: context)
+    end
+
+    def position_x=(value)
+      @position_x.value = value
+    end
+
+    def position_y=(value)
+      @position_y.value = value
+    end
+
+    def position_z=(value)
+      @position_z.value = value
+    end
+
+    def forward_x=(value)
+      @forward_x.value = value
+    end
+
+    def forward_y=(value)
+      @forward_y.value = value
+    end
+
+    def forward_z=(value)
+      @forward_z.value = value
+    end
+
+    def up_x=(value)
+      @up_x.value = value
+    end
+
+    def up_y=(value)
+      @up_y.value = value
+    end
+
+    def up_z=(value)
+      @up_z.value = value
+    end
+
+    def set_position(x, y, z)
+      self.position_x = x
+      self.position_y = y
+      self.position_z = z
+      self
+    end
+
+    def set_orientation(forward_x, forward_y, forward_z, up_x = 0.0, up_y = 1.0, up_z = 0.0)
+      self.forward_x = forward_x
+      self.forward_y = forward_y
+      self.forward_z = forward_z
+      self.up_x = up_x
+      self.up_y = up_y
+      self.up_z = up_z
+      self
+    end
+
+    alias positionX position_x
+    alias positionY position_y
+    alias positionZ position_z
+    alias forwardX forward_x
+    alias forwardY forward_y
+    alias forwardZ forward_z
+    alias upX up_x
+    alias upY up_y
+    alias upZ up_z
+    alias setPosition set_position
+    alias setOrientation set_orientation
+
+    def positionX=(value)
+      self.position_x = value
+    end
+
+    def positionY=(value)
+      self.position_y = value
+    end
+
+    def positionZ=(value)
+      self.position_z = value
+    end
+
+    def forwardX=(value)
+      self.forward_x = value
+    end
+
+    def forwardY=(value)
+      self.forward_y = value
+    end
+
+    def forwardZ=(value)
+      self.forward_z = value
+    end
+
+    def upX=(value)
+      self.up_x = value
+    end
+
+    def upY=(value)
+      self.up_y = value
+    end
+
+    def upZ=(value)
+      self.up_z = value
+    end
+  end
+end

data/lib/deftones/music/frequency.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Music
+    class Frequency
+      attr_reader :value, :transport
+
+      def initialize(value, transport: Deftones.transport)
+        @value = value
+        @transport = transport
+        @disposed = false
+      end
+
+      def to_hz
+        self.class.parse(value)
+      end
+
+      def to_frequency
+        to_hz
+      end
+
+      def to_seconds
+        self.class.to_period(value)
+      end
+
+      def to_midi
+        self.class.to_midi(value)
+      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_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 to_note
+        Note.from_frequency(to_hz)
+      end
+
+      def transpose(interval)
+        self.class.new(Note.from_midi(to_midi + interval.to_i), transport: transport)
+      end
+
+      def harmonize(intervals)
+        Array(intervals).map { |interval| transpose(interval) }
+      end
+
+      def quantize(subdiv, percent = 1.0)
+        quantized_seconds = UnitHelpers.quantize_seconds(to_seconds, subdiv, transport: transport, percent: percent)
+        1.0 / [quantized_seconds, 1.0e-6].max
+      end
+
+      def from_type(type)
+        @value =
+          if type.respond_to?(:to_frequency)
+            type.to_frequency
+          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_hz
+      end
+
+      class << self
+        def mtof(value)
+          Deftones.mtof(value)
+        end
+
+        def ftom(value)
+          Deftones.ftom(value)
+        end
+
+        def parse(value)
+          case value
+          when Numeric
+            value.to_f
+          when /\A(\d+(?:\.\d+)?)hz\z/i
+            Regexp.last_match(1).to_f
+          else
+            Note.to_frequency(value)
+          end
+        end
+
+        def to_period(value)
+          1.0 / parse(value)
+        end
+
+        def to_midi(value)
+          Note.to_midi(Note.from_frequency(parse(value)))
+        end
+      end
+    end
+  end
+end

data/lib/deftones/music/midi.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+begin
+  require "unimidi"
+rescue LoadError
+  nil
+end
+
+module Deftones
+  module Music
+    class Midi
+      attr_reader :value, :transport
+
+      def initialize(value, transport: Deftones.transport)
+        @value = value
+        @transport = transport
+        @disposed = false
+      end
+
+      def to_i
+        self.class.parse(value)
+      end
+
+      def to_frequency
+        Note.to_frequency(to_note)
+      end
+
+      def to_seconds
+        1.0 / to_frequency
+      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_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 transpose(interval)
+        self.class.new(to_i + interval.to_i, transport: transport)
+      end
+
+      def harmonize(intervals)
+        Array(intervals).map { |interval| transpose(interval) }
+      end
+
+      def quantize(subdiv, percent = 1.0)
+        quantized_seconds = UnitHelpers.quantize_seconds(to_seconds, subdiv, transport: transport, percent: percent)
+        Note.to_midi(Note.from_frequency(1.0 / [quantized_seconds, 1.0e-6].max))
+      end
+
+      def from_type(type)
+        @value =
+          if type.respond_to?(:to_midi)
+            type.to_midi
+          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 to_note
+        Note.from_midi(to_i)
+      end
+
+      def value_of
+        to_i
+      end
+
+      class << self
+        def parse(value)
+          return value.to_i if value.is_a?(Numeric)
+
+          Note.to_midi(value)
+        end
+
+        def available?
+          !!defined?(UniMIDI)
+        end
+
+        def input_devices
+          return [] unless available?
+
+          UniMIDI::Input.all
+        end
+
+        def output_devices
+          return [] unless available?
+
+          UniMIDI::Output.all
+        end
+
+        def find_input(name = nil)
+          find_device(input_devices, name)
+        end
+
+        def find_output(name = nil)
+          find_device(output_devices, name)
+        end
+
+        def open_input(name = nil, *args, &block)
+          open_device(find_input(name), *args, &block)
+        end
+
+        def open_output(name = nil, *args, &block)
+          open_device(find_output(name), *args, &block)
+        end
+
+        def receive(name = nil, *args)
+          open_input(name) do |input|
+            input.gets(*args)
+          end
+        end
+
+        def send_message(message, device: nil)
+          open_output(device) do |output|
+            output.puts(message)
+          end
+        end
+
+        def note_on(note, velocity: 100, channel: 1, device: nil)
+          send_message([status_byte(0x90, channel), normalize_note(note), normalize_data_byte(velocity)], device: device)
+        end
+
+        def note_off(note, velocity: 0, channel: 1, device: nil)
+          send_message([status_byte(0x80, channel), normalize_note(note), normalize_data_byte(velocity)], device: device)
+        end
+
+        def control_change(controller, value, channel: 1, device: nil)
+          send_message(
+            [status_byte(0xB0, channel), normalize_data_byte(controller), normalize_data_byte(value)],
+            device: device
+          )
+        end
+
+        private
+
+        def find_device(devices, name)
+          return devices.first if name.nil?
+
+          devices.find { |device| device.name == name.to_s }
+        end
+
+        def open_device(device, *args, &block)
+          raise ArgumentError, "MIDI support is unavailable" unless available?
+          raise ArgumentError, "No matching MIDI device found" unless device
+
+          return device.open(*args) unless block
+
+          device.open(*args)
+          begin
+            block.call(device)
+          ensure
+            device.close if device.respond_to?(:close)
+          end
+        end
+
+        def normalize_note(note)
+          normalize_data_byte(parse(note))
+        end
+
+        def normalize_data_byte(value)
+          value.to_i.clamp(0, 127)
+        end
+
+        def status_byte(base, channel)
+          base + normalize_channel(channel)
+        end
+
+        def normalize_channel(channel)
+          [[channel.to_i - 1, 0].max, 15].min
+        end
+      end
+    end
+  end
+end

data/lib/deftones/music/note.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Deftones
+  module Music
+    class Note
+      NOTE_NAMES = %w[C C# D D# E F F# G G# A A# B].freeze
+      FLAT_MAP = {
+        "Cb" => "B",
+        "Db" => "C#",
+        "Eb" => "D#",
+        "Fb" => "E",
+        "Gb" => "F#",
+        "Ab" => "G#",
+        "Bb" => "A#"
+      }.freeze
+
+      class << self
+        def to_frequency(note_name)
+          midi_number = to_midi(note_name)
+          440.0 * (2.0**((midi_number - 69) / 12.0))
+        end
+
+        def to_midi(note_name)
+          name, octave = parse_note_name(note_name)
+          NOTE_NAMES.index(name) + ((octave + 1) * 12)
+        end
+
+        def from_midi(midi_number)
+          integer = midi_number.to_i
+          octave = (integer / 12) - 1
+          "#{NOTE_NAMES[integer % 12]}#{octave}"
+        end
+
+        def from_frequency(frequency)
+          midi_number = (12 * Math.log2(frequency.to_f / 440.0) + 69).round
+          from_midi(midi_number)
+        end
+
+        private
+
+        def parse_note_name(note_name)
+          match = note_name.to_s.match(/\A([A-Ga-g][#b]?)(-?\d+)\z/)
+          raise ArgumentError, "Invalid note: #{note_name}" unless match
+
+          normalized_name = normalize_name(match[1])
+          raise ArgumentError, "Unsupported note name: #{note_name}" unless NOTE_NAMES.include?(normalized_name)
+
+          [normalized_name, match[2].to_i]
+        end
+
+        def normalize_name(token)
+          canonical = token[0].upcase + token[1..]
+          FLAT_MAP.fetch(canonical, canonical.upcase)
+        end
+      end
+    end
+  end
+end