rtmidi-ruby 0.1.0

data/lib/rtmidi/message.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Rtmidi
+  module Message
+    NoteOff = Struct.new(:channel, :note, :velocity, keyword_init: true)
+    NoteOn = Struct.new(:channel, :note, :velocity, keyword_init: true)
+    PolyAftertouch = Struct.new(:channel, :note, :pressure, keyword_init: true)
+    ControlChange = Struct.new(:channel, :controller, :value, keyword_init: true)
+    ProgramChange = Struct.new(:channel, :program, keyword_init: true)
+    ChannelAftertouch = Struct.new(:channel, :pressure, keyword_init: true)
+    PitchBend = Struct.new(:channel, :value, keyword_init: true)
+    SysEx = Struct.new(:data, keyword_init: true)
+    TimeCodeQuarterFrame = Struct.new(:message_type, :value, keyword_init: true)
+    SongPositionPointer = Struct.new(:position, keyword_init: true)
+    SongSelect = Struct.new(:song, keyword_init: true)
+    TuneRequest = Struct.new(nil, keyword_init: true)
+    TimingClock = Struct.new(nil, keyword_init: true)
+    Start = Struct.new(nil, keyword_init: true)
+    Continue = Struct.new(nil, keyword_init: true)
+    Stop = Struct.new(nil, keyword_init: true)
+    ActiveSensing = Struct.new(nil, keyword_init: true)
+    SystemReset = Struct.new(nil, keyword_init: true)
+    Unknown = Struct.new(:bytes, keyword_init: true)
+
+    class << self
+      def parse(message)
+        bytes = normalize_bytes(message, allow_empty: false)
+        status = bytes[0]
+
+        return parse_system_message(status, bytes) if status >= 0xF0
+
+        parse_channel_message(status, bytes)
+      end
+
+      def serialize(message)
+        case message
+        when Array
+          normalize_bytes(message, allow_empty: false)
+        when NoteOff
+          [status_byte(0x80, message.channel), data_byte(message.note, "note"), data_byte(message.velocity, "velocity")]
+        when NoteOn
+          [status_byte(0x90, message.channel), data_byte(message.note, "note"), data_byte(message.velocity, "velocity")]
+        when PolyAftertouch
+          [status_byte(0xA0, message.channel), data_byte(message.note, "note"), data_byte(message.pressure, "pressure")]
+        when ControlChange
+          [status_byte(0xB0, message.channel), data_byte(message.controller, "controller"), data_byte(message.value, "value")]
+        when ProgramChange
+          [status_byte(0xC0, message.channel), data_byte(message.program, "program")]
+        when ChannelAftertouch
+          [status_byte(0xD0, message.channel), data_byte(message.pressure, "pressure")]
+        when PitchBend
+          bend = integer_in_range(message.value, 0, 16_383, "value")
+          [status_byte(0xE0, message.channel), bend & 0x7F, (bend >> 7) & 0x7F]
+        when SysEx
+          serialize_sysex(message.data)
+        when TimeCodeQuarterFrame
+          message_type = integer_in_range(message.message_type, 0, 7, "message_type")
+          value = integer_in_range(message.value, 0, 15, "value")
+          [0xF1, (message_type << 4) | value]
+        when SongPositionPointer
+          position = integer_in_range(message.position, 0, 16_383, "position")
+          [0xF2, position & 0x7F, (position >> 7) & 0x7F]
+        when SongSelect
+          [0xF3, data_byte(message.song, "song")]
+        when TuneRequest
+          [0xF6]
+        when TimingClock
+          [0xF8]
+        when Start
+          [0xFA]
+        when Continue
+          [0xFB]
+        when Stop
+          [0xFC]
+        when ActiveSensing
+          [0xFE]
+        when SystemReset
+          [0xFF]
+        when Unknown
+          normalize_bytes(message.bytes, allow_empty: false)
+        else
+          raise ArgumentError, "unsupported MIDI message: #{message.inspect}"
+        end
+      end
+
+      private
+
+      def parse_channel_message(status, bytes)
+        channel = status & 0x0F
+
+        case status & 0xF0
+        when 0x80
+          expect_length!(bytes, 3, "note off")
+          NoteOff.new(channel: channel, note: bytes[1], velocity: bytes[2])
+        when 0x90
+          expect_length!(bytes, 3, "note on")
+          NoteOn.new(channel: channel, note: bytes[1], velocity: bytes[2])
+        when 0xA0
+          expect_length!(bytes, 3, "poly aftertouch")
+          PolyAftertouch.new(channel: channel, note: bytes[1], pressure: bytes[2])
+        when 0xB0
+          expect_length!(bytes, 3, "control change")
+          ControlChange.new(channel: channel, controller: bytes[1], value: bytes[2])
+        when 0xC0
+          expect_length!(bytes, 2, "program change")
+          ProgramChange.new(channel: channel, program: bytes[1])
+        when 0xD0
+          expect_length!(bytes, 2, "channel aftertouch")
+          ChannelAftertouch.new(channel: channel, pressure: bytes[1])
+        when 0xE0
+          expect_length!(bytes, 3, "pitch bend")
+          PitchBend.new(channel: channel, value: bytes[1] | (bytes[2] << 7))
+        else
+          Unknown.new(bytes: bytes)
+        end
+      end
+
+      def parse_system_message(status, bytes)
+        case status
+        when 0xF0
+          SysEx.new(data: bytes[1..-2] || [])
+        when 0xF1
+          expect_length!(bytes, 2, "time code quarter frame")
+          TimeCodeQuarterFrame.new(message_type: (bytes[1] >> 4) & 0x07, value: bytes[1] & 0x0F)
+        when 0xF2
+          expect_length!(bytes, 3, "song position pointer")
+          SongPositionPointer.new(position: bytes[1] | (bytes[2] << 7))
+        when 0xF3
+          expect_length!(bytes, 2, "song select")
+          SongSelect.new(song: bytes[1])
+        when 0xF6
+          TuneRequest.new
+        when 0xF8
+          TimingClock.new
+        when 0xFA
+          Start.new
+        when 0xFB
+          Continue.new
+        when 0xFC
+          Stop.new
+        when 0xFE
+          ActiveSensing.new
+        when 0xFF
+          SystemReset.new
+        else
+          Unknown.new(bytes: bytes)
+        end
+      end
+
+      def serialize_sysex(data)
+        bytes = normalize_bytes(data, allow_empty: true)
+        return [0xF0, 0xF7] if bytes.empty?
+
+        return bytes if bytes[0] == 0xF0 && bytes[-1] == 0xF7
+        raise ArgumentError, "sysex data with 0xF0 prefix must end with 0xF7" if bytes[0] == 0xF0
+
+        [0xF0, *bytes, 0xF7]
+      end
+
+      def status_byte(base, channel)
+        base | integer_in_range(channel, 0, 15, "channel")
+      end
+
+      def data_byte(value, label)
+        integer_in_range(value, 0, 127, label)
+      end
+
+      def integer_in_range(value, min, max, label)
+        integer = begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          raise ArgumentError, "#{label} must be an Integer"
+        end
+
+        return integer if integer >= min && integer <= max
+
+        raise ArgumentError, "#{label} must be within #{min}..#{max}"
+      end
+
+      def normalize_bytes(message, allow_empty:)
+        raise ArgumentError, "message must be an Array" unless message.is_a?(Array)
+        raise ArgumentError, "message must not be empty" if !allow_empty && message.empty?
+
+        message.each_with_index.map do |byte, index|
+          integer_in_range(byte, 0, 255, "message[#{index}]")
+        end
+      end
+
+      def expect_length!(bytes, minimum, label)
+        return if bytes.length >= minimum
+
+        raise ArgumentError, "#{label} message must contain at least #{minimum} bytes"
+      end
+    end
+  end
+end

