ffi-coremidi 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c86ac17739ef22c4478c0b6074602c35e6797d7
-  data.tar.gz: 612c5638da885ab668b64952087d52d49112fbdc
+  metadata.gz: 4191e1b978dd6f7b928a1c1822850ded9034c0ae
+  data.tar.gz: 780525a088dde5901dd1c9326d483ebe356e9c59
 SHA512:
-  metadata.gz: dad0821c9b3019da6993960a098d0275a79d009535e09a8e63509908542c3a29b888cfc739cf06b2933e775f8575150c0092d63af9400812c7c0c46dc7db07b0
-  data.tar.gz: 379c75695cea32e8f7ff3347bc6556eb1ead7301781d0ad845261ccf9630b00d39bf006dc5f4294a3193ebdb6a334cb5f0e27fe93c2636864a5a48d277250c9b
+  metadata.gz: 87ca289e7f5edb44619c6503c611828ad60c937e48952c0c99eb65665c75f869079cb1313cf25794fe47db0c944cd8849b764dada1e5c3df1ee82ff448ac9299
+  data.tar.gz: 9c48b781b0b7ab4df324ec15c8f3d18c2131d4776849fcd98c75233d5f59297074a7485b2ef47c3d3d551d3886aa706a18586c87822f5b0556f38864e72270cf

data/lib/coremidi/{map.rb → api.rb}

@@ -1,12 +1,13 @@
 module CoreMIDI
 
   # Coremidi C binding
-  module Map
+  module API
 
     extend FFI::Library
     ffi_lib '/System/Library/Frameworks/CoreMIDI.framework/Versions/Current/CoreMIDI'
 
-    SnowLeopard = `uname -r`.scan(/\d*\.\d*/).first.to_f >= 10.6
+    # if osx is 10.6 or higher, there are some differences with 32 vs 64 bit handling
+    X86_64 = `uname -r`.scan(/\d*\.\d*/).first.to_f >= 10.6
 
     typedef :pointer, :CFStringRef
     typedef :int32, :ItemCount
@@ -46,41 +47,118 @@ module CoreMIDI
 
     end
 
+    def self.get_callback(*args, &block)
+      FFI::Function.new(:void, *args, &block)
+    end
+
+    # Pack the given data into a coremidi MIDI packet (used by Destination)
+    def self.get_midi_packet(data)
+      format = "C" * data.size
+      packed_data = data.pack(format)
+      char_size = FFI.type_size(:char) * data.size
+      bytes = FFI::MemoryPointer.new(char_size)
+      bytes.write_string(packed_data)
+      bytes
+    end
+
+    def self.create_midi_client(resource_id, name)
+      client_name = API::CF.CFStringCreateWithCString(nil, "Client #{resource_id} #{name}", 0)
+      client_pointer = FFI::MemoryPointer.new(:pointer)
+      error = API.MIDIClientCreate(client_name, nil, nil, client_pointer)
+      client = client_pointer.read_pointer
+      {
+        :error => error,
+        :resource => client
+      }
+    end
+
+    def self.create_midi_input_port(client, resource_id, name, callback)
+      port_name = API::CF.CFStringCreateWithCString(nil, "Port #{resource_id}: #{name}", 0)
+      handle_ptr = FFI::MemoryPointer.new(:pointer)
+      error = API.MIDIInputPortCreate(client, port_name, callback, nil, handle_ptr)
+      handle = handle_ptr.read_pointer
+      { 
+        :error => error,
+        :handle => handle
+      }
+    end
+
+    def self.create_midi_output_port(client, resource_id, name)
+      port_name = CF.CFStringCreateWithCString(nil, "Port #{resource_id}: #{name}", 0)
+      port_pointer = FFI::MemoryPointer.new(:pointer)
+      error = API.MIDIOutputPortCreate(client, port_name, port_pointer)
+      handle = port_pointer.read_pointer
+      {
+        :error => error,
+        :handle => handle
+      }
+    end
+
+    # (used by Destination)
+    def self.get_midi_packet_list(bytes, size)
+      packet_list = FFI::MemoryPointer.new(256)
+      packet_ptr = API.MIDIPacketListInit(packet_list)
+      packet_ptr = if X86_64
+        API.MIDIPacketListAdd(packet_list, 256, packet_ptr, 0, size, bytes)
+      else
+        # Pass in two 32-bit 0s for the 64 bit time
+        API.MIDIPacketListAdd(packet_list, 256, packet_ptr, 0, 0, size, bytes)
+      end
+      packet_list
+    end
+
+    # @param [FFI::Pointer] resource A pointer to an underlying struct
+    # @param [String, Symbol] name The property name to get
+    # @return [Fixnum]
+    def self.get_int(resource, name)
+      property = API::CF.CFStringCreateWithCString(nil, name.to_s, 0)
+      value = FFI::MemoryPointer.new(:pointer, 32)
+      API::MIDIObjectGetIntegerProperty(resource, property, value)
+      value.read_int
+    end
+
     # @param [FFI::Pointer] resource A pointer to an underlying struct
     # @param [String, Symbol] name The property name to get
     # @return [String]
     def self.get_string(resource, name)
