mtk 0.0.2 → 0.0.3

data/lib/mtk/midi/input.rb

@@ -0,0 +1,97 @@
+module MTK
+  module MIDI
+
+    # Common behavior for realtime MIDI input.
+    #
+    class Input
+
+      class << self
+
+        def inherited(subclass)
+          available_input_types << subclass
+        end
+
+        def available_input_types
+          @available_input_types ||= []
+        end
+
+        def input_types_by_device
+          @input_types_by_device ||= (
+          available_input_types.each_with_object( Hash.new ) do |input_type,hash|
+            input_type.devices.each{|device| hash[device] = input_type }
+          end
+          )
+        end
+
+        # All available input devices.
+        def devices
+          @devices ||= available_input_types.map{|input_type| input_type.devices }.flatten
+        end
+
+        # Maps input device names to the input device.
+        def devices_by_name
+          @devices_by_name ||= (
+          available_input_types.each_with_object( Hash.new ) do |input_type,hash|
+            hash.merge!( input_type.devices_by_name )
+          end
+          )
+        end
+
+        def find_by_name(name)
+          if name.is_a? Regexp
+            matching_name = devices_by_name.keys.find{|device_name| device_name =~ name }
+            device = devices_by_name[matching_name]
+          else
+            device = devices_by_name[name.to_s]
+          end
+          open(device) if device
+        end
+
+        def open(device)
+          input_type = input_types_by_device[device]
+          input_type.new(device) if input_type
+        end
+      end
+
+
+      def initialize(input_device, options={})
+        @device = input_device
+        @device.open
+        @options = options
+      end
+      private_class_method :new
+
+
+      ########################
+      public
+
+      # The underlying output device implementation wrapped by this class.
+      # The device type depends on the platform.
+      attr_reader :device
+
+      def name
+        @device.name
+      end
+
+      def record
+      end
+
+      def stop
+      end
+
+      def to_timeline
+        Timeline.new
+      end
+
+    end
+  end
+end
+
+
+unless $__RUNNING_RSPEC_TESTS__ # I can't get this working on Travis-CI, problem installing native dependencies
+  if RUBY_PLATFORM == 'java'
+    require 'mtk/midi/jsound_input'
+  else
+    require 'mtk/midi/unimidi_input'
+  end
+end

data/lib/mtk/midi/jsound_input.rb

@@ -1,31 +1,50 @@
-require 'rubygems'
 require 'jsound'
 
 module MTK
   module MIDI
 
-    # Provides MIDI input for JRuby via the jsound gem
-    class JSoundInput
+    # Provides realtime MIDI input for JRuby via the jsound gem.
+    # @note This class is optional and only available if you require 'mtk/midi/jsound_input'.
+    #       It depends on the 'jsound' gem.
+    class JSoundInput < Input
 
-      def initialize(input_device)
-        if input_device.is_a? ::JSound::Midi::Device
-          @input = input_device
-        else
-          @input = ::JSound::Midi::INPUTS.send input_device
-        end
+      public_class_method :new
+
+      def self.devices
+        @devices ||= ::JSound::Midi::INPUTS.devices
+      end
+
+      def self.devices_by_name
+        @devices_by_name ||= devices.each_with_object( Hash.new ){|device,hash| hash[device.description] = device }
+      end
+
+
+      attr_reader :device
+
+      def initialize(input_device, options={})
+        @device = input_device
         @recorder = ::JSound::Midi::Devices::Recorder.new(false)
-        @input >> @recorder
+        @device.open
+      end
+
+      def name
+        @device.description
       end
 
-      def record
-        @input.open
+      def record(options={})
+        if options[:monitor]
+          @monitor = ::JSound::Midi::Devices::Monitor.new
+          @device >> [@monitor, @recorder]
+        else
+          @device >> @recorder
+        end
+
         @recorder.clear
         @recorder.start
       end
 
       def stop
         @recorder.stop
-        @input.close
       end
 
       def to_timeline(options={})
@@ -35,7 +54,7 @@ module MTK
         note_ons = {}
         start = nil
 
-        for message,time in @recorder.messages_with_timestamps
+        @recorder.messages_with_timestamps.each do |message,time|
           start = time unless start
           time -= start
           time /= beats_per_second
@@ -46,13 +65,13 @@ module MTK
 
             when :note_off
               if note_ons.has_key? message.pitch
-                note_on, start_time = note_ons[message.pitch]
+                note_on, start_time = note_ons.delete(message.pitch)
                 duration = time - start_time
-                note = Note.from_midi note_on.pitch, note_on.velocity, duration
+                note = MTK::Events::Note.from_midi(note_on.pitch, note_on.velocity, duration, message.channel)
                 timeline.add time,note
               end
 
-            else timeline.add time,message
+            else timeline.add time, MTK::Events::Parameter.from_midi([message.type, message.channel], message.data1, message.data2)
           end
         end
 

data/lib/mtk/midi/jsound_output.rb

