rtmidi 0.1

data/ext/ruby-rtmidi.cpp

@@ -0,0 +1,108 @@
+#include "RtMidi.h"
+#include "RtError.h"
+#include <vector>
+#include <iostream> // TODO: can probably stop including this later when done debugging
+
+#include "ruby-rtmidi.h"
+
+
+//================================================
+// INPUT
+
+rtmidi_ptr midiin_new() {
+  return static_cast<void *>(new RtMidiIn());
+}
+
+void midiin_delete(rtmidi_ptr p) {
+  delete static_cast<RtMidiIn *>(p);
+}
+
+int midiin_port_count(rtmidi_ptr p) {
+  RtMidiIn *midiin = static_cast<RtMidiIn *>(p);  
+  return midiin->getPortCount();
+}
+
+const char* midiin_port_name(rtmidi_ptr p, int port_index) {
+  RtMidiIn *midiin = static_cast<RtMidiIn *>(p);  
+  return midiin->getPortName(port_index).c_str(); // getPortName returns a std::string, use c_str() to be convert to char*
+}
+
+void midiin_open_port(rtmidi_ptr p, int port_index) {
+  RtMidiIn *midiin = static_cast<RtMidiIn *>(p);
+  midiin->openPort(port_index);
+}
+
+void midiin_close_port(rtmidi_ptr p) {
+  RtMidiIn *midiin = static_cast<RtMidiIn *>(p);
+  midiin->closePort();
+}
+
+void midiin_ignore_types(rtmidi_ptr p, bool sysex, bool timing, bool active_sensing) {
+  RtMidiIn *midiin = static_cast<RtMidiIn *>(p);
+  midiin->ignoreTypes(sysex, timing, active_sensing);
+}
+
+void midiin_callback_proxy( double deltatime, std::vector< unsigned char > *message, void *userData )
+{
+  unsigned int byte_count = message->size();
+  // for ( unsigned int i=0; i<byte_count; i++ )
+  //   std::cout << "Byte " << i << " = " << (int)message->at(i) << ", ";
+  // if ( byte_count > 0 )
+  //   std::cout << "stamp = " << deltatime << std::endl; # TODO: do we care about the deltatime?
+  int byte1 = 0, byte2 = 0, byte3 = 0;
+  if(byte_count > 0) byte1 = (int)message->at(0);
+  if(byte_count > 1) byte2 = (int)message->at(1);
+  if(byte_count > 2) byte3 = (int)message->at(2);
+  ((rtmidi_callback)userData)(byte1, byte2, byte3);
+}
+
+void midiin_set_callback(rtmidi_ptr p, rtmidi_callback callback) {
+  RtMidiIn *midiin = static_cast<RtMidiIn *>(p);
+  midiin->setCallback(midiin_callback_proxy, (void *)callback);
+}
+
+void midiin_cancel_callback(rtmidi_ptr p) {
+  RtMidiIn *midiin = static_cast<RtMidiIn *>(p);
+  midiin->cancelCallback();
+}
+
+
+//================================================
+// OUTPUT
+
+rtmidi_ptr midiout_new() {
+  return static_cast<void *>(new RtMidiOut());
+}
+
+void midiout_delete(rtmidi_ptr p) {
+  delete static_cast<RtMidiOut *>(p);
+}
+
+int midiout_port_count(rtmidi_ptr p) {
+  RtMidiOut *midiout = static_cast<RtMidiOut *>(p);  
+  return midiout->getPortCount();
+}
+
+const char* midiout_port_name(rtmidi_ptr p, int port_index) {
+  RtMidiOut *midiout = static_cast<RtMidiOut *>(p);  
+  return midiout->getPortName(port_index).c_str(); // getPortName returns a std::string, use c_str() to be convert to char*
+}
+
+void midiout_open_port(rtmidi_ptr p, int port_index) {
+  RtMidiOut *midiout = static_cast<RtMidiOut *>(p);
+  midiout->openPort(port_index);
+}
+
+void midiout_close_port(rtmidi_ptr p) {
+  RtMidiOut *midiout = static_cast<RtMidiOut *>(p);
+  midiout->closePort();    
+}
+
+void midiout_send_message(rtmidi_ptr p, int byte1, int byte2, int byte3) {
+  RtMidiOut *midiout = static_cast<RtMidiOut *>(p);
+  static std::vector<unsigned char> message(3); // static so we don't keep constructing and destroying objects
+  message[0] = byte1;
+  message[1] = byte2;
+  message[2] = byte3;
+  midiout->sendMessage(&message);
+}

data/ext/ruby-rtmidi.h

