jmtk 0.0.3.3-java

data/lib/mtk/io/unimidi_input.rb

@@ -0,0 +1,117 @@
+require 'unimidi'
+require 'ostruct'
+
+module MTK
+  module IO
+
+    # Provides realtime MIDI input for MRI/YARV Ruby via the unimidi gem.
+    # @note This class is optional and only available if you require 'mtk/midi/unimidi_input'.
+    #       It depends on the 'unimidi' gem.
+    class UniMIDIInput < MIDIInput
+
+      public_class_method :new
+
+      def self.devices
+        @devices ||= ::UniMIDI::Input.all.reject{|d| d.name.strip.empty? }
+      end
+
+      def self.devices_by_name
+        @devices_by_name ||= devices.each_with_object( Hash.new ){|device,hash| hash[device.name] = device }
+      end
+
+
+      attr_reader :device, :recording, :thread
+
+      def initialize(input_device, options={})
+        super
+        @open_time = Time.now.to_f
+      end
+
+      def record(options={})
+        @recording = [] unless options[:append] and @recording
+        monitor = options[:monitor]
+
+        stop
+        @thread = Thread.new do
+          @start_time = Time.now.to_f
+          loop do
+            @device.gets.each do |data|
+              puts data if monitor
+              record_raw_data data
+            end
+            sleep 0.001
+          end
+        end
+
+        time_limit = options[:time_limit]
+        if time_limit
+          puts "Blocking current thread for #{time_limit} seconds to record MIDI input."
+          @thread.join(time_limit)
+        end
+      end
+
+      def stop
+        Thread.kill @thread if @thread
+      end
+
+      def to_timeline(options={})
+        return nil if not @recording
+
+        bpm = options.fetch :bmp, 120
+        beats_per_second = bpm.to_f/60
+        timeline = Timeline.new
+        note_ons = {}
+        start = nil
+
+        @recording.each do |message, time|
+          start ||= time
+          time -= start
+          time /= beats_per_second
+
+          if message.is_a? MTK::Events::Event
+            timeline.add time,message
+          else
+            case message.type
+            when :note_on
+              pitch = message.pitch
+              note_ons[pitch] = [message,time]
+
+            when :note_off
+              pitch = message.pitch
+              if note_ons.has_key? pitch
+                note_on, start_time = note_ons.delete(pitch)
+                duration = time - start_time
+                note = MTK::Events::Note.from_midi pitch, note_on.velocity, duration
+                timeline.add time,note
+              end
+            end
+          end
+        end
+
+        timeline.quantize! options[:quantize] if options.key? :quantize
+        timeline.shift_to! options[:shift_to] if options.key? :shift_to
+
+        timeline
+      end
+
+
+      #######################
+      private
+
+      def record_raw_data raw
+        status, data1, data2 = *raw[:data] # the 3 bytes of raw message data
+        message = (
+          case status & 0xF0
+            when 0x80 then OpenStruct.new({:type => :note_off, :pitch => data1, :velocity => data2})
+            when 0x90 then OpenStruct.new({:type => :note_on,  :pitch => data1, :velocity => data2})
+            else MTK::Events::Parameter.from_midi(status,data1,data2)
+          end
+        )
+        time = raw[:timestamp]/1000 - (@start_time - @open_time)
+        @recording << [message, time]
+      end
+
+    end
+  end
+end
+

data/lib/mtk/io/unimidi_output.rb

