midi-jruby 0.0.12

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,52 @@
+= midi-jruby
+
+== Summary
+
+Simple MIDI wrapper for realtime IO in JRuby. Uses javax.sound.midi.
+
+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-jruby for users who are using jruby.  
+
+== Features
+
+* Input and output on multiple devices concurrently
+* Agnostically handle different MIDI Message types (including SysEx)
+* Timestamped input events
+
+== Install
+
+* gem install midi-jruby
+
+== Usage 
+
+This library requires that JRuby be run in '1.9 mode'.  This is normally done by passing --1.9 to JRuby at the command line
+	
+== Examples
+
+* {input}[http://github.com/arirusso/midi-jruby/blob/master/examples/input.rb]
+* {output}[http://github.com/arirusso/midi-jruby/blob/master/examples/output.rb]
+
+== Issues
+
+There is an issue that causes javax.sound.midi not to be able to send SysEx messages in some OSX Snow Leopard versions.
+	
+== Tests
+
+Use
+
+    jruby --1.9 -S rake test
+
+* please see {test/config.rb}[http://github.com/arirusso/midi-jruby/blob/master/test/config.rb] before running tests
+
+== Documentation
+
+* {rdoc}[http://rdoc.info/gems/midi-jruby]
+
+== Author 
+
+{Ari Russo}[http://github.com/arirusso] <ari.russo at gmail.com>
+		
+== License
+
+Apache 2.0, See the file LICENSE
+
+Copyright (c) 2011 Ari Russo

data/lib/midi-jruby/device.rb

@@ -0,0 +1,73 @@
+module MIDIJRuby
+
+  #
+  # Module containing methods used by both input and output devices
+  #
+  module Device
+    
+    import javax.sound.midi.MidiSystem
+    import javax.sound.midi.MidiDevice
+    import javax.sound.midi.MidiEvent
+    import javax.sound.midi.Receiver
+
+                # has the device been initialized?
+    attr_reader :enabled,
+                # unique int id 
+                :id,
+                # name property from javax.sound.midi.MidiDevice.Info
+                :name,
+                # description property from javax.sound.midi.MidiDevice.Info
+                :description,
+                # vendor property from javax.sound.midi.MidiDevice.Info
+                :vendor,
+                # :input or :output
+                :type 
+
+    alias_method :enabled?, :enabled
+    
+    def initialize(id, device, options = {}, &block)
+      @name = options[:name]
+      @description = options[:description]
+      @vendor = options[:vendor]
+      @id = id
+      @device = device
+
+      # 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 => [] }
+      count = -1
+      MidiSystem.get_midi_device_info.each do |info|
+        device = MidiSystem.get_midi_device(info)
+        opts = { :name => info.get_name, 
+                 :description => info.get_description, 
+                 :vendor => info.get_vendor }
+        available_devices[:output] << Output.new(count += 1, device, opts) unless device.get_max_receivers.zero?
+        available_devices[:input] << Input.new(count += 1, device, opts) unless device.get_max_transmitters.zero?
+      end
+      available_devices
+    end
+
+    # all devices of both types
+    def self.all
+      all_by_type.values.flatten
+    end
+
+  end
+
+end

data/lib/midi-jruby/input.rb

@@ -0,0 +1,190 @@
+module MIDIJRuby
+    
+  #
+  # Input device class
+  #
+  class Input
+    
+    import javax.sound.midi.Transmitter
+
+    include Device
+    
+    attr_reader :buffer
+    
+    class InputReceiver
+      
+      include javax.sound.midi.Receiver
+      extend Forwardable
+    
+      attr_reader :stream
+
+      def initialize
+        @buf = []
+      end
+      
+      def read
+        to_return = @buf.dup
+        @buf.clear
+        to_return
+      end
+      
+      def send(msg, timestamp = -1)
+        if msg.respond_to?(:get_packed_msg)
+          m = msg.get_packed_msg
+          @buf << unpack(m)
+        else
+          str = String.from_java_bytes(msg.get_data)
+          arr = str.unpack("C" * str.length)
+          arr.insert(0, msg.get_status)
+          @buf << arr 
+        end
+      end      
+      
+      private
+      
+      def unpack(msg)
+        # there's probably a better way of doing this
+        o = []
+        s = msg.to_s(16)
+        s = "0" + s if s.length.divmod(2).last > 0
+        while s.length > 0 
+          o << s.slice!(0,2).hex
+        end
+        o.reverse        
+      end
+     
+    end
+    
+    #
+    # 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 { |msg| msg[:data] = numeric_bytes_to_hex_string(msg[: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)
+      @device.open
+      @transmitter = @device.get_transmitter
+      @transmitter.set_receiver(InputReceiver.new)
+      initialize_buffer
+      @start_time = Time.now.to_f
+      spawn_listener!
+      @enabled = true
+      if block_given?
+        begin
+          block.call(self)
+        ensure
+          close
+        end
+      else
+        self
+      end
+    end
+    alias_method :open, :enable
+    alias_method :start, :enable
+
+    # close this input
+    def close
+      @listener.kill
+      @transmitter.close
+      @device.close
+      @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
+      @buffer = []
+      @pointer = 0
+      def @buffer.clear
+        @pointer = 0
+        super        
+      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 => 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
+    def spawn_listener!
+      @listener = Thread.fork do
+        while true          
+          while (msgs = poll_system_buffer).empty?
+            sleep(1.0/1000)
+          end
+          populate_local_buffer(msgs) unless msgs.empty?
+        end
+      end
+    end
+    
+    def poll_system_buffer
+      @transmitter.get_receiver.read
+    end
+    
+    def populate_local_buffer(msgs)
+      msgs.each { |raw| @buffer << get_message_formatted(raw, now) unless raw.nil? }
+    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-jruby/output.rb

@@ -0,0 +1,82 @@
+module MIDIJRuby
+  
+  #
+  # Output device class
+  #
+  class Output
+    import javax.sound.midi.ShortMessage
+    import javax.sound.midi.SysexMessage
+    
+    include Device
+    
+    # close this output
+    def close
+      @device.close
+      @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)
+      if data.first.eql?(0xF0)
+        msg = SysexMessage.new
+        msg.set_message(data.to_java(:byte), data.length)
+      else
+        msg = ShortMessage.new
+        msg.set_message(*data)
+      end
+      @device.get_receiver.send(msg, 0)
+    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_bytestr(*a)
+      end
+    end
+    alias_method :write, :puts
+    
+    # enable this device; also takes a block
+    def enable(options = {}, &block)
+      @device.open
+      @enabled = true
+      unless block.nil?
+        begin
+          block.call(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/midi-jruby.rb

@@ -0,0 +1,15 @@
+require 'java'
+require 'forwardable' 
+
+#
+# Set of modules and classes for interacting with javax.sound.midi
+#
+module MIDIJRuby
+  
+    VERSION = "0.0.12"
+       
+end
+
+require 'midi-jruby/device'
+require 'midi-jruby/input'
+require 'midi-jruby/output'

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: midi-jruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.12
+platform: ruby
+authors: 
+  - Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-04 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Simple MIDI wrapper for realtime IO in JRuby.  Uses javax.sound.midi. Note that this library requires JRuby to be run in '1.9 mode'
+email: 
+  - ari.russo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/midi-jruby.rb
+  - lib/midi-jruby/device.rb
+  - lib/midi-jruby/input.rb
+  - lib/midi-jruby/output.rb
+  - LICENSE
+  - README.rdoc
+has_rdoc: true
+homepage: http://github.com/arirusso/midi-jruby
+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-jruby
+rubygems_version: 1.5.1
+signing_key: 
+specification_version: 3
+summary: Simple MIDI wrapper for realtime IO in JRuby
+test_files: []
+