alsa-rawmidi 0.2.14 → 0.3.1

data/lib/alsa-rawmidi/device.rb

@@ -1,79 +1,108 @@
-#!/usr/bin/env ruby
-
 module AlsaRawMIDI
 
-  #
-  # Module containing methods used by both input and output devices when using the
-  # ALSA driver interface
-  #
+  # Functionality common to both inputs and outputs
   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 
+    module ClassMethods
 
-    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
+      # Select the first device of the given direction
+      # @param [Symbol] direction
+      # @return [Input, Output]
+      def first(direction)
+        all_by_type[direction].first
+      end
 
-      @enabled = false
-    end
+      # Select the last device of the given direction
+      # @param [Symbol] direction
+      # @return [Input, Output]
+      def last(direction)
+        all_by_type[direction].last
+      end
 
-    # select the first device of type <em>type</em>
-    def self.first(type)
-      all_by_type[type].first
-    end
+      # A hash of devices, partitioned by direction
+      # @return [Hash]
+      def all_by_type
+        @devices ||= get_devices
+      end
 
-    # select the last device of type <em>type</em>
-    def self.last(type)
-      all_by_type[type].last
-    end
+      # All devices
+      # @return [Array<Input, Output>]
+      def all
+        all_by_type.values.flatten
+      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
+      private
+
+      # Get all available devices from the system
+      # @return [Hash]
+      def get_devices
+        available_devices = {
+          :input => [],
+          :output => []
+        }
+        device_count = 0
+        32.times do |i|
+          card = Soundcard.find(i)
+          unless card.nil?
+            available_devices.keys.each do |direction|
+              devices = card.subdevices[direction]
+              devices.each do |dev|
+                dev.send(:id=, device_count)
+                device_count += 1
+              end
+              available_devices[direction] += devices
             end
-            available_devices[type] += devices
           end
         end
+        available_devices
       end
-      available_devices
+
     end
 
-    # all devices of both types
-    def self.all
-      all_by_type.values.flatten
+    extend ClassMethods
+
+    attr_reader :enabled, # has the device been initialized?
+    :system_id, # the alsa id of the device
+    :id, # a local uuid for the device
+    :name,
+    :subname,
+    :type # :input or :output
+
+    alias_method :enabled?, :enabled
+
+    def self.included(base)
+      base.send(:extend, ClassMethods)
     end
-    
+
+    # @param [Hash] options
+    # @option options [Fixnum] :id
+    # @option options [String] :name
+    # @option options [String] :subname
+    # @option options [String] :system_id
+    def initialize(options = {})
+      @id = options[:id]
+      @name = options[:name]
+      @subname = options[:subname]
+      @system_id = options[:system_id]
+      @type = get_type
+      @enabled = false
+    end
+
     private
-    
+
+    # Assign an id
+    # @param [Fixnum] id
+    # @return [Fixnum]
     def id=(id)
       @id = id
     end
 
+    # Get the device type
+    # @return [Symbol]
+    def get_type
+      self.class.name.split('::').last.downcase.to_sym
+    end
+
   end
 
-end
+end

data/lib/alsa-rawmidi/input.rb

@@ -1,168 +1,199 @@
-#!/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
+module AlsaRawMIDI
+
+  # Input device class
+  class Input
+
+    include Device
+
+    attr_reader :buffer
+
+    #
+    # 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
+    #
+    # @return [Array<Hash>]
+    def gets
+      loop until enqueued_messages?
+      msgs = enqueued_messages
+      @pointer = @buffer.length
+      msgs
+    end
+    alias_method :read, :gets
+
+    # Like Input#gets but returns message data as string of hex digits as such:
+    #   [
+    #     { :data => "904060", :timestamp => 904 },
+    #     { :data => "804060", :timestamp => 1150 },
+    #     { :data => "90447F", :timestamp => 1300 }
+    #   ]
+    #
+    # @return [Array<Hash>]
+    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; yields
+    # @param [Hash] options
+    # @param [Proc] block
+    # @return [Input] self
+    def enable(options = {}, &block)
+      unless @enabled
+        @start_time = Time.now.to_f
+        @resource = API::Input.open(@system_id)
+        @enabled = true
+        initialize_buffer
+        spawn_listener
+      end
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      end
+      self
+    end
+    alias_method :open, :enable
+    alias_method :start, :enable
+
+    # Close this input
+    # @return [Boolean]
+    def close
+      if @enabled
+        Thread.kill(@listener)
+				API::Device.close(@resource)
+        @enabled = false
+        true
+      else
+        false
+      end
+    end
+
+    # The first input available
+    # @return [Input]
+    def self.first
+      Device.first(:input)
+    end
+
+    # The last input available
+    # @return [Input]
+    def self.last
+      Device.last(:input)
+    end
+
+    # All available inputs
+    # @return [Array<Input>]
+    def self.all
+      Device.all_by_type[:input]
+    end
+
+    private
+
+    # Initialize the input buffer
+    # @return [Array]
+    def initialize_buffer
+      @pointer = 0
+      @buffer = []
+      def @buffer.clear
+        super
+        @pointer = 0
+      end
+      @buffer
+    end
+
+    # A timestamp for the current time
+    # @return [Float]
+    def now
+      time = Time.now.to_f - @start_time
+      time * 1000
+    end
+
+    # A message paired with timestamp
+    # @param [String] hexstring
+    # @param [Float] timestamp
+    # @return [Hash]
+    def get_message_formatted(hexstring, timestamp)
+      {
+        :data => hex_string_to_numeric_bytes(hexstring),
+        :timestamp => timestamp
+      }
+    end
+
+    # The messages enqueued in the buffer
+    # @return [Array<Hash>]
+    def enqueued_messages
+      @buffer.slice(@pointer, @buffer.length - @pointer)
+    end
+
+    # Are there messages enqueued?
+    # @return [Boolean]
+    def enqueued_messages?
+      @pointer < @buffer.length
+    end
+
+    # Launch a background thread that collects messages
+    # and holds them for the next call to gets*
+    # @return [Thread]
+    def spawn_listener
+      interval = 1.0/1000
+      @listener = Thread.new do
+        begin
+          loop do
+            while (messages = API::Input.poll(@resource)).nil?
+              sleep(interval)
+            end
+            populate_buffer(messages) unless messages.nil?
+          end
+        rescue Exception => exception
+          Thread.main.raise(exception)
+        end
+      end
+      @listener.abort_on_exception = true
+      @listener
+    end
+
+    # Collect messages from the system buffer
+    # @return [Array<String>, nil]
+    def populate_buffer(messages)
+      @buffer << get_message_formatted(messages, now) unless messages.nil?
+    end
+
+    # Convert a hex string to an array of numeric bytes eg "904040" -> [0x90, 0x40, 0x40]
+    # @param [String] string
+    # @return [Array<Fixnum>]
+    def hex_string_to_numeric_bytes(string)
+      string = string.dup
+      bytes = []
+      until string.length.zero?
+        string_byte = string.slice!(0, 2)
+        bytes << string_byte.hex
+      end
+      bytes
+    end
+
+    # Convert an array of numeric bytes to a hex string eg [0x90, 0x40, 0x40] -> "904040"
+    # @param [Array<Fixnum>] bytes
+    # @return [String]
+    def numeric_bytes_to_hex_string(bytes)
+      string_bytes = bytes.map do |byte|
+        string_byte = byte.to_s(16).upcase
+        string_byte = "0#{string_byte}" if byte < 16
+        string_byte
+      end
+      string_bytes.join
+    end
+
+  end
+
+end