midi-communications-macos 0.5.0

data/LICENSE.ffi-coremidi

@@ -0,0 +1,13 @@
+Copyright 2011-2017 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/LICENSE.midiator

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2008, Ben Bleything <ben@bleything.net>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/LICENSE.prp

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2006, 2007 Topher Cyll
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,118 @@
+# MIDI Communications MacOS Layer
+
+**Realtime MIDI IO with Ruby for OSX.**
+
+Access the [Apple Core MIDI framework API](https://developer.apple.com/library/mac/#documentation/MusicAudio/Reference/CACoreMIDIRef/MIDIServices/) with Ruby.
+
+This library is part of a suite of Ruby libraries for MIDI:
+
+| Function | Library |
+| --- | --- |
+| MIDI Events representation | [MIDI Events](https://github.com/javier-sy/midi-events) |
+| MIDI Data parsing | [MIDI Parser](https://github.com/javier-sy/midi-parser) |
+| MIDI communication with Instruments and Control Surfaces | [MIDI Communications](https://github.com/javier-sy/midi-communications) |
+| Low level MIDI interface to MacOS | [MIDI Communications MacOS Layer](https://github.com/javier-sy/midi-communications-macos) |
+| Low level MIDI interface to Linux | **TO DO** (by now [MIDI Communications](https://github.com/javier-sy/midi-communications) uses [alsa-rawmidi](http://github.com/arirusso/alsa-rawmidi)) | 
+| Low level MIDI interface to JRuby | **TO DO** (by now [MIDI Communications](https://github.com/javier-sy/midi-communications) uses [midi-jruby](http://github.com/arirusso/midi-jruby))| 
+| Low level MIDI interface to Windows | **TO DO** (by now [MIDI Communications](https://github.com/javier-sy/midi-communications) uses [midi-winm](http://github.com/arirusso/midi-winmm)) | 
+
+This library is based on [Ari Russo's](http://github.com/arirusso) library [ffi-coremidi](https://github.com/arirusso/ffi-coremidi).
+
+## Features
+
+* Simplified API
+* Input and output on multiple devices concurrently
+* Generalized handling of different MIDI Message types (including SysEx)
+* Timestamped input events
+* Patch MIDI via software to other programs using IAC
+
+## Requirements
+
+* [ffi](http://github.com/ffi/ffi)
+
+## Installation
+
+If you're using Bundler, add this line to your application's Gemfile:
+
+`gem "midi-communications-macos"`
+
+Otherwise
+
+`gem install midi-communications-macos`
+
+## Documentation
+
+(**TO DO**) [rdoc](http://rubydoc.info/github/javier-sy/midi-communications-macos)
+
+## Differences between [MIDI Communications MacOS Layer](https://github.com/javier-sy/midi-communications-macos) library and [ffi-coremidi](https://github.com/arirusso/ffi-coremidi) library
+
+[MIDI Communications MacOS Layer](https://github.com/javier-sy/midi-communications-macos) is mostly a clone of [ffi-coremidi](https://github.com/arirusso/ffi-coremidi) with some modifications:
+* Added locking behaviour when waiting midi events
+* Removed process history information logging (to reduce CPU usage in some scenarios)
+* Improved MIDI devices name detection
+* Source updated to Ruby 2.7 code conventions (method keyword parameters instead of options = {}, hash keys as 'key:' instead of ':key =>', etc.)
+* Updated dependencies versions
+* Renamed module to MIDICommunicationsMacOS instead of CoreMIDI
+* Renamed gem to midi-communications-macos instead of ffi-coremidi
+* TODO: update tests to use rspec instead of rake
+* TODO: migrate to (or confirm it's working ok on) Ruby 3.0 and Ruby 3.1
+
+## Then, why does exist this library if it is mostly a clone of another library?
+
+The author has been developing since 2016 a Ruby project called
+[Musa DSL](https://github.com/javier-sy/musa-dsl) that needs a way
+of representing MIDI Events and a way of communicating with
+MIDI Instruments and MIDI Control Surfaces.
+
+[Ari Russo](https://github.com/arirusso) has done a great job creating
+several interdependent Ruby libraries that allow
+MIDI Events representation ([MIDI Message](https://github.com/arirusso/midi-message)
+and [Nibbler](https://github.com/arirusso/nibbler))
+and communication with MIDI Instruments and MIDI Control Surfaces
+([unimidi](https://github.com/arirusso/unimidi),
+[ffi-coremidi](https://github.com/arirusso/ffi-coremidi) and others)
+that, **with some modifications**, I've been using in MusaDSL.
+
+After thinking about the best approach to publish MusaDSL
+I've decided to publish my own renamed version of the modified dependencies because:
+
+* Some differences on the approach of the modifications vs the original library doesn't allow to merge the modifications on the original libraries.
+* Then the renaming of the libraries is needed to avoid confusing existent users of the original libraries.
+* Due to some of the interdependencies of Ari Russo libraries,
+  the modification and renaming on some of the low level libraries (ffi-coremidi, etc.)
+  forces to modify and rename unimidi library.
+* The original libraries have features
+  (very detailed logging and processing history information, not locking behaviour when waiting input midi messages)
+  that are not needed in MusaDSL and, in fact,
+  can degrade the performance on some use case scenarios in MusaDSL.
+
+All in all I have decided to publish a suite of libraries optimized for MusaDSL use case that also can be used by other people in their projects.
+
+| Function | Library | Based on Ari Russo's| Difference |
+| --- | --- | --- | --- |
+| MIDI Events representation | [MIDI Events](https://github.com/javier-sy/midi-events) | [MIDI Message](https://github.com/arirusso/midi-message) | removed parsing, small improvements |
+| MIDI Data parsing | [MIDI Parser](https://github.com/javier-sy/midi-parser) | [Nibbler](https://github.com/arirusso/nibbler) | removed process history information, minor optimizations |
+| MIDI communication with Instruments and Control Surfaces | [MIDI Communications](https://github.com/javier-sy/midi-communications) | [unimidi](https://github.com/arirusso/unimidi) | use of [MIDI Communications MacOS Layer](https://github.com/javier-sy/midi-communications-macos)
+| Low level MIDI interface to MacOS | [MIDI Communications MacOS Layer](https://github.com/javier-sy/midi-communications-macos) | [ffi-coremidi](https://github.com/arirusso/ffi-coremidi) | removed process history information, locking behaviour when waiting midi events, improved midi devices name detection, minor optimizations |
+| Low level MIDI interface to Linux | **TO DO** | | |
+| Low level MIDI interface to JRuby | **TO DO** | | |
+| Low level MIDI interface to Windows | **TO DO** | | |
+
+## Author
+
+* [Javier Sánchez Yeste](https://github.com/javier-sy)
+
+## Acknowledgements
+
+Thanks to [Ari Russo](http://github.com/arirusso) for his ruby library [ffi-coremidi](https://github.com/arirusso/ffi-coremidi) licensed as Apache License 2.0.
+
+As explained by **Ari Russo** regarding his library **ffi-coremidi**:
+* **ffi-coremidi** 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
+
+[MIDI Events](https://github.com/javier-sy/midi-events) Copyright (c) 2021 [Javier Sánchez Yeste](https://yeste.studio), licensed under LGPL 3.0 License
+
+[ffi-coremidi](https://github.com/arirusso/ffi-coremidi) Copyright (c) 2011-2017 [Ari Russo](http://arirusso.com), licensed under Apache License 2.0 (see the file LICENSE.ffi-coremidi)

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task default: [:test]

data/examples/input.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join('..', 'lib'))
+
+require 'midi-communications-macos'
+
+# This program selects the first midi input and sends an inspection of the first 10 messages
+# messages it receives to standard out
+
+num_messages = 10
+
+# CoreMIDI::Device.all.to_s will list your midi devices
+# or amidi -l from the command line
+
+MIDICommunicationsMacOS::Source.all[0].open do |input|
+  puts "Using input: #{input.id}, #{input.name}"
+
+  puts 'send some MIDI to your input now...'
+
+  num_messages.times do
+    m = input.gets
+    puts(m)
+  end
+
+  puts 'finished'
+end

data/examples/list_endpoints.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join('..', 'lib'))
+
+require 'midi-communications-macos'
+
+# This will output a big list of Endpoint objects. Endpoint objects are what's used to input
+# and output MIDI messages
+
+pp MIDICommunicationsMacOS::Device.all.map { |device| device.endpoints.values }.flatten

data/examples/output.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join('..', 'lib'))
+
+require 'midi-communications-macos'
+
+# This program selects the first midi output and sends some arpeggiated chords to it
+
+notes = [36, 40, 43] # C E G
+octaves = 5
+duration = 0.1
+
+# CoreMIDI::Device.all.to_s will list your midi devices
+# or amidi -l from the command line
+
+MIDICommunicationsMacOS::Destination.first.open do |output|
+  (0..((octaves-1)*12)).step(12) do |oct|
+    notes.each do |note|
+      output.puts(0x90, note + oct, 100) # note on
+      sleep(duration) # wait
+      output.puts(0x80, note + oct, 100) # note off
+    end
+  end
+end

data/examples/sysex_output.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join('..', 'lib'))
+
+require 'midi-communications-macos'
+
+# This example outputs a raw sysex message to the first Output endpoint
+# there will not be any output to the console
+
+output = MIDICommunicationsMacOS::Destination.first
+sysex_msg = [0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7]
+
+output.open { |output| output.puts(sysex_msg) }

data/lib/midi-communications-macos/api.rb

@@ -0,0 +1,259 @@
+module MIDICommunicationsMacOS
+  # Coremidi C binding
+  module API
+    extend FFI::Library
+    ffi_lib '/System/Library/Frameworks/CoreMIDI.framework/Versions/Current/CoreMIDI'
+
+    # 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
+    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
+
+    def self.get_callback(*args, &block)
+      FFI::Function.new(:void, *args, &block)
+    end
+
+    # Pack the given data into a midi-communications-macos 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)
+      time = HostTime.AudioGetCurrentHostTime
+      packet_ptr = if X86_64
+        API.MIDIPacketListAdd(packet_list, 256, packet_ptr, time, size, bytes)
+      else
+        # Pass in two 32-bit 0s for the 64 bit time
+        time1 = API.MIDIPacketListAdd(packet_list, 256, packet_ptr, time >> 32, time & 0xFFFFFFFF, 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 [Integer]
+    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 = CF.CFStringCreateWithCString(nil, name.to_s, 0)
+      begin
+        pointer = FFI::MemoryPointer.new(:pointer)
+        MIDIObjectGetStringProperty(resource, property, pointer)
+        string = pointer.read_pointer
+        length = CF.CFStringGetMaximumSizeForEncoding(CF.CFStringGetLength(string), :kCFStringEncodingUTF8)
+
+        bytes = FFI::MemoryPointer.new(length + 1)
+
+        if CF.CFStringGetCString(string, bytes, length + 1, :kCFStringEncodingUTF8)
+          bytes.read_string.force_encoding("utf-8")
+        end
+      ensure
+        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);
+    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 );
+    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
+
+    # MIDIDeviceRef MIDIGetDevice(ItemCount deviceIndex0);
+    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
+
+    # (MIDIPacket*) MIDIPacketListInit(MIDIPacketList *pktlist);
+    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
+
+    #OSStatus MIDISendSysex(MIDISysexSendRequest *request);
+    attach_function :MIDISendSysex, [:pointer], :int
+
+    # 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, :uint64, :int, :pointer], :pointer
+    else
+      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'
+
+      typedef :pointer, :CFStringRef
+      typedef :long, :CFIndex
+      enum :CFStringEncoding, [ :kCFStringEncodingUTF8, 0x08000100 ]
+
+      # CFString* CFStringCreateWithCString( ?, CString, encoding)
+      attach_function :CFStringCreateWithCString, [:pointer, :string, :int], :pointer
+      # 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
+
+    module HostTime
+      extend FFI::Library
+      ffi_lib '/System/Library/Frameworks/CoreAudio.framework/Versions/Current/CoreAudio'
+
+      # UInt64 AudioConvertHostTimeToNanos(UInt64 IO)
+      attach_function :AudioConvertHostTimeToNanos, [:uint64], :uint64
+      # UInt64 AudioGetCurrentHostTime()
+      attach_function :AudioGetCurrentHostTime, [], :uint64
+    end
+  end
+end

data/lib/midi-communications-macos/destination.rb

@@ -0,0 +1,142 @@
+module MIDICommunicationsMacOS
+  # Type of endpoint used for output
+  class Destination
+    include Endpoint
+
+    attr_reader :entity
+
+    # Close this output
+    # @return [Boolean]
+    def close
+      if @enabled
+        @enabled = false
+        true
+      else
+        false
+      end
+    end
+
+    # Send a MIDI message comprised of a String of hex digits
+    # @param [String] data A string of hex digits eg "904040"
+    # @return [Boolean]
+    def puts_s(data)
+      data = data.dup
+      bytes = []
+      until (str = data.slice!(0, 2)).eql?('')
+        bytes << str.hex
+      end
+      puts_bytes(*bytes)
+      true
+    end
+    alias puts_bytestr puts_s
+    alias puts_hex puts_s
+
+    # Send a MIDI message comprised of numeric bytes
+    # @param [*Integer] data Numeric bytes eg 0x90, 0x40, 0x40
+    # @return [Boolean]
+    def puts_bytes(*data)
+      type = sysex?(data) ? :sysex : :small
+      bytes = API.get_midi_packet(data)
+      send("puts_#{type.to_s}", bytes, data.size)
+      true
+    end
+
+    # Send a MIDI message of indeterminate type
+    # @param [*Array<Integer>, *Array<String>, *Integer, *String] args
+    # @return [Boolean]
+    def puts(*args)
+      case args.first
+      when Array then args.each { |arg| puts(*arg) }
+      when Integer then puts_bytes(*args)
+      when String then puts_bytestr(*args)
+      end
+    end
+    alias write puts
+
+    # Enable this device
+    # @return [Destination]
+    def enable
+      @enabled ||= true
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      end
+      self
+    end
+    alias open enable
+    alias start enable
+
+    # Shortcut to the first output endpoint available
+    # @return [Destination]
+    def self.first
+      Endpoint.first(:destination)
+    end
+
+    # Shortcut to the last output endpoint available
+    # @return [Destination]
+    def self.last
+      Endpoint.last(:destination)
+    end
+
+    # All output endpoints
+    # @return [Array<Destination>]
+    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
+    # @return [Boolean]
+    def connect
+      client_error = enable_client
+      port_error = initialize_port
+      @resource = API.MIDIEntityGetDestination(@entity.resource, @resource_id)
+      !@resource.address.zero? && client_error.zero? && port_error.zero?
+    end
+    alias connect? connect
+
+    private
+
+    # Output a short MIDI message
+    def puts_small(bytes, size)
+      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 = 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
+      API.MIDISendSysex(request)
+      true
+    end
+
+    SysexCompletionCallback =
+      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 midi-communications-macos port for this endpoint
+    def initialize_port
+      port = API.create_midi_output_port(@client, @resource_id, @name)
+      @handle = port[:handle]
+      port[:error]
+    end
+
+    # Is the given data a MIDI sysex message?
+    def sysex?(data)
+      data.first.eql?(0xF0) && data.last.eql?(0xF7)
+    end
+  end
+end