@@ -0,0 +1,140 @@
+require 'unimidi'
+
+module MTK
+  module IO
+
+    # Provides realtime MIDI output for "standard" Ruby (MRI) via the unimidi and gamelan gems.
+    # @note This class is optional and only available if you require 'mtk/midi/unimidi_output'.
+    #       It depends on the 'unimidi' and 'gamelan' gems.
+    class UniMIDIOutput < MIDIOutput
+
+      public_class_method :new
+
+      def self.devices
+        @devices ||= ::UniMIDI::Output.all.reject{|d| d.name.strip.empty? }
+      end
+
+      def self.devices_by_name
+        @devices_by_name ||= devices.each_with_object( Hash.new ){|device,hash| hash[device.name] = device }
+      end
+
+
+      ######################
+      protected
+
+      # (see MIDIOutput#note_on)
+      def note_on(pitch, velocity, channel)
+        @device.puts(0x90|channel, pitch, velocity)
+      end
+
+      # (see MIDIOutput#note_off)
+      def note_off(pitch, velocity, channel)
+        @device.puts(0x80|channel, pitch, velocity)
+      end
+
+      # (see MIDIOutput#control)
+      def control(number, midi_value, channel)
+        @device.puts(0xB0|channel, number, midi_value)
+      end
+
+      # (see MIDIOutput#channel_pressure)
+      def channel_pressure(midi_value, channel)
+        @device.puts(0xD0|channel, midi_value, 0)
+      end
+
+      # (see MIDIOutput#poly_pressure)
+      def poly_pressure(pitch, midi_value, channel)
+        @device.puts(0xA0|channel, pitch, midi_value)
+      end
+
+      # (see MIDIOutput#bend)
+      def bend(midi_value, channel)
+        @device.puts(0xE0|channel, midi_value & 127, (midi_value >> 7) & 127)
+      end
+
+      # (see MIDIOutput#program)
+      def program(number, channel)
+        @device.puts(0xC0|channel, number, 0)
+      end
+
+    end
+  end
+end
+
+
+#####################################################################
+# MONKEY PATCHING for https://github.com/arirusso/ffi-coremidi/pull/2
+# This can be removed once that pull request is released.
+
+if RbConfig::CONFIG['host_os'] =~ /darwin/
+  # We're running on OS X
+
+  begin
+    ffi_coremidi_exists = !CoreMIDI::Map::CF.nil?
+  rescue NameError
+    ffi_coremidi_exists = false
+  end
+
+  if ffi_coremidi_exists
+
+    # @private
+    module CoreMIDI
+
+      # @private
+      class Device
+        def initialize(id, device_pointer, options = {})
+          include_if_offline = options[:include_offline] || false
+          @id = id
+          @resource = device_pointer
+          @entities = []
+
+          prop = Map::CF.CFStringCreateWithCString( nil, "name", 0 )
+          begin
+            name_ptr = FFI::MemoryPointer.new(:pointer)
+            Map::MIDIObjectGetStringProperty(@resource, prop, name_ptr)
+            name = name_ptr.read_pointer
+            len = Map::CF.CFStringGetMaximumSizeForEncoding(Map::CF.CFStringGetLength(name), :kCFStringEncodingUTF8)
+            bytes = FFI::MemoryPointer.new(len + 1)
+            raise RuntimeError.new("CFStringGetCString") unless Map::CF.CFStringGetCString(name, bytes, len, :kCFStringEncodingUTF8)
+            @name = bytes.read_string
+          ensure
+            Map::CF.CFRelease(name) unless name.nil? || name.null?
+            Map::CF.CFRelease(prop) unless prop.null?
+          end
+          populate_entities(:include_offline => include_if_offline)
+        end
+
+      end
+
+      # @private
+      module Map
+
+        # @private
+        module CF
+
+          extend FFI::Library
+          ffi_lib '/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation'
+
+          typedef :pointer, :CFStringRef
+          typedef :long, :CFIndex
+          enum :CFStringEncoding, [ :kCFStringEncodingUTF8, 0x08000100 ]
+
+          # CFString* CFStringCreateWithCString( ?, CString, encoding)
+          attach_function :CFStringCreateWithCString, [:pointer, :string, :int], :pointer
+          # CString* CFStringGetCStringPtr(CFString*, encoding)
+          attach_function :CFStringGetCStringPtr, [:pointer, :int], :pointer
+
+          attach_function :CFStringGetLength, [ :CFStringRef ], :CFIndex
+
+          attach_function :CFStringGetMaximumSizeForEncoding, [ :CFIndex, :CFStringEncoding ], :long
+
+          attach_function :CFStringGetCString, [ :CFStringRef, :pointer, :CFIndex, :CFStringEncoding ], :bool
+
+          attach_function :CFRelease, [ :pointer ], :void
+
+        end
+      end
+    end
+
+  end
+end

