rtmidi-ruby 0.1.0

data/lib/rtmidi/midi_out.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+module Rtmidi
+  class MidiOut
+    DEFAULT_CLIENT_NAME = "Rtmidi Ruby Client"
+    DEFAULT_PORT_NAME = "Rtmidi Output"
+
+    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_out_free(@handle)
+          @handle = nil
+        end
+      end
+    end
+
+    def initialize(api: :unspecified, client_name: DEFAULT_CLIENT_NAME)
+      Native.ensure_loaded!
+
+      @mutex = Mutex.new
+      @port_open = false
+      @closed = false
+      @last_async_error = nil
+      @user_error_callback = nil
+      @error_callback = nil
+
+      @handle = Native.rtmidi_out_create(Api.normalize(api), client_name.to_s)
+      raise Error, "failed to create RtMidi output 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 Output")
+      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_out_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 send_message(message)
+      bytes = normalize_message(message)
+
+      with_device_lock do
+        raise InvalidUseError, "port is not open" unless @port_open
+
+        buffer = FFI::MemoryPointer.new(:uint8, bytes.length)
+        buffer.write_array_of_uint8(bytes)
+        Native.rtmidi_out_send_message(@handle, buffer, bytes.length)
+        Native.check_error(@handle)
+      end
+      self
+    end
+
+    def sysex(data)
+      send_message(Rtmidi::Message::SysEx.new(data: data))
+    end
+
+    def note_on(channel, note, velocity)
+      send_message([
+        status_byte(0x90, channel),
+        data_byte(note, "note"),
+        data_byte(velocity, "velocity")
+      ])
+    end
+
+    def note_off(channel, note, velocity: 0)
+      send_message([
+        status_byte(0x80, channel),
+        data_byte(note, "note"),
+        data_byte(velocity, "velocity")
+      ])
+    end
+
+    def control_change(channel, controller, value)
+      send_message([
+        status_byte(0xB0, channel),
+        data_byte(controller, "controller"),
+        data_byte(value, "value")
+      ])
+    end
+
+    def program_change(channel, program)
+      send_message([
+        status_byte(0xC0, channel),
+        data_byte(program, "program")
+      ])
+    end
+
+    def pitch_bend(channel, value)
+      bend = normalize_range(value, 0, 16_383, "value")
+      send_message([
+        status_byte(0xE0, channel),
+        bend & 0x7F,
+        (bend >> 7) & 0x7F
+      ])
+    end
+
+    def channel_aftertouch(channel, pressure)
+      send_message([
+        status_byte(0xD0, channel),
+        data_byte(pressure, "pressure")
+      ])
+    end
+
+    def poly_aftertouch(channel, note, pressure)
+      send_message([
+        status_byte(0xA0, channel),
+        data_byte(note, "note"),
+        data_byte(pressure, "pressure")
+      ])
+    end
+
+    def time_code_quarter_frame(message_type, value)
+      send_message(Rtmidi::Message::TimeCodeQuarterFrame.new(message_type: message_type, value: value))
+    end
+
+    def song_position_pointer(position)
+      send_message(Rtmidi::Message::SongPositionPointer.new(position: position))
+    end
+
+    def song_select(song)
+      send_message(Rtmidi::Message::SongSelect.new(song: song))
+    end
+
+    def tune_request
+      send_message(Rtmidi::Message::TuneRequest.new)
+    end
+
+    def timing_clock
+      send_message(Rtmidi::Message::TimingClock.new)
+    end
+
+    def start
+      send_message(Rtmidi::Message::Start.new)
+    end
+
+    def continue
+      send_message(Rtmidi::Message::Continue.new)
+    end
+
+    def stop
+      send_message(Rtmidi::Message::Stop.new)
+    end
+
+    def active_sensing
+      send_message(Rtmidi::Message::ActiveSensing.new)
+    end
+
+    def system_reset
+      send_message(Rtmidi::Message::SystemReset.new)
+    end
+
+    def nrpn(channel, parameter, value)
+      parameter_number = normalize_range(parameter, 0, 16_383, "parameter")
+      data_value = normalize_range(value, 0, 16_383, "value")
+
+      control_change(channel, 99, (parameter_number >> 7) & 0x7F)
+      control_change(channel, 98, parameter_number & 0x7F)
+      control_change(channel, 6, (data_value >> 7) & 0x7F)
+      control_change(channel, 38, data_value & 0x7F)
+      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 @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 normalize_message(message)
+      Rtmidi::Message.serialize(message)
+    end
+
+    def status_byte(base, channel)
+      base | normalize_range(channel, 0, 15, "channel")
+    end
+
+    def data_byte(value, label)
+      normalize_range(value, 0, 127, label)
+    end
+
+    def normalize_range(value, min, max, label)
+      integer = integer_for(value, label)
+      return integer if integer >= min && integer <= max
+
+      raise ArgumentError, "#{label} must be within #{min}..#{max}"
+    end
+
+    def integer_for(value, label)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "#{label} must be an Integer"
+    end
+  end
+end