@@ -1,23 +1,30 @@
-require 'rubygems'
 require 'jsound'
-require 'gamelan'
 
 module MTK
   module MIDI
 
-    # Provides MIDI output for JRuby via the jsound gem
-    class JSoundOutput
+    # Provides realtime MIDI output for JRuby via the jsound and gamelan gems.
+    # @note This class is optional and only available if you require 'mtk/midi/jsound_output'.
+    #       It depends on the 'jsound' and 'gamelan' gems.
+    class JSoundOutput < Output
 
-      attr_reader :device
+      public_class_method :new
+
+      def self.devices
+        @devices ||= ::JSound::Midi::OUTPUTS.devices
+      end
+
+      def self.devices_by_name
+        @devices_by_name ||= devices.each_with_object( Hash.new ){|device,hash| hash[device.description] = device }
+      end
 
-      def initialize(output, options={})
-        if output.is_a? ::JSound::Midi::Device
-          @device = output
-        else
-          @device = ::JSound::Midi::OUTPUTS.send output
-        end
 
+      def initialize(device, options={})
+        @device = device
+
+        # and create an object for generating MIDI message to send to the output:
         @generator = ::JSound::Midi::Devices::Generator.new
+
         if options[:monitor]
           @monitor = ::JSound::Midi::Devices::Monitor.new
           @generator >> [@monitor, @device]
@@ -27,51 +34,46 @@ module MTK
         @device.open
       end
 
-      def play(timeline, options={})
-        scheduler_rate = options.fetch :scheduler_rate, 500 # default: 500 Hz
-        trailing_buffer = options.fetch :trailing_buffer, 2 # default: continue playing for 2 beats after the end of the timeline
-        in_background = options.fetch :background, false # default: don't run in background Thread
-        bpm = options.fetch :bmp, 120 # default: 120 beats per minute
-
-        @scheduler = Gamelan::Scheduler.new :tempo => bpm, :rate => scheduler_rate
-
-        for time,events in timeline
-          for event in events
-            case event
-              when Note
-                pitch, velocity, duration = event.to_midi
-                at time, note_on(pitch,velocity)
-                time += duration
-                at time, note_off(pitch,velocity)
-            end
-          end
-        end
+      def name
+        @device.description
+      end
 
-        end_time = timeline.times.last + trailing_buffer
-        @scheduler.at(end_time) { @scheduler.stop }
+      ######################
+      protected
 
-        thread = @scheduler.run
-        thread.join if not in_background
+      # (see Output#note_on)
+      def note_on(pitch, velocity, channel)
+        @generator.note_on(pitch, velocity, channel)
       end
 
-      ######################
-      private
+      # (see Output#note_off)
+      def note_off(pitch, velocity, channel)
+        @generator.note_off(pitch, velocity, channel)
+      end
+
+      # (see Output#control)
+      def control(number, midi_value, channel)
+        @generator.control_change(number, midi_value, channel)
+      end
 
-      # It's necessary to generate the events through methods and lambdas like this to create closures.
-      # Otherwise when the @generator methods are called, they might not be passed the values you expected.
-      # I suspect this may not a problem in MRI ruby, but I'm having trouble in JRuby
-      # (pitch and velocity were always the last scheduled values)
+      # (see Output#channel_pressure)
+      def channel_pressure(midi_value, channel)
+        @generator.channel_pressure(midi_value, channel)
+      end
 
-      def note_on(pitch, velocity)
-        lambda { @generator.note_on(pitch, velocity) }
+      # (see Output#poly_pressure)
+      def poly_pressure(pitch, midi_value, channel)
+        @generator.poly_pressure(pitch, midi_value, channel)
       end
 
-      def note_off(pitch, velocity)
-        lambda { @generator.note_off(pitch, velocity) }
+      # (see Output#bend)
+      def bend(midi_value, channel)
+        @generator.pitch_bend(midi_value, channel)
       end
 
-      def at time, block
-        @scheduler.at(time) { block.call }
+      # (see Output#program)
+      def program(number, channel)
+        @generator.program_change(number, channel)
       end
 
     end

data/lib/mtk/midi/output.rb

