jmtk 0.0.3.3-java

data/lib/mtk/io/midi_input.rb

@@ -0,0 +1,97 @@
+module MTK
+  module IO
+
+    # Common behavior for realtime MIDI input.
+    #
+    class MIDIInput
+
+      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/io/jsound_input'
+  else
+    require 'mtk/io/unimidi_input'
+  end
+end

data/lib/mtk/io/midi_output.rb

@@ -0,0 +1,195 @@
+require 'rbconfig'
+require 'gamelan'
+
+module MTK
+  module IO
+
+    # 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 MIDIOutput
+
+      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::Events::Timeline then anything
+          when Hash then  MTK::Events::Timeline.from_h anything
+          when Enumerable,MTK::Events::Event then  MTK::Events::Timeline.from_h(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/io/dls_synth_output'
+  end
+
+  if RUBY_PLATFORM == 'java'
+    require 'mtk/io/jsound_output'
+  else
+    require 'mtk/io/unimidi_output'
+  end
+end

data/lib/mtk/io/notation.rb

@@ -0,0 +1,162 @@
+require 'tempfile'
+require 'tmpdir'
+require 'fileutils'
+
+module MTK
+  module IO
+
+    # Uses {Events::Timeline}s to generates music notation graphics with {http://lilypond.org/ Lilypond}.
+    # @note This class is optional and only available if you require 'mtk/io/lilypond'.
+    # @note To make notation graphics, {http://lilypond.org/download.html Lilypond} must be installed
+    #       and you must follow the "Running on the command-line" instructions (found on the download page for
+    #       your operating system). If the lilypond command is not on your PATH, set the environment variable LILYPOND_PATH
+    class Notation
+
+      LILYPOND_PATH = ENV['LILYPOND_PATH'] || 'lilypond'
+
+      VALID_FORMATS = %w( png pdf ps )
+
+
+      def initialize(file, options={})
+        @file = file
+        @options = options
+
+        @format = File.extname(file)[1..-1].downcase
+        raise ArgumentError.new("Invalid file format '#{@format}'") unless VALID_FORMATS.include? @format
+
+        @dpi = options[:dpi]
+      end
+
+      def self.open(file, options={})
+        new(file,options)
+      end
+
+
+      def write(timeline)
+        lilypond_syntax = syntax_for_timeline(timeline)
+        puts lilypond_syntax
+        puts "_____________________________"
+        Tempfile.open('mtk_lilypond') do |lilypond_file|
+          Dir.mktmpdir do |tmpdir|
+            # use the directory...
+            #open("#{dir}/foo", "w") { ... }
+
+            lilypond_file.write(lilypond_syntax)
+            lilypond_file.flush
+
+            cmd = ['lilypond', '-dbackend=eps', "-f#{@format}", "--output=\"#{tmpdir}\""]
+            cmd << "-dresolution=#{@dpi}" if @dpi
+            cmd << lilypond_file.path
+            cmd = cmd.join(' ')
+
+            puts cmd if $DEBUG
+            lilypond_command_output = `#{cmd}`
+            puts lilypond_command_output if $DEBUG
+
+            output_file = Dir["#{tmpdir}/*.#{@format}"].first
+
+            FileUtils.cp output_file, @file
+
+            puts "Wrote #{@file}"
+          end
+        end
+      end
+
+
+      ########################
+      private
+
+      QUANTIZATION_INTERVAL = 0.0625 # 64th note granularity
+
+      SYNTAX_PREFIX = '
+      \language "english"
+      \paper{
+        oddFooterMarkup=##f
+        oddHeaderMarkup=##f
+      }
+      \new PianoStaff {
+        \autochange {
+      '
+
+      SYNTAX_SUFFIX = '
+        }
+      }
+      '
+
+      def syntax_for_timeline(timeline)
+        quantized_timeline = timeline.flatten.quantize(QUANTIZATION_INTERVAL)
+        last_time = 0
+        last_duration = 0
+
+        s = ''
+        s << SYNTAX_PREFIX
+
+        for time,events in quantized_timeline
+
+          # handle rests between notes
+          delta = time - last_time
+          if delta > last_duration
+            s << 'r'+syntax_for_duration(delta - last_duration)
+            s << ' '
+          end
+
+          notes = events.find_all{|event| event.type == :note }
+
+          if notes.length > 1
+            # a chord
+            s << '<'
+            total_duration = 0
+            for note in notes
+              total_duration += note.duration
+              s << syntax_for_pitch(note.pitch)
+              s << ' '
+            end
+            s << '>'
+            duration = total_duration.to_f/notes.length
+            s << syntax_for_duration(duration)
+
+          else # a single note
+            note = notes.first
+            s << syntax_for_pitch(note.pitch)
+            duration = note.duration
+            s << syntax_for_duration(duration)
+          end
+
+          last_time = time
+          last_duration = duration
+          s << ' '
+        end
+
+        s << SYNTAX_SUFFIX
+        s
+      end
+
+      def syntax_for_pitch(pitch)
+        syntax = pitch.pitch_class.name.downcase
+        if syntax.length > 0
+          syntax = syntax[0] + syntax[1..-1].gsub('b','f') # .gsub('#','s') pitch class names never have '#'
+        end
+        oct = pitch.octave
+        while oct > 3
+          syntax << "'"
+          oct -= 1
+        end
+        while oct < 3
+          syntax << ","
+          oct += 1
+        end
+        syntax
+      end
+
+      def syntax_for_duration(duration)
+        # TODO: handle dots, triplets, and ties of arbitrary durations
+        duration = MTK::Events::Timeline.quantize_time(duration.to_f.abs, QUANTIZATION_INTERVAL)
+        syntax = (4.0/duration).round
+        syntax = 1 if syntax < 1
+        syntax.to_s
+      end
+
+    end
+
+  end
+end