mtk 0.0.2 → 0.0.3

data/lib/mtk/midi/unimidi_input.rb

@@ -0,0 +1,117 @@
+require 'unimidi'
+require 'ostruct'
+
+module MTK
+  module MIDI
+
+    # 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 < Input
+
+      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/midi/unimidi_output.rb

@@ -0,0 +1,121 @@
+require 'unimidi'
+
+module MTK
+  module MIDI
+
+    # 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 < Output
+
+      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 Output#note_on)
+      def note_on(pitch, velocity, channel)
+        @device.puts(0x90|channel, pitch, velocity)
+      end
+
+      # (see Output#note_off)
+      def note_off(pitch, velocity, channel)
+        @device.puts(0x80|channel, pitch, velocity)
+      end
+
+      # (see Output#control)
+      def control(number, midi_value, channel)
+        @device.puts(0xB0|channel, number, midi_value)
+      end
+
+      # (see Output#channel_pressure)
+      def channel_pressure(midi_value, channel)
+        @device.puts(0xD0|channel, midi_value, 0)
+      end
+
+      # (see Output#poly_pressure)
+      def poly_pressure(pitch, midi_value, channel)
+        @device.puts(0xA0|channel, pitch, midi_value)
+      end
+
+      # (see Output#bend)
+      def bend(midi_value, channel)
+        @device.puts(0xE0|channel, midi_value & 127, (midi_value >> 7) & 127)
+      end
+
+      # (see Output#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.
+
+# @private
+module CoreMIDI
+  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
+
+  module Map
+    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

data/lib/mtk/{_numeric_extensions.rb → numeric_extensions.rb}

@@ -1,5 +1,17 @@
+# Optional Numeric methods for converting a number to common intervals.
+#
+# @note you must require 'mtk/numeric_extensions' to use these methods.
+#
 class Numeric
 
+  def beats
+    MTK::Duration(self)
+  end
+  alias beat beats
+
+
+  # TODO: these should all return intervals
+
   def semitones
     self
   end

data/lib/mtk/patterns/chain.rb

@@ -0,0 +1,49 @@
+module MTK
+  module Patterns
+
+    # A pattern that takes a list of patterns and combines their values into a list of event properties.
+    class Chain < Pattern
+
+      def initialize(elements, options={})
+        super
+        @stop_after_first = true # assume everything's an element until we inspect them in the loop below
+        @stop_after_first = true if @elements.all?{|element| not element.is_a? ::MTK::Patterns::Pattern }
+      end
+
+      ###################
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @is_element_done = Array.new(elements.size)
+        super
+      end
+
+      # (see Pattern#advance)
+      def advance
+        @current = @elements.map.with_index do |element,index|
+          if element.is_a? ::MTK::Patterns::Pattern
+            begin
+              element.next
+            rescue StopIteration
+              raise StopIteration if element.max_elements_exceeded?
+              @is_element_done[index] = true
+              element.rewind
+              element.next
+            end
+          else
+            element
+          end
+        end.flatten
+
+        raise StopIteration if @is_element_done.all?{|done| done }
+
+        @elements.each.with_index do |element,index|
+          @is_element_done[index] = true unless element.is_a? ::MTK::Patterns::Pattern
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mtk/{pattern → patterns}/choice.rb

@@ -1,15 +1,15 @@
 module MTK
-  module Pattern
+  module Patterns
 
     # Randomly choose from a list of elements.
     #
     # Supports giving different weights to different choices.
     # Default is to weight all choices equally.
     #
-    class Choice < AbstractPattern
+    class Choice < Pattern
 
-      # @param (see AbstractPattern#initialize)
-      # @option (see AbstractPattern#initialize)
+      # @param (see Pattern#initialize)
+      # @option (see Pattern#initialize)
       # @option options [Array] :weights a list of chances that each corresponding element will be selected (normalized against the total weight)
       # @example choose the second element twice as often as the first or third:
       #     MTK::Pattern::Choice.new [:first,:second,:third], :weights => [1,2,1]
@@ -22,12 +22,18 @@ module MTK
       #####################
       protected
 
-      # (see AbstractPattern#current)
-      def current
+      def advance
+        @index += 1
+        raise StopIteration if @index > 0
+
         target = rand * @total_weight
         @weights.each_with_index do |weight,index|
-          return @elements[index] if target < weight
-          target -= weight
+          if target < weight
+            @current = @elements[index]
+            break
+          else
+            target -= weight
+          end
         end
       end
 

data/lib/mtk/patterns/cycle.rb

@@ -0,0 +1,18 @@
+module MTK
+  module Patterns
+
+    # An endless enumerator that outputs an element one at a time from a list of elements,
+    # looping back to the beginning when elements run out.
+    # This is the same as a Sequence but by default has unlimited @max_cycles
+    class Cycle < Sequence
+
+      def initialize(elements, options={})
+        super
+        # Base Pattern & Sequence default to 1 max_cycle, this defaults to nil which is unlimited cycles
+        @max_cycles = options[:max_cycles]
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/for_each.rb

@@ -0,0 +1,71 @@
+module MTK
+  module Patterns
+
+    # For each value in the first sub-pattern, iterate over the second sub-pattern and chain the resulting values.
+    #
+    class ForEach < Pattern
+
+      # (see Pattern#next)
+      def next
+        @index = 0 if @index < 0
+
+        last_index = @elements.length-1
+        while @index <= last_index
+          # assume all elements are Patterns, otherwise this construct doesn't really have a point...
+          pattern = @elements[@index]
+          begin
+            element = pattern.next
+            value = evaluate_variables(element)
+
+            if @index == last_index # then emit values
+              @current = value
+              return emit(value)
+
+            else # not last element, so store variables
+              @vars.push value
+              @index += 1
+            end
+
+          rescue StopIteration
+            if @index==0
+              raise # We're done when the first pattern is done
+            else
+              pattern.rewind
+              @vars.pop
+              @index -= 1
+            end
+          end
+        end
+      end
+
+
+      ###################
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @vars = []
+        @elements.each{|elem| elem.rewind }
+        super
+      end
+
+
+      ####################
+      private
+
+      def evaluate_variables(element)
+        case element
+          when ::MTK::Variable
+            if element.implicit?
+              return @vars[-element.name.length] # '$' is most recently pushed value, $$' goes back 2 levels, '$$$' goes back 3, etc
+            end
+          when Array
+            return element.map{|e| evaluate_variables(e) }
+        end
+        return element
+      end
+
+    end
+
+  end
+end

data/lib/mtk/patterns/function.rb

@@ -0,0 +1,39 @@
+module MTK
+  module Patterns
+
+    # An arbitrary function that dynamically generates elements.
+    #
+    class Function < Pattern
+
+      attr_reader :function
+      
+      def initialize(elements, options={})
+        # unpack from the varargs Array that may be passed in from the "convenience constructor methods" defined in MTK::Pattern                        \
+        @function = if elements.is_a? Enumerable then elements.first else elements end
+        super [@function], options
+      end
+
+
+      ###################
+      protected
+
+      # (see Pattern#rewind_or_cycle)
+      def rewind_or_cycle(is_cycling=false)
+        @function_call_count = -1
+        super
+      end
+
+      def advance
+        @function_call_count += 1
+        @current = case @function.arity
+          when 0 then @function.call
+          when 1 then @function.call(@current)
+          when 2 then @function.call(@current, @function_call_count)
+          else @function.call(@current, @function_call_count, @element_count)
+        end
+      end
+
+    end
+
+  end
+end