ffi-coremidi 0.1.7

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2011 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.rdoc

@@ -0,0 +1,48 @@
+= ffi-coremidi
+
+== Summary
+
+Realtime MIDI IO with Ruby for OSX
+
+Note that in the interest of allowing people on other platforms to utilize your code, you should consider using {unimidi}[http://github.com/arirusso/unimidi].  Unimidi is a platform independent wrapper that implements this library and has a similar API.
+
+== Features
+
+* Simplified API
+* Input and output on multiple devices concurrently
+* Agnostically handle different MIDI Message types (including SysEx)
+* Timestamped input events
+* Internally patch MIDI to other programs using IAC (and {MIDI Patch Bay}[http://notahat.com/midi_patchbay] if you're using OSX Snow Leopard or earlier)
+== Requirements
+
+* {ffi}[http://github.com/ffi/ffi] (gem install ffi)
+
+== Install
+
+  gem install ffi-coremidi
+  
+== Documentation
+
+* {rdoc}[http://rubydoc.info/github/arirusso/ffi-coremidi]
+
+== Author
+
+* {Ari Russo}[http://github.com/arirusso] <ari.russo at gmail.com>
+
+== Credits
+
+This library began with some coremidi/ffi binding code for MIDI output by
+
+* Colin Harris -- http://github.com/aberant
+
+contained in {his fork of MIDIator}[http://github.com/aberant/midiator] and a {blog post}[http://aberant.tumblr.com/post/694878119/sending-midi-sysex-with-core-midi-and-ruby-ffi]
+
+{MIDIator}[http://github.com/bleything/midiator] is (c)2008 by Ben Bleything and Topher Cyll and released under the MIT license (see LICENSE.midiator and LICENSE.prp)
+
+Also thank you to {Jeremy Voorhis}[http://github.com/jvoorhis] for some useful debugging
+
+== License
+
+Apache 2.0, See the file LICENSE
+
+Copyright (c) 2011 Ari Russo

data/lib/coremidi.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+#
+# ffi-coremidi
+# Realtime MIDI IO with Ruby for OSX
+# (c)2011 Ari Russo
+# 
+
+# libs
+require 'ffi'
+require 'forwardable'
+
+# modules
+require 'coremidi/endpoint'
+require 'coremidi/map'
+
+# classes
+require 'coremidi/entity'
+require 'coremidi/device'
+require 'coremidi/source'
+require 'coremidi/destination'
+
+module CoreMIDI
+  VERSION = "0.1.7"
+end

data/lib/coremidi/destination.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+
+module CoreMIDI
+
+  #
+  # Output/Destination endpoint class
+  #
+  class Destination
+
+    include Endpoint
+
+    # close this output
+    def close
+      #error = Map.MIDIClientDispose(@handle)
+      #raise "MIDIClientDispose returned error code #{error}" unless error.zero?
+      #error = Map.MIDIPortDispose(@handle)
+      #raise "MIDIPortDispose returned error code #{error}" unless error.zero?
+      #error = Map.MIDIEndpointDispose(@resource)
+      #raise "MIDIEndpointDispose returned error code #{error}" unless error.zero?
+      @enabled = false
+
+    end
+
+    # sends a MIDI message comprised of a String of hex digits
+    def puts_s(data)
+      data = data.dup
+	    output = []
+      until (str = data.slice!(0,2)).eql?("")
+      	output << str.hex
+      end
+      puts_bytes(*output)
+    end
+    alias_method :puts_bytestr, :puts_s
+    alias_method :puts_hex, :puts_s
+
+    # sends a MIDI messages comprised of Numeric bytes
+    def puts_bytes(*data)
+
+      format = "C" * data.size
+      bytes = (FFI::MemoryPointer.new FFI.type_size(:char) * data.size)
+      bytes.write_string(data.pack(format))
+
+      if data.first.eql?(0xF0) && data.last.eql?(0xF7)
+        puts_sysex(bytes, data.size)
+      else
+        puts_small(bytes, data.size)
+      end
+    end
+
+    # send a MIDI message of an indeterminant type
+    def puts(*a)
+  	  case a.first
+        when Array then puts_bytes(*a.first)
+    	  when Numeric then puts_bytes(*a)
+    	  when String then puts_bytestr(*a)
+      end
+    end
+    alias_method :write, :puts
+
+    # enable this device; also takes a block
+    def enable(options = {}, &block)
+      #connect
+      @enabled = true
+      unless block.nil?
+      	begin
+      		yield(self)
+      	ensure
+      		close
+      	end
+      else
+        self
+      end
+    end
+    alias_method :open, :enable
+    alias_method :start, :enable
+
+    # shortcut to the first output endpoint available
+    def self.first
+      Endpoint.first(:destination)
+    end
+    
+    # shortcut to the last output endpoint available
+    def self.last
+      Endpoint.last(:destination)
+    end
+
+    # all output endpoints
+    def self.all
+      Endpoint.all_by_type[:destination]
+    end
+    
+    protected
+
+    # base initialization for this endpoint -- done whether or not the endpoint is enabled to
+    # check whether it is truly available for use
+    def connect
+      client_error = enable_client
+      port_error = initialize_port
+
+      @resource = Map.MIDIEntityGetDestination( @entity.resource, @resource_id )
+      !@resource.address.zero? && client_error.zero? && port_error.zero?
+    end
+    alias_method :connect?, :connect
+
+    private
+
+    # output a short MIDI message
+    def puts_small(bytes, size)
+      packet_list = FFI::MemoryPointer.new(256)
+      packet_ptr = Map.MIDIPacketListInit(packet_list)
+
+      if Map::SnowLeopard
+        packet_ptr = Map.MIDIPacketListAdd(packet_list, 256, packet_ptr, 0, size, bytes)
+      else
+        # Pass in two 32-bit 0s for the 64 bit time
+        packet_ptr = Map.MIDIPacketListAdd(packet_list, 256, packet_ptr, 0, 0, size, bytes)
+      end
+
+      Map.MIDISend( @handle, @resource, packet_list )
+    end
+
+    # output a System Exclusive MIDI message
+    def puts_sysex(bytes, size)
+
+      request = Map::MIDISysexSendRequest.new
+      request[:destination] = @resource
+      request[:data] = bytes
+      request[:bytes_to_send] = size
+      request[:complete] = 0
+      request[:completion_proc] = SysexCompletionCallback
+      request[:completion_ref_con] = request
+
+      Map.MIDISendSysex(request)
+    end
+
+    SysexCompletionCallback =
+      FFI::Function.new(:void, [:pointer]) do |sysex_request_ptr|
+        p 'hi'
+        # this isn't working for some reason
+        # as of now, we don't need it though
+      end
+      
+    # initialize a coremidi port for this endpoint
+    def initialize_port
+      port_name = Map::CF.CFStringCreateWithCString(nil, "Port #{@resource_id}: #{name}", 0)
+      outport_ptr = FFI::MemoryPointer.new(:pointer)
+      error = Map.MIDIOutputPortCreate(@client, port_name, outport_ptr)
+      @handle = outport_ptr.read_pointer
+      error
+    end
+
+  end
+
+end

data/lib/coremidi/device.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+module CoreMIDI
+
+  class Device
+
+    attr_reader :entities,
+                # unique Numeric id
+                :id,
+                # device name from coremidi
+                :name
+
+    def initialize(id, device_pointer, options = {})
+      include_if_offline = options[:include_offline] || false
+      @id = id
+      @resource = device_pointer
+      @entities = []
+      
+      prop = Map::CF.CFStringCreateWithCString( nil, "name", 0 )
+      name = Map::CF.CFStringCreateWithCString( nil, id.to_s, 0 )
+      Map::MIDIObjectGetStringProperty(@resource, prop, name)
+
+      @name = Map::CF.CFStringGetCStringPtr(name.read_pointer, 0).read_string
+      populate_entities(:include_offline => include_if_offline)
+    end
+    
+    # returns all devices which are cached in an instance variable @devices on the Device class
+    #
+    # options:
+    # 
+    # * <b>cache</b>: if false, the device list will never be cached. this would be useful if one needs to alter the device list (e.g. plug in a USB MIDI interface) while their program is running.
+    # * <b>include_offline</b>: if true, devices marked offline by coremidi will be included in the list
+    #
+    def self.all(options = {})
+      use_cache = options[:cache] || true
+      include_offline = options[:include_offline] || false
+      if @devices.nil? || @devices.empty? || !use_cache
+        @devices = []
+        i = 0
+        while !(device_pointer = Map.MIDIGetDevice(i)).null?
+          device = new(i, device_pointer, :include_offline => include_offline)
+          @devices << device
+          i+=1
+        end
+        populate_endpoint_ids
+      end
+      @devices
+    end
+    
+    # Refresh the Device cash.  You'll need to do this if, for instance, you plug in
+    # a USB MIDI device while the program is running 
+    def self.refresh
+      @devices.clear
+    end
+    
+    # returns all of the Endpoints for this device
+    def endpoints
+      endpoints = { :source => [], :destination => [] }
+      endpoints.keys.each do |k|
+        endpoints[k] += entities.map { |entity| entity.endpoints[k] }.flatten
+      end
+      endpoints
+    end
+    
+    # assign all of this Device's endpoints an consecutive local id
+    def populate_endpoint_ids(starting_id)
+      i = 0
+      entities.each_with_index { |entity| i += entity.populate_endpoint_ids(i + starting_id) }
+      i
+    end
+
+    private
+    
+    # gives all of the endpoints for all devices a consecutive local id
+    def self.populate_endpoint_ids
+      i = 0
+      all.each { |device| i += device.populate_endpoint_ids(i) }
+    end
+
+    # populates the entities for this device. these are in turn used to gather the endpoints
+    def populate_entities(options = {})
+      include_if_offline = options[:include_offline] || false
+      i = 0
+      while !(entity_pointer = Map.MIDIDeviceGetEntity(@resource, i)).null?
+        @entities << Entity.new(entity_pointer, :include_offline => include_if_offline)
+        i += 1
+      end
+    end
+
+  end
+
+end

data/lib/coremidi/endpoint.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+module CoreMIDI
+
+  module Endpoint
+    
+    extend Forwardable
+
+                # has the endpoint been initialized?
+    attr_reader :enabled,
+                :entity,
+                # unique local Numeric id of the endpoint
+                :id,
+                :resource_id,
+                # :input or :output
+                :type
+                
+    def_delegators :entity, :manufacturer, :model, :name
+
+    alias_method :enabled?, :enabled
+
+    def initialize(resource_id, entity, options = {}, &block)
+      @entity = entity
+      @resource_id = resource_id
+      @type = self.class.name.split('::').last.downcase.to_sym
+      @enabled = false
+    end
+    
+    # is this endpoint online?
+    def online?
+      @entity.online? && connect?
+    end
+    
+    # sets the id for this endpoint (the id is immutable once its set)
+    def id=(val)
+      @id ||= val
+    end
+
+    # select the first endpoint of type <em>type</em>
+    def self.first(type)
+      all_by_type[type].first
+    end
+
+    # select the last endpoint of type <em>type</em>
+    def self.last(type)
+      all_by_type[type].last
+    end
+
+    # a Hash of :source and :destination endpoints
+    def self.all_by_type
+      {
+        :source => Device.all.map { |d| d.endpoints[:source] }.flatten,
+        :destination => Device.all.map { |d| d.endpoints[:destination] }.flatten
+      }
+    end
+
+    # all endpoints of both types
+    def self.all
+      Device.all.map { |d| d.endpoints }.flatten
+    end
+    
+    protected
+    
+    # enables the coremidi MIDI client that will go with this endpoint
+    def enable_client
+      client_name = Map::CF.CFStringCreateWithCString( nil, "Client #{@resource_id} #{name}", 0 )
+      client_ptr = FFI::MemoryPointer.new(:pointer)
+      error = Map.MIDIClientCreate(client_name, nil, nil, client_ptr)
+      @client = client_ptr.read_pointer
+      error
+    end
+
+  end
+
+end

data/lib/coremidi/entity.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+module CoreMIDI
+
+  class Entity
+
+    attr_reader :endpoints, 
+                :is_online,
+                :manufacturer,
+                :model,
+                :name,
+                :resource
+                
+    alias_method :online?, :is_online
+
+    def initialize(resource, options = {}, &block)
+      @endpoints = { :source => [], :destination => [] }
+      @resource = resource
+      @manufacturer = get_property(:manufacturer)
+      @model = get_property(:model)
+      @name = "#{@manufacturer} #{@model}"
+      @is_online = get_property(:offline, :type => :int) == 0
+      @endpoints.keys.each { |type| populate_endpoints(type) }
+    end
+    
+    # assign all of this Entity's endpoints an consecutive local id
+    def populate_endpoint_ids(starting_id)
+      i = 0
+      @endpoints.values.flatten.each do |e|  
+        e.id = (i + starting_id)
+        i += 1
+      end
+      i
+    end
+    
+    private
+    
+    # populate endpoints of <em>type</em> for this entity
+    def populate_endpoints(type, options = {})
+      include_if_offline = options[:include_offline] || false
+      endpoint_class = case type
+        when :source then Source
+        when :destination then Destination
+      end  
+      num_endpoints = number_of_endpoints(type)
+      (0..num_endpoints).each do |i|
+        ep = endpoint_class.new(i, self)
+        @endpoints[type] << ep if ep.online? || include_if_offline
+      end  
+      @endpoints[type].size   
+    end
+    
+    # gets the number of endpoints for this entity
+    def number_of_endpoints(type)
+      case type
+        when :source then Map.MIDIEntityGetNumberOfSources(@resource)
+        when :destination then Map.MIDIEntityGetNumberOfDestinations(@resource)
+      end
+    end
+    
+    # gets a CFString property
+    def get_string(name, pointer)
+      prop = Map::CF.CFStringCreateWithCString( nil, name.to_s, 0 )
+      val = Map::CF.CFStringCreateWithCString( nil, name.to_s, 0 ) # placeholder
+      Map::MIDIObjectGetStringProperty(pointer, prop, val)
+      Map::CF.CFStringGetCStringPtr(val.read_pointer, 0).read_string rescue nil
+    end
+    
+    # gets an Integer property
+    def get_int(name, pointer)
+      prop = Map::CF.CFStringCreateWithCString( nil, name.to_s, 0 )
+      val = FFI::MemoryPointer.new(:pointer, 32)
+      Map::MIDIObjectGetIntegerProperty(pointer, prop, val)
+      val.read_int
+    end        
+
+    # gets a CString or Integer property from this Endpoint's entity
+    def get_property(name, options = {})
+      from = options[:from] || @resource
+      type = options[:type] || :string
+      
+      case type
+        when :string then get_string(name, from)
+        when :int then get_int(name, from)
+      end
+    end
+
+  end
+
+end

data/lib/coremidi/map.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+module CoreMIDI
+
+  #
+  # coremidi binding
+  #
+  #
+  module Map
+
+    extend FFI::Library
+    ffi_lib '/System/Library/Frameworks/CoreMIDI.framework/Versions/Current/CoreMIDI'
+
+    SnowLeopard = `uname -r`.scan(/\d*\.\d*/).first.to_f >= 10.6
+
+    typedef :pointer, :CFStringRef
+    typedef :int32, :ItemCount
+    typedef :pointer, :MIDIClientRef
+    typedef :pointer, :MIDIDeviceRef
+    typedef :pointer, :MIDIEndpointRef
+    typedef :pointer, :MIDIEntityRef
+    typedef :pointer, :MIDIObjectRef
+    typedef :pointer, :MIDIPortRef
+    #typedef :pointer, :MIDIReadProc
+    typedef :uint32, :MIDITimeStamp
+    typedef :int32, :OSStatus
+
+    class MIDISysexSendRequest < FFI::Struct
+
+      layout :destination,         :MIDIEndpointRef,
+             :data,                :pointer,
+             :bytes_to_send,       :uint32,
+             :complete,            :int,
+             :reserved,            [:char, 3],
+             :completion_proc,     :pointer,
+             :completion_ref_con,  :pointer
+    end
+
+    class MIDIPacket < FFI::Struct
+
+      layout :timestamp, :MIDITimeStamp,
+             :nothing, :uint32, # no idea...
+             :length, :uint16,
+             :data, [:uint8, 256]
+
+    end
+
+    class MIDIPacketList < FFI::Struct
+      layout :numPackets, :uint32,
+             :packet, [MIDIPacket.by_value, 1]
+
+    end
+
+    callback :MIDIReadProc, [MIDIPacketList.by_ref, :pointer, :pointer], :pointer
+
+    attach_function :MIDIClientCreate, [:pointer, :pointer, :pointer, :pointer], :int
+
+    attach_function :MIDIClientDispose, [:pointer], :int
+
+    # MIDIEntityRef MIDIDeviceGetEntity (MIDIDeviceRef  device, ItemCount entityIndex0);
+    attach_function :MIDIDeviceGetEntity, [:MIDIDeviceRef, :ItemCount], :MIDIEntityRef
+
+    attach_function :MIDIGetNumberOfDestinations, [], :ItemCount
+
+    attach_function :MIDIGetNumberOfDevices, [], :ItemCount
+
+    attach_function :MIDIGetDestination, [:int], :pointer
+    
+    #extern OSStatus MIDIEndpointDispose( MIDIEndpointRef endpt );
+    attach_function :MIDIEndpointDispose, [:MIDIEndpointRef], :OSStatus
+
+    # MIDIEndpointRef MIDIEntityGetDestination( MIDIEntityRef entity, ItemCount destIndex0 );
+    attach_function :MIDIEntityGetDestination, [:MIDIEntityRef, :int], :MIDIEndpointRef
+
+    # ItemCount MIDIEntityGetNumberOfDestinations (MIDIEntityRef  entity);
+    attach_function :MIDIEntityGetNumberOfDestinations, [:MIDIEntityRef], :ItemCount
+
+    # ItemCount MIDIEntityGetNumberOfSources (MIDIEntityRef  entity);
+    attach_function :MIDIEntityGetNumberOfSources, [:MIDIEntityRef], :ItemCount
+
+    # MIDIEndpointRef MIDIEntityGetSource (MIDIEntityRef  entity, ItemCount sourceIndex0);
+    attach_function :MIDIEntityGetSource, [:MIDIEntityRef, :ItemCount], :MIDIEndpointRef
+
+    attach_function :MIDIGetDevice, [:ItemCount], :MIDIDeviceRef
+    
+    # extern OSStatus MIDIInputPortCreate( MIDIClientRef client, CFStringRef portName, MIDIReadProc readProc, void * refCon, MIDIPortRef * outPort );
+    attach_function :MIDIInputPortCreate, [:MIDIClientRef, :CFStringRef, :MIDIReadProc, :pointer, :MIDIPortRef], :OSStatus
+
+    # extern OSStatus MIDIObjectGetIntegerProperty( MIDIObjectRef obj, CFStringRef propertyID, SInt32 * outValue );
+    attach_function :MIDIObjectGetIntegerProperty, [:MIDIObjectRef, :CFStringRef, :pointer], :OSStatus
+    # OSStatus MIDIObjectGetStringProperty (MIDIObjectRef  obj, CFStringRef propertyID, CFStringRef *str);
+    attach_function :MIDIObjectGetStringProperty, [:MIDIObjectRef, :CFStringRef, :pointer], :OSStatus
+                                                                                                                    \
+    # extern OSStatus MIDIOutputPortCreate( MIDIClientRef client, CFStringRef portName, MIDIPortRef * outPort );
+    attach_function :MIDIOutputPortCreate, [:MIDIClientRef, :CFStringRef, :pointer], :int
+
+    attach_function :MIDIPacketListInit, [:pointer], :pointer
+
+    #extern OSStatus MIDIPortConnectSource( MIDIPortRef port, MIDIEndpointRef source, void * connRefCon )
+    attach_function :MIDIPortConnectSource, [:MIDIPortRef, :MIDIEndpointRef, :pointer], :OSStatus
+
+    #extern OSStatus MIDIPortDisconnectSource( MIDIPortRef port, MIDIEndpointRef source );
+    attach_function :MIDIPortDisconnectSource, [:MIDIPortRef, :MIDIEndpointRef], :OSStatus
+
+    #extern OSStatus MIDIPortDispose(MIDIPortRef port );
+    attach_function :MIDIPortDispose, [:MIDIPortRef], :OSStatus
+
+    #extern OSStatus MIDISend(MIDIPortRef port,MIDIEndpointRef dest,const MIDIPacketList *pktlist);
+    attach_function :MIDISend, [:MIDIPortRef, :MIDIEndpointRef, :pointer], :int
+
+    attach_function :MIDISendSysex, [:pointer], :int
+
+    if SnowLeopard
+      attach_function :MIDIPacketListAdd, [:pointer, :int, :pointer, :int, :int, :pointer], :pointer
+    else
+      # extern MIDIPacket * MIDIPacketListAdd( MIDIPacketList * pktlist, ByteCount listSize, MIDIPacket * curPacket, MIDITimeStamp time, ByteCount nData, const Byte * data)
+      attach_function :MIDIPacketListAdd, [:pointer, :int, :pointer, :int, :int, :int, :pointer], :pointer
+    end
+
+    module CF
+
+      extend FFI::Library
+      ffi_lib '/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation'
+
+      # CFString* CFStringCreateWithCString( ?, CString, encoding)
+      attach_function :CFStringCreateWithCString, [:pointer, :string, :int], :pointer
+      # CString* CFStringGetCStringPtr(CFString*, encoding)
+      attach_function :CFStringGetCStringPtr, [:pointer, :int], :pointer
+
+    end
+
+    module HostTime
+      extend FFI::Library
+      ffi_lib '/System/Library/Frameworks/CoreAudio.framework/Versions/Current/CoreAudio'
+
+      attach_function :AudioConvertHostTimeToNanos, [:uint64], :uint64
+    end
+
+  end
+
+end

data/lib/coremidi/source.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+
+module CoreMIDI
+
+  #
+  # Input/Source endpoint class
+  #
+  class Source
+
+    include Endpoint
+    
+    attr_reader :buffer
+
+    #
+    # returns an array of MIDI event hashes as such:
+    #   [
+    #     { :data => [144, 60, 100], :timestamp => 1024 },
+    #     { :data => [128, 60, 100], :timestamp => 1100 },
+    #     { :data => [144, 40, 120], :timestamp => 1200 }
+    #   ]
+    #
+    # the data is an array of Numeric bytes
+    # the timestamp is the number of millis since this input was enabled
+    #
+    def gets
+      until queued_messages?
+      end
+      msgs = queued_messages
+      @pointer = @buffer.length
+      msgs
+    end
+    alias_method :read, :gets
+
+    # same as gets but returns message data as string of hex digits as such:
+    #   [
+    #     { :data => "904060", :timestamp => 904 },
+    #     { :data => "804060", :timestamp => 1150 },
+    #     { :data => "90447F", :timestamp => 1300 }
+    #   ]
+    #
+    #
+    def gets_s
+      msgs = gets
+      msgs.each { |msg| msg[:data] = numeric_bytes_to_hex_string(msg[:data]) }
+      msgs
+    end
+    alias_method :gets_bytestr, :gets_s
+
+    # enable this the input for use; can be passed a block
+    def enable(options = {}, &block)
+      @enabled = true
+
+      unless block.nil?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      else
+        self
+      end
+    end
+    alias_method :open, :enable
+    alias_method :start, :enable
+
+    # close this input
+    def close
+      #error = Map.MIDIPortDisconnectSource( @handle, @resource )
+      #raise "MIDIPortDisconnectSource returned error code #{error}" unless error.zero?
+      #error = Map.MIDIClientDispose(@handle)
+      #raise "MIDIClientDispose returned error code #{error}" unless error.zero?
+      #error = Map.MIDIPortDispose(@handle)
+      #raise "MIDIPortDispose returned error code #{error}" unless error.zero?
+      #error = Map.MIDIEndpointDispose(@resource)
+      #raise "MIDIEndpointDispose returned error code #{error}" unless error.zero?
+      @enabled = false
+    end
+
+    # shortcut to the first available input endpoint
+    def self.first
+      Endpoint.first(:source)
+    end
+
+    # shortcut to the last available input endpoint
+    def self.last
+      Endpoint.last(:source)
+    end
+
+    # all input endpoints
+    def self.all
+      Endpoint.all_by_type[:source]
+    end
+    
+    protected
+    
+    # base initialization for this endpoint -- done whether or not the endpoint is enabled to
+    # check whether it is truly available for use
+    def connect   
+      enable_client
+      initialize_port
+      @resource = Map.MIDIEntityGetSource(@entity.resource, @resource_id)
+      error = Map.MIDIPortConnectSource(@handle, @resource, nil )
+      initialize_buffer
+      @sysex_buffer = []
+      @start_time = Time.now.to_f
+
+      error.zero?
+    end
+    alias_method :connect?, :connect
+
+    private
+
+    # returns new MIDI messages from the queue
+    def queued_messages
+      @buffer.slice(@pointer, @buffer.length - @pointer)
+    end
+
+    # are there new MIDI messages in the queue?
+    def queued_messages?
+      @pointer < @buffer.length
+    end
+
+    # the callback which is called by coremidi when new MIDI messages are in the buffer
+    def get_event_callback
+      Proc.new do | new_packets, refCon_ptr, connRefCon_ptr |
+        time = Time.now.to_f
+        packet = new_packets[:packet][0]
+        len = packet[:length]
+        #p "packets received: #{new_packets[:numPackets]}"
+        #p "first packet length: #{len} data: #{packet[:data].to_a.to_s}"
+        if len > 0
+          bytes = packet[:data].to_a[0, len]
+          if bytes.first.eql?(0xF0) || !@sysex_buffer.empty?
+            @sysex_buffer += bytes
+            if bytes.last.eql?(0xF7)
+              bytes = @sysex_buffer.dup
+              @sysex_buffer.clear
+            end
+          end
+          @buffer << get_message_formatted(bytes, time) if @sysex_buffer.empty?             
+        end
+      end
+    end
+
+    # timestamp
+    def timestamp(now)
+      ((now - @start_time) * 1000)
+    end
+
+    # give a message its timestamp and package it in a Hash
+    def get_message_formatted(raw, time)
+      { :data => raw, :timestamp => timestamp(time) }
+    end
+
+    # initialize a coremidi port for this endpoint
+    def initialize_port
+      port_name = Map::CF.CFStringCreateWithCString(nil, "Port #{@resource_id}: #{name}", 0)
+      handle_ptr = FFI::MemoryPointer.new(:pointer)
+      @callback = get_event_callback
+      error = Map.MIDIInputPortCreate(@client, port_name, @callback, nil, handle_ptr)
+      @handle = handle_ptr.read_pointer
+      raise "MIDIInputPortCreate returned error code #{error}" unless error.zero?
+    end
+    
+    # initialize the MIDI message buffer
+    def initialize_buffer
+      @pointer = 0
+      @buffer = []
+      def @buffer.clear
+        super
+        @pointer = 0
+      end     
+    end
+    
+    # convert an array of numeric byes to a hex string
+    # e.g.
+    # [0x90, 0x40, 0x40] -> "904040"
+    def numeric_bytes_to_hex_string(bytes)
+      bytes.map { |b| s = b.to_s(16).upcase; b < 16 ? s = "0" + s : s; s }.join
+    end 
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'test/unit'
+require 'coremidi'
+
+module TestHelper
+  
+  def self.select_devices
+    $test_device ||= {}
+    { :input => CoreMIDI::Source.all, :output => CoreMIDI::Destination.all }.each do |type, devs|
+      puts ""
+      puts "select an #{type.to_s}..."
+      while $test_device[type].nil?
+        devs.each do |device|
+          puts "#{device.id}: #{device.name}"
+        end
+        selection = $stdin.gets.chomp
+        if selection != ""
+          selection = selection.to_i
+          $test_device[type] = devs.find { |d| d.id == selection }
+          puts "selected #{selection} for #{type.to_s}" unless $test_device[type]
+        end
+      end
+    end
+  end 
+	    
+  def bytestrs_to_ints(arr)
+    data = arr.map { |m| m[:data] }.join
+      output = []
+      until (bytestr = data.slice!(0,2)).eql?("")
+        output << bytestr.hex
+      end
+    output    	
+  end
+    
+  # some MIDI messages
+  VariousMIDIMessages = [
+    [0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7], # SysEx
+    [0x90, 100, 100], # note on
+    [0x90, 43, 100], # note on
+    [0x90, 76, 100], # note on
+    [0x90, 60, 100], # note on
+    [0x80, 100, 100] # note off
+  ]
+    
+  # some MIDI messages
+  VariousMIDIByteStrMessages = [
+    "F04110421240007F0041F7", # SysEx
+    "906440", # note on
+    "804340" # note off
+  ]
+    
+end
+
+TestHelper.select_devices

data/test/test_input_buffer.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class InputBufferTest < Test::Unit::TestCase
+
+  include CoreMIDI
+  include TestHelper
+
+  def test_input_buffer
+    sleep(1)
+
+    messages = VariousMIDIMessages
+    bytes = []
+
+    $test_device[:output].open do |output|
+      $test_device[:input].open do |input|
+        
+        input.buffer.clear
+
+        messages.each do |msg|
+
+          $>.puts "sending: " + msg.inspect
+
+          output.puts(msg)
+          
+          bytes += msg 
+          
+          sleep(0.5)
+          
+          buffer = input.buffer.map { |m| m[:data] }.flatten
+
+          $>.puts "received: " + buffer.to_s
+          
+          assert_equal(bytes, buffer)
+
+        end
+        
+        assert_equal(bytes.length, input.buffer.map { |m| m[:data] }.flatten.length)
+
+      end
+    end
+  end
+
+end

data/test/test_io.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class IoTest < Test::Unit::TestCase
+
+  include CoreMIDI
+  include TestHelper
+
+  def test_full_io
+    sleep(2)
+    messages = VariousMIDIMessages
+    messages_arr = messages.inject { |a,b| a+b }.flatten
+    received_arr = []
+    pointer = 0
+    $test_device[:output].open do |output|
+      $test_device[:input].open do |input|
+        
+        input.buffer.clear
+
+        messages.each do |msg|
+
+          $>.puts "sending: " + msg.inspect
+
+          output.puts(msg)
+          sleep(1)
+          received = input.gets.map { |m| m[:data] }.flatten
+          
+          $>.puts "received: " + received.inspect
+
+          assert_equal(messages_arr.slice(pointer, received.length), received)
+          
+          pointer += received.length
+          
+          received_arr += received
+          
+        end
+        
+        assert_equal(messages_arr.length, received_arr.length)
+
+      end
+    end
+  end
+
+  # ** this test assumes that TestOutput is connected to TestInput
+  def test_full_io_bytestr
+    sleep(2) # pause between tests
+
+    messages = VariousMIDIByteStrMessages
+    messages_str = messages.join
+    received_str = ""
+    pointer = 0
+
+    $test_device[:output].open do |output|
+      $test_device[:input].open do |input|
+        
+        input.buffer.clear
+
+        messages.each do |msg|
+
+          $>.puts "sending: " + msg.inspect
+
+          output.puts_s(msg)
+          sleep(1)
+          received = input.gets_bytestr.map { |m| m[:data] }.flatten.join
+          $>.puts "received: " + received.inspect
+
+          assert_equal(messages_str.slice(pointer, received.length), received)
+          
+          pointer += received.length
+          
+          received_str += received
+          
+        end
+   
+        assert_equal(messages_str, received_str)
+        
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: ffi-coremidi
+version: !ruby/object:Gem::Version
+  version: 0.1.7
+  prerelease: 
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &70309759821860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70309759821860
+description: Realtime MIDI IO with Ruby for OSX
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/coremidi/destination.rb
+- lib/coremidi/device.rb
+- lib/coremidi/endpoint.rb
+- lib/coremidi/entity.rb
+- lib/coremidi/map.rb
+- lib/coremidi/source.rb
+- lib/coremidi.rb
+- test/helper.rb
+- test/test_input_buffer.rb
+- test/test_io.rb
+- LICENSE
+- README.rdoc
+homepage: http://github.com/arirusso/ffi-coremidi
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: ffi-coremidi
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Realtime MIDI IO with Ruby for OSX
+test_files: []