-      property = Map::CF.CFStringCreateWithCString(nil, name.to_s, 0)
+      property = CF.CFStringCreateWithCString(nil, name.to_s, 0)
       begin
         pointer = FFI::MemoryPointer.new(:pointer)
-        Map::MIDIObjectGetStringProperty(resource, property, pointer)
+        MIDIObjectGetStringProperty(resource, property, pointer)
         string = pointer.read_pointer
-        length = Map::CF.CFStringGetMaximumSizeForEncoding(Map::CF.CFStringGetLength(string), :kCFStringEncodingUTF8)
+        length = CF.CFStringGetMaximumSizeForEncoding(CF.CFStringGetLength(string), :kCFStringEncodingUTF8)
 
         bytes = FFI::MemoryPointer.new(length + 1)
 
-        if Map::CF.CFStringGetCString(string, bytes, length + 1, :kCFStringEncodingUTF8)
+        if CF.CFStringGetCString(string, bytes, length + 1, :kCFStringEncodingUTF8)
           bytes.read_string.force_encoding("utf-8")
         end
       ensure
-        Map::CF.CFRelease(string) unless string.nil? || string.null?
-        Map::CF.CFRelease(property) unless property.null?
+        CF.CFRelease(string) unless string.nil? || string.null?
+        CF.CFRelease(property) unless property.null?
       end
     end
 
+    # Called when the system has one or more incoming MIDI messages to deliver to your app.
+    # typedef void (*MIDIReadProc) (const MIDIPacketList *pktlist, void *readProcRefCon, void *srcConnRefCon);
     callback :MIDIReadProc, [MIDIPacketList.by_ref, :pointer, :pointer], :pointer
 
+    # OSStatus MIDIClientCreate(CFStringRef name, MIDINotifyProc notifyProc, void *notifyRefCon, MIDIClientRef *outClient);
     attach_function :MIDIClientCreate, [:pointer, :pointer, :pointer, :pointer], :int
 
+    # OSStatus MIDIClientDispose(MIDIClientRef client);
     attach_function :MIDIClientDispose, [:pointer], :int
 
-    # MIDIEntityRef MIDIDeviceGetEntity (MIDIDeviceRef  device, ItemCount entityIndex0);
+    # MIDIEntityRef MIDIDeviceGetEntity(MIDIDeviceRef  device, ItemCount entityIndex0);
     attach_function :MIDIDeviceGetEntity, [:MIDIDeviceRef, :ItemCount], :MIDIEntityRef
 
+    # MIDIEndpointRef MIDIGetDestination(ItemCount destIndex0);
     attach_function :MIDIGetNumberOfDestinations, [], :ItemCount
 
+    # ItemCount MIDIGetNumberOfDevices();
     attach_function :MIDIGetNumberOfDevices, [], :ItemCount
 
+    # MIDIEndpointRef MIDIEntityGetDestination(MIDIEntityRef entity, ItemCount destIndex0);
     attach_function :MIDIGetDestination, [:int], :pointer
     
     #extern OSStatus MIDIEndpointDispose( MIDIEndpointRef endpt );
@@ -98,19 +176,23 @@ module CoreMIDI
     # MIDIEndpointRef MIDIEntityGetSource (MIDIEntityRef  entity, ItemCount sourceIndex0);
     attach_function :MIDIEntityGetSource, [:MIDIEntityRef, :ItemCount], :MIDIEndpointRef
 
