burke-coremidi 0.0.5

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008 Markus Prinz
+
+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.rdoc

@@ -0,0 +1,10 @@
+Provide easy access to CoreMIDI for Ruby.
+
+Please note that this is a work in progress. The code isn't tested and for all I know, 
+it sets your house on fire, steals your car and runs over your dog and/or cat. So proceed 
+with caution.
+
+== Installation
+
+  $ gem sources -a http://gems.github.com
+  $ sudo gem install burke-coremidi

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "coremidi"
+    s.summary = "A very simple access layer to the OS X CoreMIDI library."
+    s.email = "burke@53cr.com"
+    s.homepage = "http://github.com/burke/coremidi"
+    s.description = "A very simple access layer to the OS X CoreMIDI library."
+    s.authors = ["Burke Libbey"]
+    s.files =  FileList["[A-Z]*", "{lib,spec,examples}/**/*", "ext/extconf.rb", "ext/coremidi.c"]
+    s.extensions = ["ext/extconf.rb"]
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 5
+:major: 0
+:minor: 0

data/examples/example.rb

@@ -0,0 +1,24 @@
+begin
+  require 'rubygems'
+rescue LoadError
+end
+require 'coremidi'
+
+# Start archaeopteryx 
+# Start GarageBand (just to make sure it's all working)
+
+# Open MIDI Patch Bay.app
+# Create a new input (anyname)
+# Create a new output (anyname)
+# GarageBand will announce that it has found a new input
+# You should have sound, yay
+
+# Now run this script
+
+midi_thread = Thread.new do
+  CoreMIDI::Input.register("Test", "Test", "Out") do |event|
+    puts event.inspect
+  end
+end
+
+gets # Stop on enter

data/ext/coremidi.c