data/lib/mtk/lang/durations.rb

@@ -0,0 +1,57 @@
+require 'rational'
+
+module MTK
+  module Lang
+
+    # Defines duration constants using abbreviations for standard rhythm values ('w' for whole note, 'h' for half note, etc).
+    #
+    # In order to avoid conflict with pitch class 'e', the constant for eighth note is 'i'
+    #
+    # These can be thought of like constants, but they
+    # use lower-case names and therefore define them as "pseudo constant" methods.
+    # The methods are available either through the module (MTK::Core::Durations::e) or via mixin (include MTK::Core::Durations; q)
+    #
+    # These values assume the quarter note is one beat (1.0), so they work best with 4/4 and other */4 time signatures.
+    #
+    # @note Including this module defines a bunch of single-character variables, which may shadow existing variable names.
+    #       Just be mindful of what is defined in this module when including it.
+    #
+    # @see Note
+    module Durations
+      extend MTK::Lang::PseudoConstants
+
+      # NOTE: the yard doc macros here only fill in [$2] with the actual value when generating docs under Ruby 1.9+
+
+      # whole note
+      # @macro [attach] durations.define_constant
+      #   @attribute [r]
+      #   @return [$2] number of beats for $1
+      define_constant 'w', MTK::Core::Duration[4]
+
+      # half note
+      define_constant 'h', MTK::Core::Duration[2]
+
+      # quarter note
+      define_constant 'q', MTK::Core::Duration[1]
+
+      # eight note
+      define_constant 'i', MTK::Core::Duration[Rational(1,2)]
+
+      # sixteenth note
+      define_constant 's', MTK::Core::Duration[Rational(1,4)]
+
+      # thirty-second note
+      define_constant 'r', MTK::Core::Duration[Rational(1,8)]
+
+      # sixty-fourth note
+      define_constant 'x', MTK::Core::Duration[Rational(1,16)]
+
+      # The values of all "psuedo constants" defined in this module
+      DURATIONS = [w, h, q, i, s, r, x].freeze
+
+      # The names of all "psuedo constants" defined in this module
+      DURATION_NAMES = MTK::Core::Duration::NAMES
+
+    end
+  end
+end

data/lib/mtk/lang/intensities.rb

@@ -0,0 +1,61 @@
+module MTK
+  module Lang
+
+    # Defines intensity constants using standard dynamic symbols.
+    #
+    # These can be thought of like constants, but in order to distinguish 'f' (forte) from the {PitchClass} 'F'
+    # it was necessary to use lower-case names and therefore define them as "pseudo constant" methods.
+    # The methods are available either through the module (MTK::Intensities::f) or via mixin (include MTK::Intensities;  f)
+    #
+    # These values are intensities in the range 0.125 - 1.0 (in increments of 1/8), so they can be easily scaled (unlike MIDI velocities).
+    #
+    # It is also possible to retrieve values in increments of 1/24 by using the '+' and '-' suffix when looking
+    # up values via the {.[]} method.
+    #
+    # @note Including this module shadows Ruby's built-in p() method.
+    #   If you include this module, you can access the built-in p() method via Kernel.p()
+    #
+    # @see Note
+    module Intensities
+      extend MTK::Lang::PseudoConstants
+
+      # NOTE: the yard doc macros here only fill in [$2] with the actual value when generating docs under Ruby 1.9+
+
+      # pianississimo
+      # @macro [attach] intensities.define_constant
+      #   @attribute [r]
+      #   @return [$2] intensity value for $1
+      define_constant 'ppp', MTK::Core::Intensity[0.125]
+
+      # pianissimo
+      define_constant 'pp', MTK::Core::Intensity[0.25]
+
+      # piano
+      # @note Including this module shadows Ruby's built-in p() method.
+      #   If you include this module, you can access the built-in p() method via Kernel.p()
+      define_constant 'p', MTK::Core::Intensity[0.375]
+
+      # mezzo-piano
+      define_constant 'mp', MTK::Core::Intensity[0.5]
+
+      # mezzo-forte
+      define_constant 'mf', MTK::Core::Intensity[0.625]
+
+      # forte
+      define_constant 'o', MTK::Core::Intensity[0.75]
+
+      # fortissimo
+      define_constant 'ff', MTK::Core::Intensity[0.875]
+
+      # fortississimo
+      define_constant 'fff', MTK::Core::Intensity[1.0]
+
+      # The values of all "psuedo constants" defined in this module
+      INTENSITIES = [ppp, pp, p, mp, mf, o, ff, fff].freeze
+
+      # The names of all "psuedo constants" defined in this module
+      INTENSITY_NAMES = MTK::Core::Intensity::NAMES
+
+    end
+  end
+end