+    # MIDIDeviceRef MIDIGetDevice(ItemCount deviceIndex0);
     attach_function :MIDIGetDevice, [:ItemCount], :MIDIDeviceRef
     
-    # extern OSStatus MIDIInputPortCreate( MIDIClientRef client, CFStringRef portName, MIDIReadProc readProc, void * refCon, MIDIPortRef * outPort );
+    # 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
 
+    # (MIDIPacket*) MIDIPacketListInit(MIDIPacketList *pktlist);
     attach_function :MIDIPacketListInit, [:pointer], :pointer
 
     #extern OSStatus MIDIPortConnectSource( MIDIPortRef port, MIDIEndpointRef source, void * connRefCon )
@@ -125,12 +207,15 @@ module CoreMIDI
     #extern OSStatus MIDISend(MIDIPortRef port,MIDIEndpointRef dest,const MIDIPacketList *pktlist);
     attach_function :MIDISend, [:MIDIPortRef, :MIDIEndpointRef, :pointer], :int
 
+    #OSStatus MIDISendSysex(MIDISysexSendRequest *request);
     attach_function :MIDISendSysex, [:pointer], :int
 
-    if SnowLeopard
+    # extern MIDIPacket * MIDIPacketListAdd( MIDIPacketList * pktlist, ByteCount listSize, 
+    #                                        MIDIPacket * curPacket, MIDITimeStamp time, 
+    #                                        ByteCount nData, const Byte * data)
+    if X86_64
       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
 
@@ -148,12 +233,16 @@ module CoreMIDI
       # CString* CFStringGetCStringPtr(CFString*, encoding)
       attach_function :CFStringGetCStringPtr, [:pointer, :int], :pointer
 
+      # CFIndex CFStringGetLength(CFStringRef theString);
       attach_function :CFStringGetLength, [ :CFStringRef ], :CFIndex
 
+      # CFIndex CFStringGetMaximumSizeForEncoding(CFIndex length, CFStringEncoding encoding);
       attach_function :CFStringGetMaximumSizeForEncoding, [ :CFIndex, :CFStringEncoding ], :long
 
+      # Boolean CFStringGetCString(CFStringRef theString, char *buffer, CFIndex bufferSize, CFStringEncoding encoding);
       attach_function :CFStringGetCString, [ :CFStringRef, :pointer, :CFIndex, :CFStringEncoding ], :bool
 
+      # void CFRelease (CFTypeRef cf);
       attach_function :CFRelease, [ :pointer ], :void
 
     end
@@ -162,6 +251,7 @@ module CoreMIDI
       extend FFI::Library
       ffi_lib '/System/Library/Frameworks/CoreAudio.framework/Versions/Current/CoreAudio'
 
+      # UInt64 AudioConvertHostTimeToNanos(UInt64 IO)
       attach_function :AudioConvertHostTimeToNanos, [:uint64], :uint64
     end
 

data/lib/coremidi/destination.rb

@@ -38,7 +38,7 @@ module CoreMIDI
     # @return [Boolean]
     def puts_bytes(*data)
       type = sysex?(data) ? :sysex : :small
-      bytes = pack_data(data)
+      bytes = API.get_midi_packet(data)
       send("puts_#{type.to_s}", bytes, data.size)
       true
     end
@@ -99,7 +99,7 @@ module CoreMIDI
     def connect
       client_error = enable_client
       port_error = initialize_port
-      @resource = Map.MIDIEntityGetDestination( @entity.resource, @resource_id )
+      @resource = API.MIDIEntityGetDestination( @entity.resource, @resource_id )
       !@resource.address.zero? && client_error.zero? && port_error.zero?
     end
     alias_method :connect?, :connect
@@ -108,53 +108,34 @@ module CoreMIDI
 
     # 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 )
+      packet_list = API.get_midi_packet_list(bytes, size)
+      API.MIDISend(@handle, @resource, packet_list)
       true
     end
 
     # Output a System Exclusive MIDI message
     def puts_sysex(bytes, size)
-      request = Map::MIDISysexSendRequest.new
+      request = API::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)
+      API.MIDISendSysex(request)
       true
     end
 
     SysexCompletionCallback =