data/lib/rtmidi/native.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Rtmidi
+  module Native
+    extend FFI::Library
+
+    LOAD_ERROR_MESSAGE = <<~MSG.freeze
+      librtmidi が見つかりません。
+      macOS:         brew install rtmidi
+      Ubuntu/Debian: sudo apt install librtmidi-dev
+      環境変数 RTMIDI_LIB_PATH でパスを指定することもできます。
+    MSG
+
+    DEFAULT_LIBRARIES = [
+      "rtmidi",
+      "librtmidi",
+      "librtmidi.so.7",
+      "librtmidi.so",
+      "librtmidi.dylib",
+      "/opt/homebrew/lib/librtmidi.dylib",
+      "/usr/local/lib/librtmidi.dylib",
+      "rtmidi.dll",
+      "librtmidi.dll"
+    ].freeze
+
+    class Wrapper < FFI::Struct
+      layout :ptr, :pointer,
+             :data, :pointer,
+             :ok, :bool,
+             :msg, :pointer
+    end
+
+    enum :rtmidi_api, [
+      :unspecified, 0,
+      :macosx_core, 1,
+      :linux_alsa, 2,
+      :unix_jack, 3,
+      :windows_mm, 4,
+      :rtmidi_dummy, 5,
+      :web_midi_api, 6,
+      :windows_uwp, 7,
+      :android_amidi, 8,
+      :num_apis, 9
+    ]
+
+    enum :rtmidi_error_type, [
+      :warning, 0,
+      :debug_warning, 1,
+      :unspecified, 2,
+      :no_devices_found, 3,
+      :invalid_device, 4,
+      :memory_error, 5,
+      :invalid_parameter, 6,
+      :invalid_use, 7,
+      :driver_error, 8,
+      :system_error, 9,
+      :thread_error, 10
+    ]
+
+    callback :rtmidi_c_callback, [:double, :pointer, :size_t, :pointer], :void
+    callback :rtmidi_error_c_callback, [:rtmidi_error_type, :string, :pointer], :void
+
+    FUNCTION_SIGNATURES = {
+      rtmidi_get_version: [[], :string],
+      rtmidi_get_compiled_api: [[:pointer, :uint], :int],
+      rtmidi_api_name: [[:rtmidi_api], :string],
+      rtmidi_api_display_name: [[:rtmidi_api], :string],
+      rtmidi_compiled_api_by_name: [[:string], :rtmidi_api],
+      rtmidi_open_port: [[:pointer, :uint, :string], :void],
+      rtmidi_open_virtual_port: [[:pointer, :string], :void],
+      rtmidi_close_port: [[:pointer], :void],
+      rtmidi_get_port_count: [[:pointer], :uint],
+      rtmidi_get_port_name: [[:pointer, :uint, :pointer, :pointer], :int],
+      rtmidi_set_error_callback: [[:pointer, :rtmidi_error_c_callback, :pointer], :void],
+      rtmidi_in_create_default: [[], :pointer],
+      rtmidi_in_create: [[:rtmidi_api, :string, :uint], :pointer],
+      rtmidi_in_free: [[:pointer], :void],
+      rtmidi_in_get_current_api: [[:pointer], :rtmidi_api],
+      rtmidi_in_set_callback: [[:pointer, :rtmidi_c_callback, :pointer], :void],
+      rtmidi_in_cancel_callback: [[:pointer], :void],
+      rtmidi_in_ignore_types: [[:pointer, :bool, :bool, :bool], :void],
+      rtmidi_in_get_message: [[:pointer, :pointer, :pointer], :double],
+      rtmidi_out_create_default: [[], :pointer],
+      rtmidi_out_create: [[:rtmidi_api, :string], :pointer],
+      rtmidi_out_free: [[:pointer], :void],
+      rtmidi_out_get_current_api: [[:pointer], :rtmidi_api],
+      rtmidi_out_send_message: [[:pointer, :pointer, :int], :int]
+    }.freeze
+
+    OPTIONAL_FUNCTIONS = [
+      :rtmidi_set_error_callback
+    ].freeze
+
+    @loaded = false
+    @load_error = nil
+    @available_functions = [].freeze
+
+    class << self
+      def loaded?
+        @loaded
+      end
+
+      def ensure_loaded!
+        return if loaded?
+
+        raise @load_error || LoadError, LOAD_ERROR_MESSAGE
+      end
+
+      def read_size_t(pointer)
+        if FFI::Platform::ADDRESS_SIZE == 64
+          pointer.get_uint64(0)
+        else
+          pointer.get_uint32(0)
+        end
+      end
+
+      def write_size_t(pointer, value)
+        if FFI::Platform::ADDRESS_SIZE == 64
+          pointer.put_uint64(0, value)
+        else
+          pointer.put_uint32(0, value)
+        end
+      end
+
+      def check_error(device_ptr)
+        ensure_loaded!
+        return if device_ptr.nil? || device_ptr.null?
+
+        wrapper = Wrapper.new(device_ptr)
+        return if wrapper[:ok]
+
+        msg_ptr = wrapper[:msg]
+        message = msg_ptr.nil? || msg_ptr.null? ? "Unknown RtMidi error" : msg_ptr.read_string
+        raise Rtmidi::Error, message
+      end
+
+      def function_available?(name)
+        @available_functions.include?(name.to_sym)
+      end
+
+      private
+
+      def library_candidates
+        candidates = []
+        lib_path = ENV["RTMIDI_LIB_PATH"]
+        candidates << lib_path unless lib_path.nil? || lib_path.empty?
+        candidates.concat(DEFAULT_LIBRARIES)
+        candidates.uniq
+      end
+
+      def load_error_with_original(error)
+        LoadError.new("#{LOAD_ERROR_MESSAGE}\nOriginal error: #{error.message}")
+      end
+    end
+
+    begin
+      ffi_lib(library_candidates)
+      @loaded = true
+    rescue LoadError => e
+      @loaded = false
+      @load_error = load_error_with_original(e)
+    end
+
+    if @loaded
+      begin
+        available_functions = []
+
+        FUNCTION_SIGNATURES.each do |name, signature|
+          attach_function(name, signature[0], signature[1])
+          available_functions << name
+        rescue FFI::NotFoundError => e
+          raise e unless OPTIONAL_FUNCTIONS.include?(name)
+        end
+
+        @available_functions = available_functions.freeze
+        (OPTIONAL_FUNCTIONS - available_functions).each do |name|
+          define_singleton_method(name) do |*_args|
+            raise NotImplementedError, "RtMidi function #{name} is not available in the loaded librtmidi"
+          end
+        end
+      rescue FFI::NotFoundError => e
+        @loaded = false
+        @available_functions = [].freeze
+        @load_error = load_error_with_original(e)
+      end
+    end
+
+    unless @loaded
+      FUNCTION_SIGNATURES.each_key do |name|
+        define_singleton_method(name) do |*_args|
+          ensure_loaded!
+        end
+      end
+    end
+  end
+end