data/lib/mtk/lang/intervals.rb

@@ -0,0 +1,73 @@
+module MTK
+  module Lang
+
+    # Defines a constant for intervals up to an octave using diatonic naming conventions (see http://en.wikipedia.org/wiki/Interval_(music)#Main_intervals)
+    #
+    # Naming conventions
+    #   P#: perfect interval
+    #   M#: major interval
+    #   m#: minor interval
+    #   TT: tritone (AKA augmented 4th or diminished 5th)
+    #
+    # These can be thought of like constants, but in order to succinctly distinguish 'm2' (minor) from 'M2' (major),
+    # it was necessary to use lower-case names for some of the values and therefore define them as "pseudo constant" methods.
+    # The methods are available either through the module (MTK::Core::Intervals::m2) or via mixin (include MTK::Core::Intervals; m2)
+    module Intervals
+      extend MTK::Lang::PseudoConstants
+
+      # NOTE: the yard doc macros here only fill in [$2] with the actual value when generating docs under Ruby 1.9+
+
+      # perfect unison
+      # @macro [attach] interval.define_constant
+      #   @attribute [r]
+      #   @return [$2] number of semitones in the interval $1
+      define_constant 'P1', MTK::Core::Interval[0]
+
+      # minor second
+      # @macro [attach] interval.define_constant
+      #   @attribute [r]
+      #   @return [$2] number of semitones in the interval $1
+      define_constant 'm2', MTK::Core::Interval[1]
+
+      # major second
+      define_constant 'M2', MTK::Core::Interval[2]
+
+      # minor third
+      define_constant 'm3', MTK::Core::Interval[3]
+
+      # major third
+      define_constant 'M3', MTK::Core::Interval[4]
+
+      # pefect fourth
+      define_constant 'P4', MTK::Core::Interval[5]
+
+      # tritone (AKA augmented fourth or diminished fifth)
+      define_constant 'TT', MTK::Core::Interval[6]
+
+      # perfect fifth
+      define_constant 'P5', MTK::Core::Interval[7]
+
+      # minor sixth
+      define_constant 'm6', MTK::Core::Interval[8]
+
+      # major sixth
+      define_constant 'M6', MTK::Core::Interval[9]
+
+      # minor seventh
+      define_constant 'm7', MTK::Core::Interval[10]
+
+      # major seventh
+      define_constant 'M7', MTK::Core::Interval[11]
+
+      # pefect octave
+      define_constant 'P8', MTK::Core::Interval[12]
+
+      # The values of all "psuedo constants" defined in this module
+      INTERVALS = [P1, m2, M2, m3, M3, P4, TT, P5, m6, M6, m7, M7, P8].freeze
+
+      # The names of all "psuedo constants" defined in this module
+      INTERVAL_NAMES = MTK::Core::Interval::NAMES
+
+    end
+  end
+end