-      FFI::Function.new(:void, [:pointer]) do |sysex_request_ptr|
+      API.get_callback([:pointer]) do |sysex_request_ptr|
         # this isn't working for some reason. as of now, it's not needed 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
-
-    # Pack the given data into a coremidi MIDI packet
-    def pack_data(data)
-      format = "C" * data.size
-      packed_data = data.pack(format)
-      char_size = FFI.type_size(:char) * data.size
-      bytes = FFI::MemoryPointer.new(char_size)
-      bytes.write_string(packed_data)
-      bytes
+      port = API.create_midi_output_port(@client, @resource_id, @name)
+      @handle = port[:handle]
+      port[:error]
     end
 
     # Is the given data a MIDI sysex message?

data/lib/coremidi/device.rb

@@ -1,5 +1,10 @@
 module CoreMIDI
 
+  # A MIDI device may have multiple logically distinct sub-components. For example, one device may 
+  # encompass a MIDI synthesizer and a pair of MIDI ports, both addressable via a USB port. Each 
+  # such element of a device is called a MIDI entity.
+  #
+  # https://developer.apple.com/library/ios/documentation/CoreMidi/Reference/MIDIServices_Reference/Reference/reference.html
   class Device
 
     attr_reader :entities,
@@ -48,7 +53,7 @@ module CoreMIDI
       if !populated? || !use_cache
         @devices = []
         counter = 0
-        while !(device_pointer = Map.MIDIGetDevice(counter)).null?
+        while !(device_pointer = API.MIDIGetDevice(counter)).null?
           device = new(counter, device_pointer, :include_offline => include_offline)
           @devices << device
           counter += 1
@@ -74,7 +79,7 @@ module CoreMIDI
 
     # Populate the device name
     def populate_name
-      @name = Map.get_string(@resource, "name")
+      @name = API.get_string(@resource, "name")
       raise RuntimeError.new("Can't get device name") unless @name
     end
     
@@ -92,7 +97,7 @@ module CoreMIDI
     def populate_entities(options = {})
       include_if_offline = options[:include_offline] || false
       i = 0
-      while !(entity_pointer = Map.MIDIDeviceGetEntity(@resource, i)).null?
+      while !(entity_pointer = API.MIDIDeviceGetEntity(@resource, i)).null?
         @entities << Entity.new(entity_pointer, :include_offline => include_if_offline)
         i += 1
       end

data/lib/coremidi/endpoint.rb

@@ -1,5 +1,6 @@
 module CoreMIDI
 
+  # A MIDI source or destination, owned by an entity.
   module Endpoint
     
     extend Forwardable
@@ -14,10 +15,12 @@ module CoreMIDI
 
     alias_method :enabled?, :enabled
 
-    def initialize(resource_id, entity, options = {}, &block)
+    # @param [Fixnum] resource_id
+    # @param [Entity] entity
+    def initialize(resource_id, entity)
       @entity = entity
       @resource_id = resource_id
-      @type = self.class.name.split('::').last.downcase.to_sym
+      @type = get_type
       @enabled = false
     end
     
@@ -46,12 +49,24 @@ module CoreMIDI
       all_by_type[type].last
     end
 
+    # All source endpoints
+    # @return [Array<Source>]
+    def self.sources
+      Device.all.map { |d| d.endpoints[:source] }.flatten
+    end
+
+    # All destination endpoints
+    # @return [Array<Destination>]
+    def self.destinations
+      Device.all.map { |d| d.endpoints[:destination] }.flatten
+    end
+
     # A Hash of :source and :destination endpoints
     # @return [Hash]
     def self.all_by_type
       {
-        :source => Device.all.map { |d| d.endpoints[:source] }.flatten,
-        :destination => Device.all.map { |d| d.endpoints[:destination] }.flatten
+        :source => sources,
+        :destination => destinations
       }
     end
 
@@ -72,14 +87,18 @@ module CoreMIDI
     end
     
     protected
+
+    # Constructs the endpoint type (eg source, destination) for easy consumption
+    def get_type
+      class_name = self.class.name.split('::').last
+      class_name.downcase.to_sym
+    end
     
     # 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
+      client = API.create_midi_client(@resource_id, @name)
+      @client = client[:resource]
+      client[:error]
     end
 
   end

data/lib/coremidi/entity.rb

@@ -1,9 +1,15 @@
 module CoreMIDI
 
