alsa-rawmidi 0.2.14 → 0.3.1

data/lib/alsa-rawmidi/output.rb

@@ -1,84 +1,96 @@
-#!/usr/bin/env ruby
-
 module AlsaRawMIDI
-  
-  #
+
   # Output device class
-  #
   class Output
-    
+
     include Device
-    
-    # close this output
+
+    # Close this output
+    # @return [Boolean]
     def close
-      Map.snd_rawmidi_drain(@handle)
-      Map.snd_rawmidi_close(@handle)
-      @enabled = false
+      if @enabled
+        API::Device.close(@resource)
+        @enabled = false
+        true
+      else
+        false
+      end
     end
-    
-    # sends a MIDI message comprised of a String of hex digits 
+
+    # Output a MIDI message in hex string format
+    # @param [String] data
+    # @return [Boolean]
     def puts_s(data)
       data = data.dup
-	    output = []
-      until (str = data.slice!(0,2)).eql?("")
-      	output << str.hex
+      output = []
+      until (str = data.slice!(0,2)) == ""
+        output << str.hex
       end
       puts_bytes(*output)
+      true
     end
     alias_method :puts_bytestr, :puts_s
     alias_method :puts_hex, :puts_s
 
-    # sends a MIDI messages comprised of Numeric bytes 
+    # Output a MIDI message in numeric byte format
+    # @param [*Fixnum] data
+    # @return [Boolean]
     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)
-      
+      API::Output.puts(@resource, data)
+      true
     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)
+
+    # Output the given MIDI message
+    # @param [*Fixnum, *String] args
+    # @return [Boolean]
+    def puts(*args)
+      case args.first
+        when Array then args.each { |arg| puts(*arg) }
+        when Numeric then puts_bytes(*args)
+        when String then puts_bytestr(*args)
       end
     end
     alias_method :write, :puts
-    
-    # enable this device; also takes a block
+
+    # Enable this device; yields
+    # @param [Hash] options
+    # @param [Proc] block
+    # @return [Output]
     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
+      unless @enabled
+        @resource = API::Output.open(@system_id)
+        @enabled = true
+      end
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
       end
+      self
     end
     alias_method :open, :enable
     alias_method :start, :enable
-    
+
+    # The first available output
+    # @return [Output]
     def self.first
-      Device.first(:output)	
+      Device.first(:output)
     end
 
+    # The last available output
+    # @return [Output]
     def self.last
-      Device.last(:output)	
+      Device.last(:output)
     end
-    
+
+    # All outputs
+    # @return [Array<Output>]
     def self.all
       Device.all_by_type[:output]
     end
+
   end
-  
-end
+
+end

data/lib/alsa-rawmidi/soundcard.rb

@@ -1,78 +1,61 @@
-#!/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
+  class Soundcard
 
-    private
+    attr_reader :id, :subdevices
 
-    def unpack(string)
-      arr = string.delete_if { |n| n.zero? }
-      arr.pack("C#{arr.length}")
+    # @param [Fixnum] id
+    def initialize(id)
+      @subdevices = {
+        :input => [],
+        :output => []
+      }
+      @id = id
+      populate_subdevices
     end
 
-    def get_alsa_subdev_id(card_num, device_num, subdev_count, i)
-      ext = (subdev_count > 1) ? ",#{i}" : ''
-      "hw:#{card_num},#{device_num}#{ext}"
+    # Find a soundcard by its ID
+    # @param [Fixnum] id
+    # @return [Soundcard]
+    def self.find(id)
+      @soundcards ||= {}
+      if API::Soundcard.exists?(id)
+        @soundcards[id] ||= Soundcard.new(id)
+      end
     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
+    private
 