@@ -0,0 +1,44 @@
+extern "C"
+{
+  typedef void* rtmidi_ptr;
+  typedef void (*rtmidi_callback)(int byte1, int byte2, int byte3);
+
+  //================================================
+  // INPUT
+
+  rtmidi_ptr midiin_new();
+
+  void midiin_delete(rtmidi_ptr midiin);
+
+  int midiin_port_count(rtmidi_ptr midiin);
+
+  const char* midiin_port_name(rtmidi_ptr midiin, int port_index);
+
+  void midiin_open_port(rtmidi_ptr p, int port_index);
+
+  void midiin_close_port(rtmidi_ptr p);
+
+  void midiin_ignore_types(rtmidi_ptr p, bool sysex, bool timing, bool active_sensing);
+
+  void midiin_set_callback(rtmidi_ptr p, rtmidi_callback callback);
+
+  void midiin_cancel_callback(rtmidi_ptr p);
+  
+
+  //================================================
+  // OUTPUT
+
+  rtmidi_ptr midiout_new();
+
+  void midiout_delete(rtmidi_ptr midiout);
+
+  int midiout_port_count(rtmidi_ptr midiout);
+
+  const char* midiout_port_name(rtmidi_ptr midiout, int port_index);
+
+  void midiout_open_port(rtmidi_ptr p, int port_index);
+
+  void midiout_close_port(rtmidi_ptr p);
+
+  void midiout_send_message(rtmidi_ptr p, int byte1, int byte2, int byte3);
+};

data/lib/rtmidi.rb

@@ -0,0 +1,4 @@
+require 'ffi'
+require 'rtmidi/interface.rb'
+require 'rtmidi/in.rb'
+require 'rtmidi/out.rb'

data/lib/rtmidi/in.rb

@@ -0,0 +1,76 @@
+module RtMidi
+
+  # Ruby representation of a RtMidiIn C++ object
+  # @see Out
+  class In
+
+    # Create a new RtMidiIn wrapper object.
+    def initialize
+      @midiin = Interface::midiin_new()
+      at_exit{ Interface::midiin_delete @midiin }
+    end
+
+    # The number of MIDI input ports available.
+    def port_count      
+      @port_count ||= Interface::midiin_port_count(@midiin)
+    end
+
+    # The name of the MIDI input port at the given index.
+    # @see #port_names
+    def port_name(index)
+      port_names[index]
+    end
+
+    # The list of all MIDI input port names.
+    #
+    # The index of a port in this list is the index to be passed to {#port_name} and {#open_port}.
+    #
+    # @see #port_name
+    # @see #open_port
+    def port_names
+      @port_namess ||= (
+        names = []
+        port_count.times{|i| names << Interface::midiin_port_name(@midiin, i) }
+        names
+      )       
+    end
+
+    # Open the MIDI input port at the given index.
+    # @see #port_names
+    def open_port(index)
+      Interface::midiin_open_port(@midiin, index)
+    end
+
+    # Close all opened ports.
+    def close_ports()
+      Interface::midiin_close_port(@midiin)
+    end
+
+    # TODO: enable sysex listening by hooking up to midiin_ignore_types
+    # but that will require a more flexible callback interface.
+
+    # Setup a callback block to handle incoming MIDI channel messages from opened ports.
+    #
+    # The block should receive 3 bytes (Ruby integers)
+    #
+    # All messages are assumed to have 3 bytes.
+    # Some channel messages only have 2 bytes in which case the 3rd byte is 0.
+    # @example
+    #          midiin.set_callback do |byte1, byte2, byte3|
+    #            puts "#{byte1} #{byte2} #{byte3}"
+    #          end
+    # @see #open_port
+    # @see #cancel_callback
+    def set_callback &callback      
+      Interface::midiin_set_callback(@midiin, callback)
+    end
+
+    # Cancel previously registered callbacks.
+    # @see #set_callback
+    def cancel_callback
+      Interface::midiin_cancel_callback(@midiin)
+    end
+
+  end
+
+end

data/lib/rtmidi/interface.rb