+  # A MIDI entity can have any number of MIDI endpoints, each of which is a source or destination 
+  # of a 16-channel MIDI stream. By grouping a device's endpoints into entities, the system has 
+  # enough information for an application to make reasonable default assumptions about how to 
+  # communicate in a bi-directional manner with each entity, as is necessary in MIDI librarian 
+  # applications.
+  #
+  # https://developer.apple.com/library/ios/documentation/CoreMidi/Reference/MIDIServices_Reference/Reference/reference.html
   class Entity
 
     attr_reader :endpoints, 
-                :is_online,
                 :manufacturer,
                 :model,
                 :name,
@@ -11,13 +17,14 @@ module CoreMIDI
                 
     # @param [FFI::Pointer] resource A pointer to the underlying entity
     # @param [Hash] options
-    def initialize(resource, options = {}, &block)
+    # @option options [Boolean] :include_offline Include offline endpoints in the list
+    def initialize(resource, options = {})
       @endpoints = { 
         :source => [], 
         :destination => [] 
       }
       @resource = resource
-      populate
+      populate(options)
     end
     
     # Assign all of this Entity's endpoints an consecutive local id
@@ -25,7 +32,7 @@ module CoreMIDI
     # @return [Fixnum]
     def populate_endpoint_ids(starting_id)
       counter = 0
-      @endpoints.values.flatten.each do |endpoint|  
+      @endpoints.values.flatten.each do |endpoint|
         endpoint.id = counter + starting_id
         counter += 1
       end
@@ -35,7 +42,7 @@ module CoreMIDI
     # Is the entity online?
     # @return [Boolean]
     def online?
-      get_property(:offline, :type => :int) == 0
+      get_int(:offline) == 0
     end
 
     private
@@ -64,17 +71,19 @@ module CoreMIDI
     end
 
     # Populate the endpoints for this entity
+    # @param [Hash] options
+    # @option options [Boolean] :include_offline Include offline endpoints in the list
     # @return [Fixnum]
-    def populate_endpoints
-      @endpoints.keys.map { |type| populate_endpoints_by_type(type) }.reduce(&:+)
+    def populate_endpoints(options = {})
+      @endpoints.keys.map { |type| populate_endpoints_by_type(type, options) }.reduce(&:+)
     end
     
     # The number of endpoints for this entity
     # @param [Symbol] type The endpoint type eg :source, :destination
     def number_of_endpoints(type)
       case type
-        when :source then Map.MIDIEntityGetNumberOfSources(@resource)
-        when :destination then Map.MIDIEntityGetNumberOfDestinations(@resource)
+        when :source then API.MIDIEntityGetNumberOfSources(@resource)
+        when :destination then API.MIDIEntityGetNumberOfDestinations(@resource)
       end
     end
     
@@ -82,37 +91,24 @@ module CoreMIDI
     # @param [Symbol, String] name The property name
     # @return [String, nil]
     def get_string(name)
-      Map.get_string(@resource, name)
+      API.get_string(@resource, name)
     end
     
     # An Integer property from the underlying entity
     # @param [Symbol, String] name The property name
     # @return [Fixnum, nil]
     def get_int(name)
-      property = Map::CF.CFStringCreateWithCString(nil, name.to_s, 0)
-      value = FFI::MemoryPointer.new(:pointer, 32)
-      Map::MIDIObjectGetIntegerProperty(@resource, property, value)
-      value.read_int
+      API.get_int(@resource, name)
     end        
 
-    # A CString or Integer property from the underlying entity
-    # @param [Symbol, String] name The property name
-    # @param [Hash] options
-    # @option options [Symbol] :type The property type eg :int, :string (default :string)
-    # @return [Fixnum, String, nil]
-    def get_property(name, options = {})
-      case options[:type]
-        when :string, nil then get_string(name)
-        when :int then get_int(name)
-      end
-    end
-
     # Populate the entity properties from the underlying resource
-    def populate
-      @manufacturer = get_property(:manufacturer)
-      @model = get_property(:model)
+    # @param [Hash] options
+    # @option options [Boolean] :include_offline Include offline endpoints in the list
+    def populate(options = {})
+      @manufacturer = get_string(:manufacturer)
+      @model = get_string(:model)
       @name = get_name
