alsa-rawmidi 0.2.14

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,45 @@
+= alsa-rawmidi
+
+== Summary
+
+Perform low level realtime MIDI input and output in Ruby for Linux.  Uses the ALSA RawMIDI driver interface 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 alsa-rawmidi.  
+
+== 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)
+* libasound, libasound-dev packages
+
+== Install
+
+* gem install alsa-rawmidi
+	
+== Examples
+
+* {input}[http://github.com/arirusso/alsa-rawmidi/blob/master/examples/input.rb]
+* {output}[http://github.com/arirusso/alsa-rawmidi/blob/master/examples/output.rb]
+	
+== Tests
+
+* please see {test/config.rb}[http://github.com/arirusso/alsa-rawmidi/blob/master/test/config.rb] before running tests
+
+== Documentation
+
+* {rdoc}[http://rdoc.info/gems/alsa-rawmidi]
+		
+== 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/alsa-rawmidi.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+#
+# Set of modules and classes for interacting with the ALSA Driver Interface
+#
+module AlsaRawMIDI
+    VERSION = "0.2.14"
+end
+
+require 'ffi'
+ 
+require 'alsa-rawmidi/device'
+require 'alsa-rawmidi/input'
+require 'alsa-rawmidi/map'
+require 'alsa-rawmidi/output'
+require 'alsa-rawmidi/soundcard'

data/lib/alsa-rawmidi/device.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+module AlsaRawMIDI
+
+  #
+  # Module containing methods used by both input and output devices when using the
+  # ALSA driver interface
+  #
+  module Device
+
+                # has the device been initialized?
+    attr_reader :enabled, 
+                # the alsa id of the device
+                :system_id,
+                # a unique numerical id for the device
+                :id, 
+                :name,
+                :subname,
+                # :input or :output
+                :type 
+
+    alias_method :enabled?, :enabled
+    
+    def initialize(options = {}, &block)
+      @id = options[:id]
+      @name = options[:name]
+      @subname = options[:subname]
+      @system_id = options[:system_id]
+      
+      # cache the type name so that inspecting the class isn't necessary each time
+      @type = self.class.name.split('::').last.downcase.to_sym
+
+      @enabled = false
+    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
+
+    # a Hash of :input and :output devices
+    def self.all_by_type
+      available_devices = { :input => [], :output => [] }
+      device_count = 0
+      32.times do |i|
+        card = Soundcard.find(i)
+        unless card.nil?
+          available_devices.keys.each do |type|
+            devices = card.subdevices[type]
+            devices.each do |dev|
+              dev.send(:id=, device_count)
+              device_count += 1
+            end
+            available_devices[type] += devices
+          end
+        end
+      end
+      available_devices
+    end
+
+    # all devices of both types
+    def self.all
+      all_by_type.values.flatten
+    end
+    
+    private
+    
+    def id=(id)
+      @id = id
+    end
+
+  end
+
+end

data/lib/alsa-rawmidi/input.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+module AlsaRawMIDI
+	
+  #
+  # Input device class
+  #
+  class Input
+
+    include Device
+
+    BufferSize = 256
+    
+    attr_reader :buffer
+        
+    #
+    # returns an array of MIDI event hashes as such:
+    #   [
+    #     { :data => [144, 60, 100], :timestamp => 1024 },
+    #     { :data => [128, 60, 100], :timestamp => 1100 },
+    #     { :data => [144, 40, 120], :timestamp => 1200 }
+    #   ]
+    #
+    # the data is an array of Numeric bytes
+    # the timestamp is the number of millis since this input was enabled
+    #
+    def gets
+      until queued_messages?
+      end
+      msgs = queued_messages
+      @pointer = @buffer.length
+      msgs
+    end
+    alias_method :read, :gets
+        
+    # 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 { |m| m[:data] = numeric_bytes_to_hex_string(m[:data]) }
+      msgs
+    end
+    alias_method :gets_bytestr, :gets_s
+    alias_method :gets_hex, :gets_s
+
+    # enable this the input for use; can be passed a block
+    def enable(options = {}, &block)
+      handle_ptr = FFI::MemoryPointer.new(FFI.type_size(:int))
+      Map.snd_rawmidi_open(handle_ptr, nil, @system_id, Map::Constants[:SND_RAWMIDI_NONBLOCK])
+      @handle = handle_ptr.read_int
+      @enabled = true
+      @start_time = Time.now.to_f
+      initialize_buffer
+      spawn_listener!
+      unless block.nil?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      else
+        self
+      end
+    end
+    alias_method :open, :enable
+    alias_method :start, :enable
+
+    # close this input
+    def close
+      Thread.kill(@listener)
+      Map.snd_rawmidi_drain(@handle)
+      Map.snd_rawmidi_close(@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 initialize_buffer
+      @pointer = 0
+      @buffer = []
+      def @buffer.clear          
+        super
+        @pointer = 0
+      end
+    end
+    
+    def now
+      ((Time.now.to_f - @start_time) * 1000)
+    end
+
+    # give a message its timestamp and package it in a Hash
+    def get_message_formatted(raw, time)
+      { :data => hex_string_to_numeric_bytes(raw), :timestamp => time }
+    end
+    
+    def queued_messages
+      @buffer.slice(@pointer, @buffer.length - @pointer)
+    end
+    
+    def queued_messages?
+      @pointer < @buffer.length
+    end
+
+    # launch a background thread that collects messages
+    # and holds them for the next call to gets*
+    def spawn_listener!
+      t = 1.0/1000   
+      @listener = Thread.fork do       
+        loop do
+          while (raw = poll_system_buffer!).nil?
+            sleep(t)
+          end
+          populate_local_buffer(raw) unless raw.nil?
+        end
+      end
+    end
+    
+    # collect messages from the system buffer
+    def populate_local_buffer(msgs)      
+      @buffer << get_message_formatted(msgs, now) unless msgs.nil?
+    end
+
+    # Get the next bytes from the buffer
+    def poll_system_buffer!
+      b = FFI::MemoryPointer.new(:uint8, Input::BufferSize)
+      if (err = Map.snd_rawmidi_read(@handle, b, Input::BufferSize)) < 0
+        raise "Can't read MIDI input: #{Map.snd_strerror(err)}" unless err.eql?(-11)
+      end
+      #Map.snd_rawmidi_drain(@handle)
+      rawstr = b.get_bytes(0,Input::BufferSize)
+      str = rawstr.unpack("A*").first.unpack("H*").first.upcase
+      str.nil? || str.eql?("") ? nil : str
+    end
+    
+    # convert byte str to byte array 
+    def hex_string_to_numeric_bytes(str)
+      str = str.dup
+      bytes = []
+      until str.eql?("")
+        bytes << str.slice!(0, 2).hex
+      end
+      bytes
+    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/alsa-rawmidi/map.rb

@@ -0,0 +1,242 @@
+#!/usr/bin/env ruby
+
+module AlsaRawMIDI
+
+  #
+  # libasound RawMIDI struct, enum and function bindings
+  #
+  module Map
+
+    extend FFI::Library
+    ffi_lib 'libasound'
+
+    Constants = {
+      :SND_RAWMIDI_STREAM_OUTPUT => 0,
+      :SND_RAWMIDI_STREAM_INPUT => 1,
+      :SND_RAWMIDI_APPEND => 0x0001,
+      :SND_RAWMIDI_NONBLOCK =>  0x0002,
+      :SND_RAWMIDI_SYNC =>  0x0004
+    }
+    
+    typedef :ulong, :SndCtlType
+    typedef :ulong, :SndCtl
+    typedef :ulong, :SndRawMIDI
+
+    # snd_ctl
+    class SndCtl < FFI::Struct
+
+      layout :dl_handle, :pointer, # void*
+                :name, :pointer, # char*
+                :type, :SndCtlType,
+                :ops, :pointer, # const snd_ctl_ops_t*
+                :private_data, :pointer, # void*
+                :nonblock, :ulong,
+                :poll_fd, :ulong,
+                :async_handlers, :ulong
+    end
+
+    # snd_ctl_card_info
+    class SndCtlCardInfo < FFI::Struct
+      layout :card, :int, # card number
+                 :pad, :int, # reserved for future (was type)
+                 :id, [:uchar, 16], # ID of card (user selectable)
+                 :driver, [:uchar, 16], # Driver name
+                 :name, [:uchar, 32], # Short name of soundcard
+                 :longname, [:uchar, 80], # name + info text about soundcard
+                 :reserved_, [:uchar, 16], # reserved for future (was ID of mixer)
+                 :mixername, [:uchar, 80], # visual mixer identification
+                 :components, [:uchar, 128] # card components / fine identification, delimited with one space (AC97 etc..)
+    end
+
+    # snd_rawmidi_info
+    class SndRawMIDIInfo < FFI::Struct
+      layout :device, :uint, # RO/WR (control): device number
+                :subdevice, :uint, # RO/WR (control): subdevice number
+                :stream, :int, # WR: stream
+                :card, :int, # R: card number
+                :flags, :uint, # SNDRV_RAWMIDI_INFO_XXXX
+                :id, [:uchar, 64], # ID (user selectable)
+                :name, [:uchar, 80], # name of device
+                :subname, [:uchar, 32], # name of active or selected subdevice
+                :subdevices_count, :uint,
+                :subdevices_avail, :uint,
+                :reserved, [:uchar, 64] # reserved for future use
+    end
+
+    # timespec
+    class Timespec < FFI::Struct
+      layout :tv_sec, :time_t, # Seconds since 00:00:00 GMT
+                 :tv_nsec, :long # Additional nanoseconds since
+    end
+
+    # snd_rawmidi_status
+    class SndRawMIDIStatus < FFI::Struct
+      layout :stream, :int,
+                 :timestamp, Timespec.by_value, # Timestamp
+                 :avail, :size_t, # available bytes
+                 :xruns, :size_t, # count of overruns since last status (in bytes)
+                 :reserved, [:uchar, 64] # reserved for future use
+    end
+
+    # Simple doubly linked list implementation
+    class LinkedList < FFI::Struct
+      layout :next, :pointer, # *LinkedList
+                 :prev, :pointer # *LinkedList
+    end
+
+    # snd_rawmidi
+    class SndRawMIDI < FFI::Struct
+      layout :card, :pointer, # *snd_card
+                 :list, LinkedList.by_value,
+                 :device, :uint, # device number
+                 :info_flags, :uint, # SNDRV_RAWMIDI_INFO_XXXX
+                 :id, [:char, 64],
+                 :name, [:char, 80]
+    end
+
+    # spinlock_t
+    class Spinlock < FFI::Struct
+      layout :lock, :uint
+    end
+
+    # wait_queue_head_t
+    class WaitQueueHead < FFI::Struct
+      layout :lock, Spinlock.by_value,
+                 :task_list, LinkedList.by_value
+    end
+
+    class AtomicT < FFI::Struct
+      layout :counter, :int # volatile int counter
+    end
+
+    class Tasklet < FFI::Struct
+      layout :next, :pointer,   # pointer to the next tasklet in the list / void (*func) (unsigned long)
+                 :state, :ulong,    # state of the tasklet
+                 :count, AtomicT.by_value, # reference counter
+                 :func,  :pointer,  # tasklet handler function / void (*func) (unsigned long)
+                 :data,  :ulong     # argument to the tasklet function
+    end
+
+    # snd_rawmidi_runtime
+    class SndRawMIDIRuntime < FFI::Struct
+      layout :drain, :uint, 1, # drain stage
+                 :oss, :uint, 1, # OSS compatible mode
+                 # midi stream buffer
+                 :buffer, :pointer, # uchar* / buffer for MIDI data
+                 :buffer_size, :size_t, # size of buffer
+                 :appl_ptr, :size_t, # application pointer
+                 :hw_ptr, :size_t, # hardware pointer
+                 :avail_min, :size_t, # min avail for wakeup
+                 :avail, :size_t, # max used buffer for wakeup
+                 :xruns, :size_t, # over/underruns counter
+                 # misc
+                 :lock, Spinlock.by_value,
+                 :sleep, WaitQueueHead.by_value,
+                 # event handler (new bytes, input only)
+                 :substream, :pointer, # void (*event)(struct snd_rawmidi_substream *substream);
+                 # defers calls to event [input] or ops->trigger [output]
+                 :tasklet, Tasklet.by_value,
+                 :private_data, :pointer, # void*
+                 :private_free, :pointer # void (*private_free)(struct snd_rawmidi_substream *substream)
+    end
+
+    # snd_rawmidi_params
+    class SndRawMIDIParams < FFI::Struct
+      layout :stream, :int,
+                 :buffer_size, :size_t, # queue size in bytes
+                 :avail_min, :size_t, # minimum avail bytes for wakeup
+                 :no_active_sensing, :uint, 1, # do not send active sensing byte in close()
+                 :reserved, [:uchar, 16] # reserved for future use
+    end
+
+    #
+    # snd_card
+    #
+
+    # Try to load the driver for a card.
+    attach_function :snd_card_load, [:int], :int # (int card)
+    # Try to determine the next card.
+    attach_function :snd_card_next, [:pointer], :int # (int* card)
+    # Convert card string to an integer value.
+    attach_function :snd_card_get_index, [:pointer], :int # (const char* name)
+    # Obtain the card name.
+    attach_function :snd_card_get_name, [:int, :pointer], :int # (int card, char **name)
+    # Obtain the card long name.
+    attach_function :snd_card_get_longname, [:int, :pointer], :int # (int card, char **name)
+
+    #
+    # snd_ctl
+    #
+
+    # Opens a CTL.
+    attach_function :snd_ctl_open, [:pointer, :pointer, :int], :int #  (snd_ctl_t **ctl, const char *name, int mode)
+    # Opens a CTL using local configuration.
+    attach_function :snd_ctl_open_lconf, [:pointer, :pointer, :int, :pointer], :int # (snd_ctl_t **ctl, const char *name, int mode, snd_config_t *lconf)
+    # close CTL handle
+    attach_function :snd_ctl_close, [:pointer], :int #(snd_ctl_t *ctl)
+    # set nonblock mode
+    attach_function :snd_ctl_nonblock, [:pointer, :int], :int # (snd_ctl_t *ctl, int nonblock)
+    # Get card related information.
+    attach_function :snd_ctl_card_info, [:pointer, :pointer], :int # (snd_ctl_t *ctl, snd_ctl_card_info_t *info)
+    # Get card name from a CTL card info.
+    attach_function :snd_ctl_card_info_get_name, [:pointer], :string # (const snd_ctl_card_info_t *obj) / const char*
+    # Get info about a RawMidi device.
+    attach_function :snd_ctl_rawmidi_info, [:SndCtl, :pointer], :int # (snd_ctl_t *ctl, snd_rawmidi_info_t *info)
+    # Get next RawMidi device number.
+    attach_function :snd_ctl_rawmidi_next_device, [:SndCtl, :pointer], :int # (snd_ctl_t *ctl, int *device)
+
+    #
+    # snd_rawmidi
+    #
+
+    # close RawMidi handle
+    attach_function :snd_rawmidi_close, [:SndRawMIDI], :int # (snd_rawmidi_t *rmidi)
+    # drain all bytes in the rawmidi I/O ring buffer
+    attach_function :snd_rawmidi_drain, [:SndRawMIDI], :int # (snd_rawmidi_t *rmidi)    
+    # drop all bytes in the rawmidi I/O ring buffer immediately
+    attach_function :snd_rawmidi_drop, [:SndRawMIDI], :int # int ( snd_rawmidi_t * rawmidi)
+    # set nonblock mode  
+    attach_function :snd_rawmidi_nonblock, [:SndRawMIDI, :int], :int # (snd_rawmidi_t *rmidi, int nonblock)
+    # Opens a new connection to the RawMidi interface.
+    attach_function :snd_rawmidi_open, [:pointer, :pointer, :string, :int], :int # (snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, const char *name, int mode)
+    # Opens a new connection to the RawMidi interface using local configuration.
+    attach_function :snd_rawmidi_open_lconf, [:pointer, :pointer, :string, :int, :pointer], :int #(snd_rawmidi_t **in_rmidi, snd_rawmidi_t **out_rmidi, const char *name, int mode, snd_config_t *lconf)
+    # read MIDI bytes from MIDI stream
+    attach_function :snd_rawmidi_read, [:SndRawMIDI, :pointer, :size_t], :ssize_t # (snd_rawmidi_t *rmidi, void *buffer, size_t size)
+    # write MIDI bytes to MIDI stream
+    attach_function :snd_rawmidi_write, [:SndRawMIDI, :ulong, :size_t], :ssize_t # (snd_rawmidi_t *rmidi, const void *buffer, size_t size)
+
+    #
+    # snd_rawmidi_info
+    #
+
+    enum :snd_rawmidi_stream, [
+              'SND_RAWMIDI_STREAM_OUTPUT', 0,
+              'SND_RAWMIDI_STREAM_INPUT', 1,
+              'SND_RAWMIDI_STREAM_LAST', 1
+        ]
+
+    # get information about RawMidi handle
+    attach_function :snd_rawmidi_info, [:pointer, :pointer], :int # (snd_rawmidi_t *rmidi, snd_rawmidi_info_t *info)
+    # get rawmidi count of subdevices
+    attach_function :snd_rawmidi_info_get_subdevices_count, [:pointer], :uint # (const snd_rawmidi_info_t *obj)
+    # set rawmidi device number
+    attach_function :snd_rawmidi_info_set_device, [:pointer, :uint], :void # (snd_rawmidi_info_t *obj, unsigned int val)
+    # set rawmidi subdevice number
+    attach_function :snd_rawmidi_info_set_subdevice, [:pointer, :uint], :void # (snd_rawmidi_info_t *obj, unsigned int val)
+    # set rawmidi stream identifier
+    attach_function :snd_rawmidi_info_set_stream, [:pointer, :snd_rawmidi_stream], :void # (snd_rawmidi_info_t *obj, snd_rawmidi_stream_t val)
+    # get size of the snd_rawmidi_info_t structure in bytes
+    attach_function :snd_rawmidi_info_sizeof, [], :size_t # (void)
+
+    #
+    # misc
+    #
+
+    # Convert an error code to a string
+    attach_function :snd_strerror, [:int], :string # (int errnum) / const char*
+    # Frees the global configuration tree in snd_config.
+    attach_function :snd_config_update_free_global, [], :int # (void)
+
+  end
+end

data/lib/alsa-rawmidi/output.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+module AlsaRawMIDI
+  
+  #
+  # Output device class
+  #
+  class Output
+    
+    include Device
+    
+    # close this output
+    def close
+      Map.snd_rawmidi_drain(@handle)
+      Map.snd_rawmidi_close(@handle)
+      @enabled = false
+    end
+    
+    # sends a MIDI message comprised 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
+
+    # sends a MIDI messages comprised of Numeric bytes 
+    def puts_bytes(*data)
+
+      format = "C" * data.size
+      bytes = FFI::MemoryPointer.new(data.size).put_bytes(0, data.pack(format))
+
+      Map.snd_rawmidi_write(@handle, bytes.to_i, data.size)
+      Map.snd_rawmidi_drain(@handle)
+      
+    end
+    
+    # send a MIDI message of an indeterminant 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
+    alias_method :write, :puts
+    
+    # enable this device; also takes a block
+    def enable(options = {}, &block)
+      handle_ptr = FFI::MemoryPointer.new(FFI.type_size(:int))
+      Map.snd_rawmidi_open(nil, handle_ptr, @system_id, 0)
+      @handle = handle_ptr.read_int
+      @enabled = true
+      unless block.nil?
+      	begin
+      		yield(self)
+      	ensure
+      		close
+      	end
+      else
+        self
+      end
+    end
+    alias_method :open, :enable
+    alias_method :start, :enable
+    
+    def self.first
+      Device.first(:output)	
+    end
+
+    def self.last
+      Device.last(:output)	
+    end
+    
+    def self.all
+      Device.all_by_type[:output]
+    end
+  end
+  
+end

data/lib/alsa-rawmidi/soundcard.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+module AlsaRawMIDI
+	
+  class Soundcard
+
+    attr_reader :subdevices
+    
+    def initialize(card_num)
+      @subdevices = { :input => [], :output => [] }
+      name = "hw:#{card_num}"
+      handle_ptr = FFI::MemoryPointer.new(FFI.type_size(:int))
+      #snd_ctl = Map::SndCtl.new
+      #snd_ctl_pointer = FFI::MemoryPointer.new(:pointer).write_pointer(snd_ctl.pointer)
+      Map.snd_ctl_open(handle_ptr, name, 0)
+      handle = handle_ptr.read_int
+      32.times do |i|
+        devnum = FFI::MemoryPointer.new(:int).write_int(i)
+        if (err = Map.snd_ctl_rawmidi_next_device(handle, devnum)) < 0
+        break # fix this
+        end
+        @subdevices.keys.each do |type|
+          populate_subdevices(type, handle, card_num, i)
+        end
+      end
+    end
+
+    def self.find(card_num)
+      Soundcard.new(card_num) if Map.snd_card_load(card_num).eql?(1)
+    end
+
+    private
+
+    def unpack(string)
+      arr = string.delete_if { |n| n.zero? }
+      arr.pack("C#{arr.length}")
+    end
+
+    def get_alsa_subdev_id(card_num, device_num, subdev_count, i)
+      ext = (subdev_count > 1) ? ",#{i}" : ''
+      "hw:#{card_num},#{device_num}#{ext}"
+    end
+
+    def populate_subdevices(type, ctl_ptr, card_num, device_num)
+      ctype, dtype = *case type
+      when :input then [Map::Constants[:SND_RAWMIDI_STREAM_INPUT], Input]
+      when :output then [Map::Constants[:SND_RAWMIDI_STREAM_OUTPUT], Output]
+      end
+      info = Map::SndRawMIDIInfo.new
+      Map.snd_rawmidi_info_set_device(info.pointer, device_num)
+      Map.snd_rawmidi_info_set_stream(info.pointer, ctype)
+      i = 0
+      subdev_count = 1
+      available = []
+      while (i <= subdev_count)
+        Map.snd_rawmidi_info_set_subdevice(info.pointer, i)
+        # fix this
+        if (err = Map.snd_ctl_rawmidi_info(ctl_ptr, info.pointer)) < 0
+        break
+        end
+
+        if (i < 1)
+        subdev_count = Map.snd_rawmidi_info_get_subdevices_count(info.pointer)
+        subdev_count = (subdev_count > 32) ? 0 : subdev_count
+        end
+
+        name = info[:name].to_s
+        system_id = get_alsa_subdev_id(card_num, device_num, subdev_count, i)
+        dev = dtype.new(:system_id => system_id, :name => info[:name].to_s, :subname => info[:subname].to_s)
+        available << dev
+        i += 1
+      end
+      @subdevices[type] += available
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: alsa-rawmidi
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.14
+platform: ruby
+authors: 
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+description: Realtime MIDI input and output with Ruby for Linux.
+email: 
+- ari.russo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/alsa-rawmidi.rb
+- lib/alsa-rawmidi/map.rb
+- lib/alsa-rawmidi/device.rb
+- lib/alsa-rawmidi/output.rb
+- lib/alsa-rawmidi/input.rb
+- lib/alsa-rawmidi/soundcard.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/arirusso/alsa-rawmidi
+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: alsa-rawmidi
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Realtime MIDI input and output with Ruby for Linux.
+test_files: []
+