@@ -0,0 +1,391 @@
+/*
+ *  Copyright 2008 Markus Prinz
+ *  Released unter an MIT licence
+ *
+ */
+
+#include <ruby.h>
+#include <CoreMIDI/MIDIServices.h>
+#include <pthread.h>
+#include <stdlib.h>
+
+pthread_mutex_t mutex;
+
+CFMutableArrayRef midi_data = NULL;
+
+VALUE mCoreMIDI = Qnil;
+VALUE mCoreMIDIAPI = Qnil;
+
+VALUE cInputPort = Qnil;
+VALUE cMIDIClient = Qnil;
+
+// We need our own data structure since MIDIPacket defines data to be a 256 byte array,
+// even though it can be larger than that
+typedef struct RbMIDIPacket_t {
+    MIDITimeStamp timeStamp;
+    UInt16 length;
+    Byte* data;
+} RbMIDIPacket;
+
+// A struct that contains the input port
+typedef struct RbInputPort_t {
+    MIDIPortRef input_port;
+} RbInputPort;
+
+// A struct that contains the midi client
+typedef struct RbMIDIClient_t {
+    MIDIClientRef client;
+} RbMIDIClient;
+
+// Forward declare free_objects
+static void free_objects();
+
+// The callback function that we'll eventually supply to MIDIInputPortCreate
+static void RbMIDIReadProc(const MIDIPacketList* packetList, void* readProcRefCon, void* srcConnRefCon)
+{
+    if( pthread_mutex_lock(&mutex) != 0 )
+    {
+        // uh oh
+        // Not much we can do
+        return;
+    }
+    
+    MIDIPacket* current_packet = (MIDIPacket*) packetList->packet;
+
+    unsigned int j;
+    for( j = 0; j < packetList->numPackets; ++j )
+    {
+        RbMIDIPacket* rb_packet = (RbMIDIPacket*) malloc( sizeof(RbMIDIPacket) );
+        
+        if( rb_packet == NULL )
+        {
+            fprintf(stderr, "Failed to allocate memory for RbMIDIPacket!\n");
+            abort();
+        }
+        
+        rb_packet->timeStamp = current_packet->timeStamp;
+        rb_packet->length = current_packet->length;
+        
+        size_t size = sizeof(Byte) * rb_packet->length;
+        rb_packet->data = (Byte*) malloc( size );
+        
+        if( rb_packet->data == NULL )
+        {
+            fprintf(stderr, "Failed to allocate memory for RbMIDIPacket data!\n");
+            abort();
+        }
+        
+        memcpy(rb_packet->data, current_packet->data, size);
+        
+        CFArrayAppendValue(midi_data, rb_packet);
+        
+        current_packet = MIDIPacketNext(current_packet);
+    }
+    
+    pthread_mutex_unlock(&mutex);
+}
+
+// Checks for new data and copies it over if there is some.
+static VALUE t_check_for_new_data(VALUE self)
+{
+    if( pthread_mutex_trylock(&mutex) != 0 )
+    {
+        // no data for us yet
+        return Qfalse;
+    }
+    
+    // Switch out the arrays. Possibly evil
+    CFArrayRef data = midi_data;
+    midi_data = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
+    
+    pthread_mutex_unlock(&mutex);
+    
+    // We'll use a Ruby Struct to store the data
+    VALUE cMidiPacket = rb_const_get(mCoreMIDIAPI, rb_intern("MidiPacket"));
+    
+    VALUE rb_midi_data = rb_ary_new();
+    
+    CFIndex idx = 0;
+    CFIndex array_size = CFArrayGetCount(data);
+    const RbMIDIPacket* current_packet = NULL;
+    
+    for( ; idx < array_size; ++idx ) 
+    {
+        current_packet = (const RbMIDIPacket*) CFArrayGetValueAtIndex(data, idx);
+        
+        VALUE byte_array = rb_ary_new2(current_packet->length);
+        
+        int i;
+        for (i = 0; i < current_packet->length; ++i) 
+        {
+            rb_ary_push(byte_array, INT2FIX(current_packet->data[i]));
+        }
+        
+        // relies on sizeof(MIDITimeStamp) == sizeof(unsigned long long)
+        assert(sizeof(MIDITimeStamp) == sizeof(unsigned long long));
+        
+        VALUE midi_packet_args[2];
+        midi_packet_args[0] = ULL2NUM(current_packet->timeStamp);
+        midi_packet_args[1] = byte_array;
+        
+        rb_ary_push(rb_midi_data, rb_class_new_instance((sizeof(midi_packet_args)/sizeof(midi_packet_args[0])), midi_packet_args, cMidiPacket));
+        
+        // While we're at it..
+        // Free the memory! Save the whales!
+        free(current_packet->data);
+    }
+    
+    // Free the memory! Save the whales! Part 2!
+    CFRelease(data);
+    
+    return rb_midi_data;
+}
+
+static VALUE t_create_client(VALUE self, VALUE client_name)
+{    
+    VALUE midiclient_instance = rb_class_new_instance(0, 0, cMIDIClient);
+    if( midiclient_instance == Qnil )
+    {
+        free_objects();
+        rb_fatal("Couldn't create an instance of MIDIClient!");
+    }
+    
+    MIDIClientRef midi_client;
+    
+    CFStringRef client_str = CFStringCreateWithCString(kCFAllocatorDefault, RSTRING(client_name)->ptr, kCFStringEncodingASCII);
+    MIDIClientCreate(client_str, NULL, NULL, &midi_client);
+    CFRelease(client_str);
+    
+    RbMIDIClient* client_struct;
+    Data_Get_Struct(midiclient_instance, RbMIDIClient, client_struct);
+    
+    client_struct->client = midi_client;
+    
+    return midiclient_instance;
+}
+
+// Create a new Input Port and saves the Ruby Callback proc.
+static VALUE t_create_input_port(VALUE self, VALUE client_instance, VALUE port_name)
+{
+    MIDIPortRef in_port;
+    
+    RbMIDIClient* client;
+    Data_Get_Struct(client_instance, RbMIDIClient, client);
+    
+    CFStringRef port_str = CFStringCreateWithCString(kCFAllocatorDefault, RSTRING(port_name)->ptr, kCFStringEncodingASCII);
+    MIDIInputPortCreate(client->client, port_str, RbMIDIReadProc, NULL, &in_port);
+    CFRelease(port_str);
+    
+    VALUE inputport_instance = rb_class_new_instance(0, 0, cInputPort);
+    if( inputport_instance == Qnil )
+    {
+        free_objects();
+        rb_fatal("Couldn't create an instance of InputPort!");
+    }
+    
+    RbInputPort* port_struct;
+    Data_Get_Struct(inputport_instance, RbInputPort, port_struct);
+    
+    port_struct->input_port = in_port;
+    
+    return inputport_instance;
+}
+
+// Return an array of all available sources, filled with the names of the sources
+static VALUE t_get_sources(VALUE self)
+{    
+    int number_of_sources = MIDIGetNumberOfSources();
+    
+    VALUE source_ary = rb_ary_new2(number_of_sources);
+    
+    int idx;
+    for(idx = 0; idx < number_of_sources; ++idx)
+    {
+        MIDIEndpointRef src = MIDIGetSource(idx);
+        CFStringRef pname;
+        char name[64];
+        
+        MIDIObjectGetStringProperty(src, kMIDIPropertyName, &pname);
+        CFStringGetCString(pname, name, sizeof(name), 0);
+        CFRelease(pname);
+        
+        rb_ary_push(source_ary, rb_str_new2(name));
+    }
+    
+    return source_ary;
+}
+
+static VALUE t_get_num_sources(VALUE self)
+{
+    return INT2FIX(MIDIGetNumberOfSources());
+}
+
+// source is identified by the index in the array returned by get_sources
+// input_port is an InputPort class
+static VALUE t_connect_source_to_port(VALUE self, VALUE source_idx, VALUE input_port)
+{
+    RbInputPort* port;
+    Data_Get_Struct(input_port, RbInputPort, port);
+    
+    MIDIEndpointRef source = MIDIGetSource(FIX2INT(source_idx));
+    
+    MIDIPortConnectSource(port->input_port, source, NULL);
+    
+    return Qtrue;
+}
+
+// source is identified by the index in the array returned by get_sources
+// input_port is an InputPort class
+static VALUE t_disconnect_source_from_port(VALUE self, VALUE source_idx, VALUE input_port)
+{
+    RbInputPort* port;
+    Data_Get_Struct(input_port, RbInputPort, port);
+    
+    MIDIEndpointRef source = MIDIGetSource(FIX2INT(source_idx));
+    
+    MIDIPortDisconnectSource(port->input_port, source);
+    
+    return Qtrue;
+}
+
+/*
+ *
+ * RbInputPort related methods
+ *
+ */
+
+static void inputport_free(void* ptr)
+{
+    if( ptr != NULL)
+        free(ptr);
+}
+
+static VALUE inputport_alloc(VALUE klass)
+{
+    RbInputPort* port = (RbInputPort*) malloc(sizeof(RbInputPort));
+    port->input_port = NULL;
+    
+    VALUE obj;
+    obj = Data_Wrap_Struct(klass, 0, inputport_free, port);
+    
+    return obj;
+}
+
+static VALUE inputport_initialize(VALUE self)
+{
+    return self;
+}
+
+/*
+ *
+ * RbMIDIClient related methods
+ *
+ */
+
+static void midiclient_free(void* ptr)
+{
+    if( ptr != NULL)
+        free(ptr);
+}
+
+static VALUE midiclient_alloc(VALUE klass)
+{
+    RbMIDIClient* client = (RbMIDIClient*) malloc(sizeof(RbMIDIClient));
+    client->client = NULL;
+    
+    VALUE obj;
+    obj = Data_Wrap_Struct(klass, 0, midiclient_free, client);
+    
+    return obj;
+}
+
+static VALUE midiclient_initialize(VALUE self)
+{
+    return self;
+}
+
+/*
+ *
+ * util methods
+ *
+ */
+
+static void free_objects()
+{
+    pthread_mutex_destroy(&mutex);
+    
+    if( midi_data != NULL )
+    {
+        if( CFArrayGetCount(midi_data) > 0 )
+        {
+            int i;
+            for( i = 0; i < CFArrayGetCount(midi_data); ++i )
+            {
+                free(((const RbMIDIPacket*) CFArrayGetValueAtIndex(midi_data, i))->data);
+            }
+        }
+        
+        CFRelease(midi_data);
+    }
+}
+
+static void init_mutex()
+{
+    int mutex_init_result = pthread_mutex_init(&mutex, NULL);
+    
+    if( mutex_init_result != 0 )
+    {
+        rb_sys_fail("Failed to allocate mutex");
+    }
+}
+
+static void init_midi_data()
+{
+    midi_data = CFArrayCreateMutable(kCFAllocatorDefault, 0, NULL);
+    
+    if( midi_data == NULL )
+    {
+        free_objects();
+        rb_sys_fail("Failed to allocate CFMutableArray");
+    }
+}
+
+static void install_at_exit_handler()
+{
+    // Poor Ruby programmers destructor
+    if( atexit(free_objects) != 0 )
+    {
+        free_objects();
+        rb_sys_fail("Failed to register atexit function");
+    }
+}
+
+void Init_coremidi()
+{
+    init_mutex();
+    
+    init_midi_data();
+    
+    install_at_exit_handler();
+    
+    mCoreMIDI = rb_define_module("CoreMIDI");
+    mCoreMIDIAPI = rb_define_module_under(mCoreMIDI, "API");
+    
+    rb_define_singleton_method(mCoreMIDIAPI, "create_input_port", t_create_input_port, 2);
+    rb_define_singleton_method(mCoreMIDIAPI, "create_client", t_create_client, 1);
+    rb_define_singleton_method(mCoreMIDIAPI, "get_sources", t_get_sources, 0);
+    rb_define_singleton_method(mCoreMIDIAPI, "get_num_sources", t_get_num_sources, 0);
+    rb_define_singleton_method(mCoreMIDIAPI, "connect_source_to_port", t_connect_source_to_port, 2);
+    rb_define_singleton_method(mCoreMIDIAPI, "disconnect_source_from_port", t_disconnect_source_from_port, 2);
+    rb_define_singleton_method(mCoreMIDIAPI, "check_for_new_data", t_check_for_new_data, 0);
+
+    // Define CoreMIDI::API::InputPort class
+    cInputPort = rb_define_class_under(mCoreMIDIAPI, "InputPort", rb_cObject);
+    rb_define_alloc_func(cInputPort, inputport_alloc);
+    rb_define_method(cInputPort, "initialize", inputport_initialize, 0);
+    
+    // Define CoreMIDI::API::MIDIClient class
+    cMIDIClient = rb_define_class_under(mCoreMIDIAPI, "MIDIClient", rb_cObject);
+    rb_define_alloc_func(cMIDIClient, midiclient_alloc);
+    rb_define_method(cMIDIClient, "initialize", midiclient_initialize, 0);
+}

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+$CPPFLAGS += " -I/System/Library/Frameworks/CoreMIDI.framework/Versions/Current/Headers"
+$LDFLAGS += " -framework CoreMIDI"
+
+create_makefile('coremidi')