-      populate_endpoints
+      populate_endpoints(options)
     end
 
   end

data/lib/coremidi/source.rb

@@ -42,7 +42,7 @@ module CoreMIDI
     def gets_s
       messages = gets
       messages.each do |message| 
-        message[:data] = numeric_bytes_to_hex_string(message[:data])
+        message[:data] = TypeConversion.numeric_bytes_to_hex_string(message[:data])
       end
       messages
     end
@@ -69,13 +69,13 @@ module CoreMIDI
     # Close this input
     # @return [Boolean]
     def close
-      #error = Map.MIDIPortDisconnectSource( @handle, @resource )
+      #error = API.MIDIPortDisconnectSource( @handle, @resource )
       #raise "MIDIPortDisconnectSource returned error code #{error}" unless error.zero?
-      #error = Map.MIDIClientDispose(@handle)
+      #error = API.MIDIClientDispose(@handle)
       #raise "MIDIClientDispose returned error code #{error}" unless error.zero?
-      #error = Map.MIDIPortDispose(@handle)
+      #error = API.MIDIPortDispose(@handle)
       #raise "MIDIPortDispose returned error code #{error}" unless error.zero?
-      #error = Map.MIDIEndpointDispose(@resource)
+      #error = API.MIDIEndpointDispose(@resource)
       #raise "MIDIEndpointDispose returned error code #{error}" unless error.zero?
       if @enabled
         @enabled = false
@@ -110,8 +110,8 @@ module CoreMIDI
     def connect   
       enable_client
       initialize_port
-      @resource = Map.MIDIEntityGetSource(@entity.resource, @resource_id)
-      error = Map.MIDIPortConnectSource(@handle, @resource, nil )
+      @resource = API.MIDIEntityGetSource(@entity.resource, @resource_id)
+      error = API.MIDIPortConnectSource(@handle, @resource, nil )
       initialize_buffer
       @sysex_buffer = []
       @start_time = Time.now.to_f
@@ -169,12 +169,10 @@ module CoreMIDI
 
     # 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?
+      port = API.create_midi_input_port(@client, @resource_id, @name, @callback)
+      @handle = port[:handle]
+      raise "MIDIInputPortCreate returned error code #{port[:error]}" unless port[:error].zero?
       true
     end
     
@@ -189,18 +187,6 @@ module CoreMIDI
       true
     end
     
-    # Convert an array of numeric byes to a hex string (e.g. [0x90, 0x40, 0x40] becomes "904040")
-    # @param [Array<Fixnum>] bytes
-    # @return [String]
-    def numeric_bytes_to_hex_string(bytes)
-      string_bytes = bytes.map do |byte| 
-        str = byte.to_s(16).upcase
-        str = "0" + str if byte < 16
-        str
-      end
-      string_bytes.join
-    end 
-
   end
 
 end

data/lib/coremidi/type_conversion.rb

@@ -0,0 +1,21 @@
+module CoreMIDI
+
+  # Helper for convertig MIDI data
+  module TypeConversion
+
+    extend self
+
+    # Convert an array of numeric byes to a hex string (e.g. [0x90, 0x40, 0x40] becomes "904040")
+    # @param [Array<Fixnum>] bytes
+    # @return [String]
+    def numeric_bytes_to_hex_string(bytes)
+      string_bytes = bytes.map do |byte| 
+        str = byte.to_s(16).upcase
+        str = "0" + str if byte < 16
+        str
+      end
+      string_bytes.join
+    end 
+
+  end
+end

data/lib/coremidi.rb

@@ -8,8 +8,9 @@ require "ffi"
 require "forwardable"
 
 # modules
+require "coremidi/api"
 require "coremidi/endpoint"
-require "coremidi/map"
+require "coremidi/type_conversion"
 
 # classes
 require "coremidi/entity"
@@ -18,5 +19,5 @@ require "coremidi/source"
 require "coremidi/destination"
 
 module CoreMIDI
-  VERSION = "0.2.3"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-coremidi
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-02 00:00:00.000000000 Z
+date: 2014-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -34,12 +34,13 @@ files:
 - LICENSE
 - README.md
 - lib/coremidi.rb
+- lib/coremidi/api.rb
 - 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/type_conversion.rb
 - test/helper.rb
 - test/input_buffer_test.rb
 - test/io_test.rb