-        if (i < 1)
-        subdev_count = Map.snd_rawmidi_info_get_subdevices_count(info.pointer)
-        subdev_count = (subdev_count > 32) ? 0 : subdev_count
+    # @return [Hash]
+    def populate_subdevices
+      device_ids = API::Soundcard.get_device_ids(@id)
+      device_ids.each do |device_id|
+        @subdevices.keys.each do |direction|
+          devices = API::Soundcard.get_subdevices(direction, @id, device_id) do |device_hash|
+            new_device(direction, device_hash)
+          end
+          @subdevices[direction] += devices
         end
+      end
+      @subdevices
+    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
+    # Instantiate a new device object
+    # @param [Hash]
+    # @return [Input, Output]
+    def new_device(direction, device_hash)
+      device_class = case direction
+      when :input then Input
+      when :output then Output
       end
-      @subdevices[type] += available
+      device_properties = {
+        :system_id => device_hash[:id],
+        :name => device_hash[:name],
+        :subname => device_hash[:subname]
+      }
+      device_class.new(device_properties)
     end
 
   end
 
-end
+end

data/test/helper.rb

@@ -0,0 +1,51 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + "/../lib"
+
+require "test/unit"
+require "mocha/test_unit"
+require "shoulda-context"
+require "alsa-rawmidi"
+
+module TestHelper
+
+  extend self
+
+  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
+  def numeric_messages
+    [
+      [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
+    ]
+  end
+
+  # some MIDI messages
+  def string_messages
+    [
+      "F04110421240007F0041F7", # SysEx
+      "906440", # note on
+      "804340" # note off
+    ]
+  end
+
+  def input
+    AlsaRawMIDI::Input.first
+  end
+
+  def output
+    AlsaRawMIDI::Output.first
+  end
+
+end

data/test/input_buffer_test.rb

@@ -0,0 +1,46 @@
+require "helper"
+
+class AlsaRawMIDI::InputBufferTest < Test::Unit::TestCase
+
+  context "AlsaRawMIDI" do
+
+    setup do
+      sleep(1)
+      @input = TestHelper.input.open
+      @output = TestHelper.output.open
+      @input.buffer.clear
+      @pointer = 0
+    end
+
+    context "Source#buffer" do
+
+      setup do
+        @messages = TestHelper.numeric_messages
+        @messages_arr = @messages.inject(&:+).flatten
+        @received_arr = []
+      end
+
+      teardown do
+        @input.close
+        @output.close
+      end
+
+      should "have the correct messages in the buffer" do
+        bytes = []
+        @messages.each do |message|
+          p "sending: #{message}"
+          @output.puts(message)
+          bytes += message
+
+          sleep(1)
+
+          buffer = @input.buffer.map { |m| m[:data] }.flatten
+          p "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/io_test.rb

@@ -0,0 +1,80 @@
+require "helper"
+
+class AlsaRawMIDI::IoTest < Test::Unit::TestCase
+
+  # ** this test assumes that TestOutput is connected to TestInput
+  context "AlsaRawMIDI" do
+
+    setup do
+      sleep(1)
+      @input = TestHelper.input.open
+      @output = TestHelper.output.open
+      @input.buffer.clear
+      @pointer = 0
+    end
+
+    context "full IO" do
+
+      context "using Arrays" do
+
+        setup do
+          @messages = TestHelper.numeric_messages
+          @messages_arr = @messages.inject(&:+).flatten
+          @received_arr = []
+        end
+
+        teardown do
+          @input.close
+          @output.close
+        end
+        
+        should "do IO" do
+          @messages.each do |message|
+
+            p "sending: #{message}"
+
+            @output.puts(message)
+            sleep(1)
+            received = @input.gets.map { |m| m[:data] }.flatten
+
+            p "received: #{received}"
+
+            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
+
+      context "using byte Strings" do
+
+        setup do
+          @messages = TestHelper.string_messages
+          @messages_str = @messages.join
+          @received_str = ""
+        end
+
+        should "do IO" do
+          @messages.each do |message|
+
+            p "sending: #{message}"
+
+            @output.puts(message)
+            sleep(1)
+            received = @input.gets_bytestr.map { |m| m[:data] }.flatten.join
+            p "received: #{received}"
+
+            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
+
+end