data/lib/coremidi.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../ext/coremidi.bundle'
+#require 'coremidi/constants'
+
+module CoreMIDI
+  module API
+    MidiPacket = Struct.new(:timestamp, :data)
+  end
+
+  # Unused, but left here for documentation
+  def self.number_of_sources
+    API.get_num_sources
+  end
+
+  class Packet
+    # http://www.srm.com/qtma/davidsmidispec.html
+    def self.parse(data)
+      spec = {
+        0x80 => Events::NoteOff,
+        0x90 => lambda {|data| (data[Events::NoteOn.members.index("velocity")] == 0) ? Events::NoteOff : Events::NoteOn },
+        0xA0 => Events::KeyPressure,
+        0xC0 => Events::ProgramChange,
+        0xD0 => Events::ChannelPressure
+      }
+      
+      klass = spec.detect {|code, _|
+        data[0] & 0xF0 == code # First byte is the type code
+      }
+
+      return Events::Unknown.new(data) if klass.nil?
+
+      klass = klass.last
+      klass = klass.call(data) if klass.respond_to?(:call) # Resolve any lambdas into a class
+
+      klass.new(
+        data[0] & 0x0F, # Second byte contains the channel
+        *data[1..-1]
+      )
+    end
+  end
+
+  module Events
+    class NoteOn          < Struct.new(:channel, :pitch, :velocity); end;
+    class NoteOff         < Struct.new(:channel, :pitch, :velocity); end;
+    class KeyPressure     < Struct.new(:channel, :pitch, :pressure); end;
+    class ProgramChange   < Struct.new(:channel, :preset);           end; 
+    class ChannelPressure < Struct.new(:channel, :pressure);       end; 
+    class Unknown         < Struct.new(:data);                       end;
+  end
+
+  class Input
+    def self.register(client_name, port_name, source)
+      raise "name must be a String!" unless client_name.class == String
+
+      client = API.create_client(client_name) 
+      port = API.create_input_port(client, port_name)
+      API.connect_source_to_port(API.get_sources.index(source), port)
+
+      while true
+        data = API.check_for_new_data
+        if data && !data.empty?
+          data.each do |packet|
+            yield(Packet.parse(packet.data))
+          end
+        end
+        sleep 0.001
+      end
+    end
+  end
+end