@@ -0,0 +1,195 @@
+require 'rbconfig'
+require 'gamelan'
+
+module MTK
+  module MIDI
+
+    # Provides a scheduler and common behavior for realtime MIDI output, using the gamelan gem for scheduling.
+    #
+    # @abstract Subclasses must provide {.devices}, {.devices_by_name}, {#note_on}, {#note_off}, {#control}, {#channel_pressure}, {#poly_pressure}, {#bend}, and {#program} to implement a MIDI output.
+    #
+    class Output
+
+      class << self
+
+        def inherited(subclass)
+          available_output_types << subclass
+        end
+
+        def available_output_types
+          @available_output_types ||= []
+        end
+
+        def output_types_by_device
+          @output_types_by_device ||= (
+            available_output_types.each_with_object( Hash.new ) do |output_type,hash|
+              output_type.devices.each{|device| hash[device] = output_type }
+            end
+          )
+        end
+
+        # All available output devices.
+        def devices
+          @devices ||= available_output_types.map{|output_type| output_type.devices }.flatten
+        end
+
+        # Maps output device names to the output device.
+        def devices_by_name
+          @devices_by_name ||= (
+            available_output_types.each_with_object( Hash.new ) do |output_type,hash|
+              hash.merge!( output_type.devices_by_name )
+            end
+          )
+        end
+
+        def find_by_name(name)
+          if name.is_a? Regexp
+            matching_name = devices_by_name.keys.find{|device_name| device_name =~ name }
+            device = devices_by_name[matching_name]
+          else
+            device = devices_by_name[name.to_s]
+          end
+          open(device) if device
+        end
+
+        def open(device)
+          output_type = output_types_by_device[device]
+          output_type.new(device) if output_type
+        end
+      end
+
+
+      def initialize(output_device, options={})
+        @device = output_device
+        @device.open
+        @options = options
+      end
+      private_class_method :new
+
+
+      ########################
+      public
+
+      # The underlying output device implementation wrapped by this class.
+      # The device type depends on the platform.
+      attr_reader :device
+
+      def name
+        @device.name
+      end
+
+      def play(anything, options={})
+        timeline = case anything
+          when MTK::Timeline then anything
+          when Hash then MTK::Timeline.from_hash anything
+          when Enumerable,MTK::Events::Event then MTK::Timeline.from_hash(0 => anything)
+          else raise "#{self.class}.play() doesn't understand #{anything} (#{anything.class})"
+        end
+        timeline = timeline.flatten
+
+        scheduler_rate = options.fetch :scheduler_rate, 500 # default: 500 Hz
+        trailing_buffer = options.fetch :trailing_buffer, 2 # default: continue playing for 2 beats after the end of the timeline
+        in_background = options.fetch :background, false # default: don't run in background Thread
+        bpm = options.fetch :bmp, 120 # default: 120 beats per minute
+
+        @scheduler = Gamelan::Scheduler.new :tempo => bpm, :rate => scheduler_rate
+
+        timeline.each do |time,events|
+          events.each do |event|
+            next if event.rest?
+
+            channel = event.channel || 0
+
+            case event.type
+              when :note
+                pitch = event.midi_pitch
+                velocity = event.velocity
+                duration = event.duration.to_f
+                @scheduler.at(time) { note_on(pitch,velocity,channel) }
+                @scheduler.at(time + duration) { note_off(pitch,velocity,channel) }
+
+              when :control
+                @scheduler.at(time) { control(event.number, event.midi_value, channel) }
+
+              when :pressure
+                if event.number
+                  @scheduler.at(time) { poly_pressure(event.number, event.midi_value, channel) }
+                else
+                  @scheduler.at(time) { channel_pressure(event.midi_value, channel) }
+                end
+
+              when :bend
+                @scheduler.at(time) { bend(event.midi_value, channel) }
+
+              when :program
+                @scheduler.at(time) { program(event.number, channel) }
+            end
+          end
+        end
+
+        end_time = timeline.times.last + trailing_buffer
+        @scheduler.at(end_time) { @scheduler.stop }
+
+        thread = @scheduler.run
+        thread.join if not in_background
+      end
+
+
+      ########################
+      protected
+
+      # these all return stubbed data for testing purposes
+
+      # Send a note on event to the MIDI output
+      def note_on(midi_pitch, velocity, channel)
+        [:note_on, midi_pitch, velocity, channel] # stubbed data for testing purposes
+      end
+
+      # Send a note off event to the MIDI output
+      def note_off(midi_pitch, velocity, channel)
+        [:note_off, midi_pitch, velocity, channel]
+      end
+
+      # Send a control change event to the MIDI output
+      def control(number, midi_value, channel)
+        [:control, number, midi_value, channel]
+      end
+
+      # Send a poly pressure event to the MIDI output.
+      def poly_pressure(midi_pitch, midi_value, channel)
+        [:poly_pressure, midi_pitch, midi_value, channel]
+      end
+
+      # Send a channel pressure event to the MIDI output.
+      def channel_pressure(midi_value, channel)
+        [:channel_pressure, midi_value, channel]
+      end
+
+      # Send a pitch bend event to the MIDI output.
+      def bend(midi_value, channel)
+        [:bend, midi_value, channel]
+      end
+
+      # Send a program change event to the MIDI output.
+      def program(number, channel)
+        [:program, number, channel]
+      end
+
+    end
+
+  end
+end
+
+
+unless $__RUNNING_RSPEC_TESTS__ # I can't get this working on Travis-CI, problem installing native dependencies
+  if RbConfig::CONFIG['host_os'] =~ /darwin/
+    # We're running on OS X
+    require 'mtk/midi/dls_synth_output'
+  end
+
+  if RUBY_PLATFORM == 'java'
+    require 'mtk/midi/jsound_output'
+  else
+    require 'mtk/midi/unimidi_output'
+  end
+end