data/lib/rtmidi/midi_in.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module Rtmidi
+  class MidiIn
+    DEFAULT_CLIENT_NAME = "Rtmidi Ruby Client"
+    DEFAULT_PORT_NAME = "Rtmidi Input"
+    DEFAULT_QUEUE_SIZE_LIMIT = 1024
+    POLL_BUFFER_SIZE = 65_536
+
+    class Release
+      def initialize(handle)
+        @handle = handle
+        @mutex = Mutex.new
+      end
+
+      def call(*)
+        free
+      end
+
+      def free
+        @mutex.synchronize do
+          return if @handle.nil? || @handle.null?
+
+          Native.rtmidi_in_free(@handle)
+          @handle = nil
+        end
+      end
+    end
+
+    def initialize(api: :unspecified, client_name: DEFAULT_CLIENT_NAME, queue_size_limit: DEFAULT_QUEUE_SIZE_LIMIT)
+      Native.ensure_loaded!
+      queue_limit = integer_for(queue_size_limit, "queue_size_limit")
+
+      @mutex = Mutex.new
+      @port_open = false
+      @closed = false
+      @last_async_error = nil
+      @user_error_callback = nil
+      @error_callback = nil
+      @message_callback = nil
+
+      @handle = Native.rtmidi_in_create(Api.normalize(api), client_name.to_s, queue_limit)
+      raise Error, "failed to create RtMidi input device" if @handle.nil? || @handle.null?
+
+      @release = Release.new(@handle)
+      ObjectSpace.define_finalizer(self, @release)
+
+      setup_error_callback
+      Native.check_error(@handle)
+    end
+
+    def port_count
+      with_device_lock do
+        port_count_locked
+      end
+    end
+
+    def port_name(number)
+      with_device_lock do
+        port_name_locked(normalize_port_number(number, port_count_locked))
+      end
+    end
+
+    def port_names
+      with_device_lock do
+        count = port_count_locked
+        Array.new(count) { |index| port_name_locked(index) }
+      end
+    end
+
+    def open_port(number, name: DEFAULT_PORT_NAME)
+      with_device_lock do
+        index = normalize_port_number(number, port_count_locked)
+        Native.rtmidi_open_port(@handle, index, name.to_s)
+        Native.check_error(@handle)
+        @port_open = true
+      end
+      self
+    end
+
+    def open_virtual_port(name: "Rtmidi Virtual Input")
+      with_device_lock do
+        Native.rtmidi_open_virtual_port(@handle, name.to_s)
+        Native.check_error(@handle)
+        @port_open = true
+      end
+      self
+    end
+
+    def close_port
+      with_device_lock do
+        Native.rtmidi_close_port(@handle)
+        Native.check_error(@handle)
+        @port_open = false
+      end
+      self
+    end
+
+    def port_open?
+      @mutex.synchronize { @port_open }
+    end
+
+    def current_api
+      with_device_lock do
+        Api.normalize(Native.rtmidi_in_get_current_api(@handle))
+      end
+    end
+
+    def current_api_name
+      Rtmidi.api_name(current_api)
+    end
+
+    def current_api_display_name
+      Rtmidi.api_display_name(current_api)
+    end
+
+    def set_callback(parsed: false, &block)
+      raise ArgumentError, "block required" unless block
+
+      with_device_lock do
+        raise InvalidUseError, "callback already set" if @message_callback
+
+        @message_callback = proc do |timestamp, msg_ptr, msg_size, _user_data|
+          bytes = if msg_ptr.nil? || msg_ptr.null? || msg_size.to_i <= 0
+                    []
+                  else
+                    msg_ptr.read_array_of_uint8(msg_size.to_i)
+                  end
+          payload = parsed ? Rtmidi::Message.parse(bytes) : bytes
+          block.call(payload, timestamp)
+        rescue StandardError => e
+          @mutex.synchronize { @last_async_error ||= e }
+        end
+
+        Native.rtmidi_in_set_callback(@handle, @message_callback, nil)
+        Native.check_error(@handle)
+      end
+      self
+    end
+    alias on_message set_callback
+
+    def cancel_callback
+      with_device_lock do
+        if @message_callback
+          Native.rtmidi_in_cancel_callback(@handle)
+          Native.check_error(@handle)
+          @message_callback = nil
+        end
+      end
+      self
+    end
+
+    def get_message(parsed: false)
+      with_device_lock do
+        raise InvalidUseError, "get_message cannot be used while callback is set" if @message_callback
+
+        buffer = FFI::MemoryPointer.new(:uint8, POLL_BUFFER_SIZE)
+        size_ptr = FFI::MemoryPointer.new(:size_t, 1)
+        Native.write_size_t(size_ptr, POLL_BUFFER_SIZE)
+
+        timestamp = Native.rtmidi_in_get_message(@handle, buffer, size_ptr)
+        Native.check_error(@handle)
+
+        size = Native.read_size_t(size_ptr)
+        return nil if size.zero?
+
+        bytes = buffer.read_array_of_uint8(size)
+        [parsed ? Rtmidi::Message.parse(bytes) : bytes, timestamp]
+      end
+    end
+
+    def ignore_types(sysex: true, timing: true, active_sensing: true)
+      with_device_lock do
+        Native.rtmidi_in_ignore_types(@handle, !!sysex, !!timing, !!active_sensing)
+        Native.check_error(@handle)
+      end
+      self
+    end
+
+    def on_error(&block)
+      raise ArgumentError, "block required" unless block
+
+      @mutex.synchronize { @user_error_callback = block }
+      self
+    end
+
+    def close
+      @mutex.synchronize do
+        return if @closed
+
+        begin
+          if @message_callback
+            Native.rtmidi_in_cancel_callback(@handle)
+            Native.check_error(@handle)
+            @message_callback = nil
+          end
+
+          if @port_open
+            Native.rtmidi_close_port(@handle)
+            Native.check_error(@handle)
+            @port_open = false
+          end
+        ensure
+          @release&.free
+          @handle = nil
+          @closed = true
+        end
+      end
+      nil
+    end
+
+    def closed?
+      @mutex.synchronize { @closed }
+    end
+
+    private
+
+    def setup_error_callback
+      return unless Native.function_available?(:rtmidi_set_error_callback)
+
+      @error_callback = proc do |type, error_text, _user_data|
+        callback = @mutex.synchronize { @user_error_callback }
+
+        if callback
+          callback.call(type, error_text)
+        elsif Rtmidi.warning_type?(type)
+          warn "[Rtmidi #{type}] #{error_text}"
+        else
+          @mutex.synchronize { @last_async_error ||= Rtmidi.error_for(type, error_text) }
+        end
+      rescue StandardError => e
+        @mutex.synchronize { @last_async_error ||= e }
+      end
+
+      Native.rtmidi_set_error_callback(@handle, @error_callback, nil)
+      Native.check_error(@handle)
+    end
+
+    def with_device_lock
+      @mutex.synchronize do
+        raise InvalidUseError, "device is closed" if @closed
+
+        raise_pending_async_error!
+        yield
+      end
+    end
+
+    def raise_pending_async_error!
+      error = @last_async_error
+      @last_async_error = nil
+      raise error unless error.nil?
+    end
+
+    def port_count_locked
+      count = Native.rtmidi_get_port_count(@handle)
+      Native.check_error(@handle)
+      count
+    end
+
+    def port_name_locked(number)
+      len_ptr = FFI::MemoryPointer.new(:int, 1)
+      len_ptr.write_int(0)
+      Native.rtmidi_get_port_name(@handle, number, nil, len_ptr)
+      Native.check_error(@handle)
+
+      length = len_ptr.read_int
+      return "" if length <= 0
+
+      buffer = FFI::MemoryPointer.new(:char, length)
+      len_ptr.write_int(length)
+      Native.rtmidi_get_port_name(@handle, number, buffer, len_ptr)
+      Native.check_error(@handle)
+      buffer.read_string
+    end
+
+    def normalize_port_number(number, count)
+      port = integer_for(number, "port")
+      raise NoDevicesError, "no MIDI ports available" if count.zero?
+
+      return port if port >= 0 && port < count
+
+      raise InvalidPortError, "invalid port index #{port} (available: 0...#{count})"
+    end
+
+    def integer_for(value, label)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "#{label} must be an Integer"
+    end
+  end
+end