midi-winmm 0.1.10

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2010-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,46 @@
+= midi-winmm
+
+== Summary
+
+Realtime MIDI input and output with Ruby for Windows/Cygwin.  Uses the WinMM system API
+
+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 which implements midi-winmm.  
+
+== Features
+
+* Input and output on multiple devices concurrently
+* Agnostically handle different MIDI Message types (including SysEx)
+* Timestamped input events
+
+== Requirements
+
+* {ffi}[http://github.com/ffi/ffi] (gem install ffi)
+
+== Install
+
+  gem install midi-winmm
+	
+== Examples
+
+* {input}[http://github.com/arirusso/midi-winmm/blob/master/examples/input.rb]
+* {output}[http://github.com/arirusso/midi-winmm/blob/master/examples/output.rb]
+
+({more}[http://github.com/arirusso/midi-winmm/blob/master/examples])
+	
+== Tests
+
+please see {test/config.rb}[http://github.com/arirusso/midi-winmm/blob/master/test/config.rb] before running tests
+
+== Documentation
+
+{rdoc}[http://rdoc.info/gems/midi-winmm]
+	
+== Author 
+
+{Ari Russo}[http://github.com/arirusso] <ari.russo at gmail.com>
+		
+== License
+
+Apache 2.0, See the file LICENSE
+
+Copyright (c) 2010-2011 Ari Russo  

data/lib/midi-winmm.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#
+# Set of modules and classes for interacting with MIDI functions 
+# of the WinMM System API
+#
+module MIDIWinMM
+  VERSION = "0.1.10"
+end
+
+require 'ffi'
+ 
+require 'midi-winmm/device'
+require 'midi-winmm/input'
+require 'midi-winmm/map'
+require 'midi-winmm/output'

data/lib/midi-winmm/device.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+module MIDIWinMM
+  
+  #
+  # Module containing methods used by both input and output devices when using the
+  # WinMM driver interface 
+  #
+  module Device
+
+    attr_reader :enabled, :id, :info, :name, :type
+    
+    alias_method :enabled?, :enabled
+    
+    def initialize(id, name, options = {}, &block)
+      @id = id
+      @info = options[:info]
+      @type = self.class.name.split('::').last.downcase.to_sym
+      @name = name
+    end    
+    
+    def self.all
+      all_by_type.values.flatten
+    end
+    
+    def self.all_by_type
+      types = { :input => Input,
+              :output => Output }
+      available_devices = { :input => [], :output => [] }
+      count = 0
+      types.each do |type, klass|
+       (0..(Map::cfunc(type, :getNumDevs)-1)).each do |i|
+          data = Map::DeviceInfo[type].new
+          Map::cfunc(type, :getDevCapsA, i, data.to_ptr, Map::DeviceInfo[type].size)
+          name = data[:szPname].to_s
+          dev = klass.new(i, name, :info => data)
+          available_devices[type] << dev
+        end
+      end
+      available_devices
+    end
+    
+    # select the first device of type <em>type</em>
+    def self.first(type)
+      all_by_type[type].first
+    end
+    
+    # select the last device of type <em>type</em>
+    def self.last(type)
+      all_by_type[type].last
+    end
+    
+    WinmmCallbackFlag = 0x30000 # we plan to use a callback to collect events
+    
+    private
+    
+    # High word 
+    #   High-order byte: Not used.
+    #   Low-order byte: Contains a second byte of MIDI data (when needed).
+    # Low word  
+    #   High-order byte:  Contains the first byte of MIDI data (when needed).
+    #   Low-order byte: Contains the MIDI status.
+    #
+    def dwmsg_to_array_of_bytes(m)
+      # there has to be a better way to do this
+      s = []
+      m = m.to_s(16)
+      (1..m.length).step(2) { |i| s << m[(m.length-i)-1, 2].hex }
+      s
+    end
+    
+    def error?(num)
+      Map::error?(num)
+    end
+    
+    def error(num)
+      Map::error(num)
+    end
+    
+  end
+  
+end

data/lib/midi-winmm/input.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+module MIDIWinMM
+  
+  #
+  # Input device class for the WinMM driver interface 
+  #
+  class Input
+    
+    include Device
+    
+    BufferSize = 256
+    
+    attr_reader :buffer
+    
+    # initializes this device
+    def enable(options = {}, &block)
+      init_input_buffer
+      handle_ptr = FFI::MemoryPointer.new(FFI.type_size(:int))
+      initialize_local_buffer
+      @event_callback = get_event_callback
+      
+      Map.winmm_func(:midiInOpen, handle_ptr, @id, @event_callback, 0, Device::WinmmCallbackFlag)
+      
+      @handle = handle_ptr.read_int
+      
+      Map.winmm_func(:midiInPrepareHeader, @handle, @header.pointer, @header.size)      
+      Map.winmm_func(:midiInAddBuffer, @handle, @header.pointer, @header.size)
+      Map.winmm_func(:midiInStart, @handle)
+
+      @enabled = true
+      
+      unless block.nil?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      else
+        self
+      end
+      
+    end
+    alias_method :start, :enable
+    alias_method :open, :enable
+    
+    #
+    # returns an array of MIDI event hashes as such:
+    # [ 
+    #   { :data => [144, 90, 100], :timestamp => 1024 },
+    #   { :data => [128, 90, 100], :timestamp => 1100 },
+    #   { :data => [146, 60, 120], :timestamp => 1200 }
+    # ]
+    #
+    # message data is an array of Numeric bytes
+    #
+    def gets
+      until queued_messages?
+      end
+      msgs = queued_messages
+      @pointer = @buffer.length
+      msgs
+    end
+    
+    # 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
+    alias_method :gets_hex, :gets_s
+    
+    # close the device
+    def close
+      Map.winmm_func(:midiInUnprepareHeader, @handle, @header.pointer, @header.size)
+      Map.winmm_func(:midiInStop, @handle)
+      Map.winmm_func(:midiInClose, @handle)
+      @enabled = false
+    end
+    
+    def self.first
+      Device.first(:input)
+    end
+
+    def self.last
+      Device.last(:input)
+    end
+    
+    def self.all
+      Device.all_by_type[:input]
+    end
+        
+    private
+    
+    def queued_messages
+      @buffer.slice(@pointer, @buffer.length - @pointer)
+    end
+    
+    def queued_messages?
+      @pointer < @buffer.length
+    end
+            
+    # prepare the header struct where input event information is held
+    def init_input_buffer
+      @header = Map::MIDIHdr.new
+      @header.write_data(Input::BufferSize)
+      @header[:dwBytesRecorded] = 0
+      @header[:dwFlags] = 0
+      @header[:dwUser] = 0
+      @header[:dwBufferLength] = Input::BufferSize
+    end
+    
+    # returns a Proc that is called when the device receives a message
+    def get_event_callback
+      Proc.new do |hMidiIn,wMsg,dwInstance,dwParam1,dwParam2|
+        msg_type = Map::CallbackMessageTypes[wMsg] || ''
+        case msg_type
+          when :input_data then 
+        	  msg = { :data => dwmsg_to_array_of_bytes(dwParam1), :timestamp => dwParam2 }
+        	  @buffer << msg
+          when :input_long_data then
+        	  @receiving_sysex = true
+			      data = @header[:lpData].read_string(Input::BufferSize).gsub(/ /, '')
+			      unless data.eql?("")
+			        str = data.unpack(("C" * (data.length-1)))
+			        msg = { :data => str, :timestamp => dwParam2 }
+        	    @buffer << msg
+        	  end      		
+        end
+      end
+    end
+    
+    def initialize_local_buffer
+      @pointer = 0
+      @buffer = []
+      def @buffer.clear
+        super
+        @pointer = 0
+      end
+    end
+    
+    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/lib/midi-winmm/map.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+module MIDIWinMM
+  
+  #
+  # Module containing C function and struct binding for the WinMM 
+  # driver interface library
+  #
+  module Map
+    
+    extend FFI::Library
+    ffi_lib 'Winmm'
+    ffi_convention :stdcall
+    
+    HeaderFlags = {
+      0x00000001 => :done,
+      0x00000002 => :prepared,
+      0x00000004 => :inqueue,
+      0x00000008 => :isstream
+    }
+    
+    CallbackMessageTypes = {
+      0x3C1 => :input_open,
+      0x3C2 => :input_close,
+      0x3C3 => :input_data,        
+      0x3C4 => :input_long_data,
+      0x3C5 => :input_error,
+      0x3C6 => :input_long_error,
+      0x3C7 => :output_open, 
+      0x3C8 => :output_close,
+      0x3C9 => :output_data,
+      0x3CC => :output_more_data
+    }
+    
+    Errors = {
+      1 => "Unspecified",
+      2 => "Bad Device ID",
+      3 => "Not Enabled", 
+      4 => "Allocation",
+      5 => "Invalid Handle",
+      6 => "No Driver",
+      7 => "No Memory",
+      8 => "Not Supported",
+      9 => "Bad Error Number",
+      10 => "Invalid Flag",
+      11 => "Invalid Parameter",
+      12 => "Handle Busy",
+      13 => "Invalid Alias"
+    }
+    
+    # Byte (8 bits). Declared as unsigned char.
+    typedef :uchar, :BYTE
+    # 32-bit unsigned integer. The range is 0 through 4,294,967,295 decimal.
+    typedef :uint32, :DWORD
+    # Unsigned long type for pointer precision. Use when casting a pointer to a long type.
+    typedef :ulong, :DWORD_PTR
+    # (L) Handle to an object. WinNT.h: #typedef PVOID HANDLE;
+    typedef :ulong, :HANDLE
+    # Handle for a MIDI input device.
+    typedef :HANDLE, :HMIDIIN
+    # Handle for a MIDI output device.
+    typedef :HANDLE, :HMIDIOUT
+    # system function result codes
+    typedef :uint, :MMRESULT
+    # Unsigned INT_PTR.
+    typedef :uint, :UINT_PTR
+    # 16-bit unsigned integer. The range is 0 through 65535 decimal.
+    typedef :ushort, :WORD
+    
+    class MIDIEvent < FFI::Struct
+      layout :dwDeltaTime, :ulong,
+        :dwStreamID, :ulong,
+        :dwEvent, :ulong,
+        :dwParms, [:ulong, 8]
+    end
+    
+    class MIDIHdr < FFI::Struct
+      layout :lpData, :pointer,
+        :dwBufferLength, :DWORD,
+        :dwBytesRecorded, :DWORD,
+        :dwUser, :DWORD_PTR,
+        :dwFlags, :DWORD,
+        :lpNext, :pointer,
+        :reserved, :DWORD_PTR,
+        :dwOffset, :DWORD,
+        :dwReserved, :DWORD_PTR  
+        
+        def write_data(size, string = '')
+          ptr = FFI::MemoryPointer.new(:char, size)
+          blank = " " * (size-string.length-1)
+          ptr.put_string(0, string + blank)
+          self[:lpData] = ptr
+          self[:dwBufferLength] = string.length
+        end
+    end
+    
+    class MIDIInputInfo < FFI::Struct
+      layout :wMid, :WORD,
+       :wPid, :WORD,
+       :vDriverVersion, :ulong,
+       :szPname, [:char, 32],
+       :dwSupport, :DWORD
+    end
+    
+    class MIDIOutputInfo < FFI::Struct
+       layout :wMid, :WORD,
+         :wPid, :WORD,
+         :vDriverVersion, :ulong,
+         :szPname, [:char, 32],
+         :wTechnology, :WORD,
+         :wVoices, :WORD,
+         :wNotes, :WORD,
+         :wChannelMask, :WORD,
+         :dwSupport, :DWORD
+    end
+    
+    DeviceInfo = {
+    
+    :input => MIDIInputInfo,
+    :output => MIDIOutputInfo
+
+    }
+    
+    # void CALLBACK MidiInProc(HMIDIIN hMidiIn,UINT wMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)
+    callback :input_callback, [:pointer, :uint, :DWORD_PTR, :DWORD_PTR, :DWORD_PTR], :void
+    
+    # void CALLBACK MidiOutProc(HMIDIOUT hmo, UINT wMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
+    callback :output_callback, [:pointer, :uint, :DWORD_PTR, :DWORD_PTR, :DWORD_PTR], :void
+
+    #
+    # initialize/close devices
+    #
+
+    # MMRESULT midiInOpen(LPHMIDIIN lphMidiIn, UINT_PTR uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwCallbackInstance, DWORD dwFlags)
+    # LPHMIDIIN = *HMIDIIN
+    attach_function :midiInOpen, [:pointer, :UINT_PTR, :input_callback, :DWORD_PTR, :DWORD], :MMRESULT
+    
+    # MMRESULT midiOutOpen(LPHMIDIOUT lphmo, UINT uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwCallbackInstance, DWORD dwFlags)
+    # LPHMIDIOUT = *HMIDIOUT
+    # :output_callback
+    attach_function :midiOutOpen, [:pointer, :uint, :output_callback, :DWORD_PTR, :DWORD], :MMRESULT
+    
+    attach_function :midiInClose, [:ulong], :ulong
+    attach_function :midiOutClose, [:ulong], :ulong
+    attach_function :midiInReset, [:pointer], :ulong
+    
+    # MMRESULT midiOutReset(HMIDIOUT hmo)
+    attach_function :midiOutReset, [:HMIDIOUT], :MMRESULT
+    
+    #
+    # for message output
+    #
+    
+    # MMRESULT midiOutShortMsg(HMIDIOUT hmo, DWORD dwMsg)
+    attach_function :midiOutShortMsg, [:HMIDIOUT, :DWORD], :MMRESULT
+    
+    # MMRESULT midiOutLongMsg(HMIDIOUT hmo, LPMIDIHDR lpMidiOutHdr,UINT cbMidiOutHdr)
+    # LPMIDIHDR = *MIDIHDR
+    attach_function :midiOutLongMsg, [:HMIDIOUT, :pointer, :uint], :MMRESULT
+    
+    # MMRESULT midiStreamOpen(LPHMIDISTRM lphStream,LPUINT puDeviceID, DWORD cMidi, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
+    attach_function :midiStreamOpen, [:pointer, :pointer, :DWORD, :DWORD_PTR, :DWORD_PTR, :DWORD], :MMRESULT    
+
+    # MMRESULT midiOutPrepareHeader(HMIDIOUT hmo, LPMIDIHDR lpMidiOutHdr, UINT cbMidiOutHdr)
+    attach_function :midiOutPrepareHeader, [:HMIDIOUT, :pointer, :uint], :MMRESULT
+    
+    #MMRESULT midiOutUnprepareHeader(HMIDIOUT hmo, LPMIDIHDR lpMidiOutHdr, UINT cbMidiOutHdr)
+    attach_function :midiOutUnprepareHeader, [:HMIDIOUT, :ulong, :uint], :MMRESULT
+    
+    #MMRESULT midiOutGetVolume(HMIDIOUT hmo, LPDWORD lpdwVolume)
+    attach_function :midiOutGetVolume, [:HMIDIOUT, :pointer], :MMRESULT
+    
+    # MMRESULT midiOutSetVolume(HMIDIOUT hmo, DWORD dwVolume)
+    attach_function :midiOutSetVolume, [:HMIDIOUT, :DWORD], :MMRESULT
+    
+    #
+    # input
+    #
+
+    # MMRESULT midiInPrepareHeader(HMIDIIN hMidiIn, LPMIDIHDR lpMidiInHdr, UINT cbMidiInHdr)
+    attach_function :midiInPrepareHeader, [:HMIDIIN, :pointer, :uint], :MMRESULT
+    
+    attach_function :midiInUnprepareHeader, [:HMIDIIN, :pointer, :uint], :MMRESULT
+    attach_function :midiInAddBuffer, [:HMIDIIN, :pointer, :uint], :MMRESULT
+    
+    # MMRESULT midiInStart(HMIDIIN hMidiIn)
+    attach_function :midiInStart, [:HMIDIIN], :MMRESULT
+    
+    # MMRESULT midiInStop(HMIDIIN hMidiIn)
+    attach_function :midiInStop, [:HMIDIIN], :MMRESULT
+    
+    #
+    # enumerate devices
+    #
+    
+    # UINT midiInGetNumDevs(void)
+    attach_function :midiInGetNumDevs, [], :uint
+    
+    # UINT midiOutGetNumDevs(void)
+    attach_function :midiOutGetNumDevs, [], :uint
+    
+    # MMRESULT midiInGetDevCaps(UINT_PTR uDeviceID, LPMIDIINCAPS lpMidiInCaps, UINT cbMidiInCaps);
+    attach_function :midiInGetDevCapsA, [:UINT_PTR, :pointer, :uint], :MMRESULT
+    
+    attach_function :midiOutGetDevCapsA, [:UINT_PTR, :pointer, :uint], :MMRESULT
+   
+    # shortcut for calling winmm midi functions
+    def self.cfunc(type, funcname, *args)
+      t = type.to_s.gsub(/put/,'') # convert output to out, input to in
+      name = funcname.to_s
+      name[0] = name[0,1].upcase # capitalize
+      t[0] = t[0,1].upcase # capitalize
+      self.send("midi#{t}#{name}", *args)
+    end
+    
+    def self.winmm_func(name, *args)
+      status = self.send(name, *args)
+      raise "#{name.to_s}: #{error(status)}" if error?(status)
+    end
+    
+    def self.error?(num)
+      !Map::Errors[num].nil?
+    end
+      
+    def self.error(num)
+      Map::Errors[num]
+    end
+    
+  end
+end

data/lib/midi-winmm/output.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+module MIDIWinMM
+  
+  #
+  # Output device class for the WinMM driver interface 
+  #
+  class Output
+    
+    include Device
+    
+    BufferSize = 2048
+    
+    attr_reader :buffer
+   
+    # initialize this device
+    def enable(options = {}, &block)
+      init_output_buffer
+      Map.winmm_func(:midiOutOpen, Output::HandlePointer, @id, Output::EventCallback, 0, Device::WinmmCallbackFlag)
+      @handle = HandlePointer.read_int
+      @enabled = true
+      unless block.nil?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      else
+        self
+      end
+    end
+    alias_method :start, :enable
+    alias_method :open, :enable
+
+    # close this device
+    def close
+      Map.winmm_func(:midiOutClose, @handle)
+      @enabled = false
+    end
+    
+    # returns a hash of fixnum values { :left => n, :right => n2 } 
+    def volume
+      volume = FFI::MemoryPointer.new(FFI.type_size(:ulong))
+      
+      Map.winmm_func(:midiOutGetVolume, @handle, volume)
+      
+      str = dwmsg_to_array_of_bytes(volume.read_ulong)
+      left = str.slice!(0,4)
+      
+      { :left => left.hex, :right => str.hex }
+    end
+    
+    # accepts either a hash of fixnums { :left => n, :right => n2 } or 
+    # a single fixnum that will be applied to both channels
+    def volume=(val)
+      vol = val.kind_of?(Hash) ? (val[:left] + (val[:right] << 16)) : (val + (val << 16))
+      Map.winmm_func(:midiOutSetVolume, @handle, vol)        
+    end
+    
+    def reset
+      Map.winmm_func(:midiOutReset, @handle)
+    end
+    
+    # send a message of an indeterminate type
+    def puts(*a)
+      case a.first
+        when Array    then puts_bytes(*a.first)
+        when Numeric  then puts_bytes(*a) 
+        when String   then puts_s(*a)
+      end
+    end
+    
+    # send a message consisting of Numeric bytes
+    def puts_bytes(*message_bytes)
+      format = "C" * message_bytes.size
+      
+      packed = message_bytes.pack(format)
+      data_pointer = FFI::MemoryPointer.new(message_bytes.size).put_bytes(0, packed)
+      
+      @header[:dwBufferLength] = message_bytes.size
+      @header[:dwBytesRecorded] = message_bytes.size
+      @header[:lpData] = data_pointer
+      
+      Map.winmm_func(:midiOutPrepareHeader, @handle, @header.pointer, @header.size)
+      
+      Map.winmm_func(:midiOutLongMsg, @handle, @header.pointer, @header.size)
+      
+    end
+    
+    # send a message consisisting 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
+    
+    def self.first
+      Device::first(:output)
+    end
+
+    def self.last
+      Device::last(:output)
+    end
+    
+    def self.all
+      Device.all_by_type[:output]
+    end
+    
+    private
+    
+    EventCallback = Proc.new do |hmo, wMsg, dwInstance, dwParam1, dwParam2|
+      msg_type = Map::CallbackMessageTypes[wMsg] || ''
+      if msg_type.eql?(:output_data)
+        header = dwParam1
+        handle = HandlePointer.read_int
+        Map.winmm_func(:midiOutUnprepareHeader, handle, header, Map::MIDIHdr.size)
+      end
+    end
+    
+    HandlePointer = FFI::MemoryPointer.new(FFI.type_size(:int))
+    
+    def init_output_buffer
+      @header = Map::MIDIHdr.new
+      d = FFI::MemoryPointer.new(:char, Output::BufferSize)
+      d.put_string(0, " " * (Output::BufferSize - 1)) # initialize with a string of spaces
+      @header[:lpData] = d.address
+      @header[:dwBufferLength] = Output::BufferSize
+      @header[:dwBytesRecorded] = 0
+      @header[:dwFlags] = 0
+      @header[:dwUser] = 0
+    end
+       
+  end
+  
+end

data/test/config.rb

@@ -0,0 +1,12 @@
+module TestHelper::Config
+  
+  include MIDIWinMM
+  
+  # adjust these constants to suit your hardware configuration 
+  # before running tests
+  
+  NumDevices = 4 # this is the total number of MIDI devices that are connected to your system
+  TestInput = Input.first # this is the device you wish to use to test input
+  TestOutput = Output.all[1] # likewise for output
+  
+end

data/test/helper.rb

@@ -0,0 +1,37 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'test/unit'
+require 'midi-winmm'
+
+module TestHelper
+  
+  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
+
+require File.dirname(__FILE__) + '/config'

data/test/test_input_buffer.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class InputBufferTest < Test::Unit::TestCase
+
+  include MIDIWinMM
+  include TestHelper
+  include TestHelper::Config # before running these tests, adjust the constants in config.rb to suit your hardware setup
+  # ** this test assumes that TestOutput is connected to TestInput
+  
+  def test_input_buffer
+    sleep(1)
+
+    messages = VariousMIDIMessages
+    bytes = []
+
+    TestOutput.open do |output|
+      TestInput.open do |input|
+
+        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,82 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class IoTest < Test::Unit::TestCase
+
+  include MIDIWinMM
+  include TestHelper
+  include TestHelper::Config # before running these tests, adjust the constants in config.rb to suit your hardware setup
+  # ** this test assumes that TestOutput is connected to TestInput
+
+  def test_full_io
+    sleep(1)
+    messages = VariousMIDIMessages
+    messages_arr = messages.inject { |a,b| a+b }.flatten
+    received_arr = []
+    pointer = 0
+    TestOutput.open do |output|
+      TestInput.open do |input|
+
+        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(1) # pause between tests
+
+    messages = VariousMIDIByteStrMessages
+    messages_str = messages.join
+    received_str = ""
+    pointer = 0
+
+    TestOutput.open do |output|
+      TestInput.open do |input|
+
+        messages.each do |msg|
+
+          $>.puts "sending: " + msg.inspect
+
+          output.puts(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,67 @@
+--- !ruby/object:Gem::Specification
+name: midi-winmm
+version: !ruby/object:Gem::Version
+  version: 0.1.10
+  prerelease: 
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: &70311577275740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70311577275740
+description: Realtime MIDI IO with Ruby in Windows/Cygwin using the WinMM system API
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/midi-winmm/device.rb
+- lib/midi-winmm/input.rb
+- lib/midi-winmm/map.rb
+- lib/midi-winmm/output.rb
+- lib/midi-winmm.rb
+- test/config.rb
+- test/helper.rb
+- test/test_input_buffer.rb
+- test/test_io.rb
+- LICENSE
+- README.rdoc
+homepage: http://github.com/arirusso/midi-winmm
+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: midi-winmm
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Realtime MIDI IO with Ruby in Windows/Cygwin
+test_files: []