data/lib/rtmidi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rtmidi
+  VERSION = "0.1.0"
+end

data/lib/rtmidi.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "rtmidi/version"
+require_relative "rtmidi/error"
+require_relative "rtmidi/message"
+require_relative "rtmidi/native"
+require_relative "rtmidi/api"
+require_relative "rtmidi/midi_out"
+require_relative "rtmidi/midi_in"

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: rtmidi-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Complete Ruby bindings for RtMidi C API using FFI, including Ruby-idiomatic
+  MidiIn/MidiOut wrappers for realtime MIDI on macOS, Linux, and Windows.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/list_ports.rb
+- examples/receive_callback.rb
+- examples/receive_polling.rb
+- examples/send_note.rb
+- examples/sysex_send.rb
+- examples/virtual_port.rb
+- lib/rtmidi.rb
+- lib/rtmidi/api.rb
+- lib/rtmidi/error.rb
+- lib/rtmidi/message.rb
+- lib/rtmidi/midi_in.rb
+- lib/rtmidi/midi_out.rb
+- lib/rtmidi/native.rb
+- lib/rtmidi/version.rb
+homepage: https://github.com/ydah/mtmidi
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/ydah/mtmidi
+  changelog_uri: https://github.com/ydah/mtmidi/blob/main/CHANGELOG.md
+  documentation_uri: https://rubydoc.info/gems/rtmidi-ruby
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby FFI bindings for RtMidi with high-level MIDI I/O API
+test_files: []