data/spec/parsing_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'CoreMIDI::Packet.parse' do
+  def self.it_parses(data, expected)
+    describe "given data #{data.inspect}, creates an event" do
+      before(:each) do  
+        @packet = CoreMIDI::Packet.parse(data)
+      end
+
+      it "of type #{expected.class}" do
+        @packet.class.should == expected.class
+      end
+
+      expected.members.each do |member|
+        it "that has a #{member} of #{expected.send(member).inspect}" do
+          @packet.send(member).should == expected.send(member)
+        end
+      end
+    end
+  end
+
+  it_parses([0x90, 0x3C, 0x40], CoreMIDI::Events::NoteOn.new(0x00, 0x3C, 0x40)) # Channel 0, Middle C, half velocity
+  it_parses([0x91, 0x3C, 0x40], CoreMIDI::Events::NoteOn.new(0x01, 0x3C, 0x40)) # Channel 1, Middle C, half velocity
+  it_parses([0x80, 0x3C, 0x40], CoreMIDI::Events::NoteOff.new(0x00, 0x3C, 0x40)) # Channel 0, Middle C, half velocity
+  it_parses([0x81, 0x3C, 0x40], CoreMIDI::Events::NoteOff.new(0x01, 0x3C, 0x40))  # Channel 1, Middle C, half velocity
+  it_parses([0xC0, 0x01], CoreMIDI::Events::ProgramChange.new(0x00, 0x01)) # Channel 0, Preset #1
+  it_parses([0xC1, 0x02], CoreMIDI::Events::ProgramChange.new(0x01, 0x02)) # Channel 1, Preset #2
+  it_parses([0xA0, 0x3C, 0x64], CoreMIDI::Events::KeyPressure.new(0x00, 0x3C, 0x64)) # Channel 0, Middle C, half pressure
+  it_parses([0xA1, 0x3C, 0xFF], CoreMIDI::Events::KeyPressure.new(0x01, 0x3C, 0xFF)) # Channel 1, Middle C, full pressure
+  it_parses([0xD0, 0x64], CoreMIDI::Events::ChannelPressure.new(0x00, 0x64)) # Channel 0, half pressure
+  it_parses([0xD1, 0xFF], CoreMIDI::Events::ChannelPressure.new(0x01, 0xFF)) # Channel 1, full pressure
+
+  # This is technically a NoteOn event, but convention uses it most often in place of a note off event (setting velocity to 0)
+  it_parses([0x90, 0x3C, 0x00], CoreMIDI::Events::NoteOff.new(0x00, 0x3C, 0x00))  # Channel 0, Middle C, no velocity
+
+  describe 'when data does not match a known MIDI event,' do
+    it_parses([0xFF, 0xFF], CoreMIDI::Events::Unknown.new([0xFF, 0xFF]))
+  end
+
+  it 'creates a NoteOn event when status byte was provided by the last packet'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'coremidi'
+require 'spec'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: burke-coremidi
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Burke Libbey
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-22 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A very simple access layer to the OS X CoreMIDI library.
+email: burke@53cr.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- examples/example.rb
+- ext/coremidi.c
+- ext/extconf.rb
+- lib/coremidi.rb
+- spec/parsing_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/burke/coremidi
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A very simple access layer to the OS X CoreMIDI library.
+test_files: 
+- spec/parsing_spec.rb
+- spec/spec_helper.rb
+- examples/example.rb