@@ -0,0 +1,67 @@
+module RtMidi
+
+  # The interface to RtMidi C++ code
+  # @see RtMidi::In
+  # @see RtMidi::Out
+  module Interface
+    extend FFI::Library
+    ffi_lib "ext/ruby-rtmidi.so"
+  
+    #####################################
+    # INPUT
+  
+    # rtmidi_ptr create_rtmidiin();
+    attach_function :midiin_new, [], :pointer
+  
+    # void delete_midiin(rtmidi_ptr midiin);
+    attach_function :midiin_delete, [:pointer], :void
+  
+    # int midiin_port_count(rtmidi_ptr midiin);
+    attach_function :midiin_port_count, [:pointer], :int
+  
+    # const char * midiin_port_name(rtmidi_ptr midiin, int port_index);
+    attach_function :midiin_port_name, [:pointer, :int], :string
+  
+    # void midiin_open_port(rtmidi_ptr p, int port_index);
+    attach_function :midiin_open_port, [:pointer, :int], :void
+
+    # void midiin_close_port(rtmidi_ptr p, int port_index);
+    attach_function :midiin_close_port, [:pointer], :void
+
+    # void midiin_ignore_types(rtmidi_ptr p, bool sysex, bool timing, bool active_sensing);
+    attach_function :midiin_ignore_types, [:pointer, :bool, :bool, :bool], :void
+
+    # void midiin_set_callback(rtmidi_ptr p, rtmidi_callback callback);
+    callback :rtmidi_callback, [:int, :int, :int], :void
+    attach_function :midiin_set_callback, [:pointer, :rtmidi_callback], :void
+    
+    # void midiin_cancel_callback(rtmidi_ptr p);
+    attach_function :midiin_cancel_callback, [:pointer], :void
+
+
+    #####################################
+    # OUTPUT
+  
+    # rtmidi_ptr new_midiout();
+    attach_function :midiout_new, [], :pointer
+  
+    # void delete_midiout(rtmidi_ptr midiout);
+    attach_function :midiout_delete, [:pointer], :void
+  
+   # int midiout_port_count(rtmidi_ptr midiout);
+    attach_function :midiout_port_count, [:pointer], :int
+  
+    # const char * midiout_port_name(rtmidi_ptr midiout, int port_index);
+    attach_function :midiout_port_name, [:pointer, :int], :string
+
+    # void midiout_open_port(rtmidi_ptr p, int port_index);
+    attach_function :midiout_open_port, [:pointer, :int], :void
+  
+    # void midiout_close_port(rtmidi_ptr p);
+    attach_function :midiout_close_port, [:pointer], :void
+
+    # void midiout_message(rtmidi_ptr p, int byte1, int byte2, int byte3);
+    attach_function :midiout_send_message, [:pointer, :int, :int, :int], :void    
+  end
+
+end

data/lib/rtmidi/out.rb

@@ -0,0 +1,59 @@
+module RtMidi
+
+  # Ruby representation of a RtMidiOut C++ object
+  # @see In
+  class Out
+
+    # Create a new RtMidiOut wrapper object.
+    def initialize
+      @midiout = Interface::midiout_new()
+      at_exit{ Interface::midiout_delete @midiout }
+    end
+
+    # The number of MIDI output ports available.
+    def port_count      
+      @port_count ||= Interface::midiout_port_count(@midiout)
+    end
+
+    # The name of the MIDI output port at the given index.
+    # @see #port_names
+    def port_name(index)
+      port_names[index]
+    end
+
+    # The list of all MIDI output port names.
+    #
+    # The index of a port in this list is the index to be passed to {#port_name} and {#open_port}.
+    #
+    # @see #port_name
+    # @see #open_port
+    def port_names
+      @port_namess ||= (
+        names = []
+        port_count.times{|i| names << Interface::midiout_port_name(@midiout, i) }
+        names
+      )       
+    end
+
+    # Open the MIDI output port at the given index.
+    # @see #port_names
+    def open_port(index)
+      Interface::midiout_open_port(@midiout, index)
+    end
+
+    # Close all opened ports.
+    def close_ports()
+      Interface::midiout_close_port(@midiout)
+    end
+
+    # Send a 3-byte MIDI channel message to the opened port.
+    #
+    # Some channel messages only have 2 bytes in which case the 3rd byte is ignored.
+    # @see #open_port
+    def send_message(byte1, byte2, byte3=0)
+      Interface::midiout_send_message(@midiout, byte1, byte2, byte3)
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: rtmidi
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Adam Murray
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: Ruby wrapper for RtMidi, a cross-platform C++ library for realtime MIDI
+  input and output.
+email: adam@compusition.com
+executables: []
+extensions:
+- ext/Rakefile
+extra_rdoc_files: []
+files:
+- Rakefile
+- DEV_NOTES.md
+- README.md
+- LICENSE.txt
+- .yardopts
+- lib/rtmidi/in.rb
+- lib/rtmidi/interface.rb
+- lib/rtmidi/out.rb
+- lib/rtmidi.rb
+- ext/Rakefile
+- ext/rtmidi-2.0.1/include/ks.h
+- ext/rtmidi-2.0.1/include/ksmedia.h
+- ext/rtmidi-2.0.1/RtError.h
+- ext/rtmidi-2.0.1/RtMidi.cpp
+- ext/rtmidi-2.0.1/RtMidi.h
+- ext/rtmidi-2.0.1/RtMidi.o
+- ext/ruby-rtmidi.cpp
+- ext/ruby-rtmidi.h
+- ext/ruby-rtmidi.o
+- ext/ruby-rtmidi.so
+- examples/list_ports.rb
+- examples/monitor_input.rb
+- examples/play_notes.rb
+homepage: http://github.com/adamjmurray/ruby-rtmidi
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- gcc
+- g++
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Ruby-RtMidi
+test_files: []
+has_rdoc: