mtk 0.0.1 → 0.0.2

data/lib/mtk/_constants/pitches.rb

@@ -0,0 +1,49 @@
+module MTK
+
+  # Defines a constants for each {Pitch} in the standard MIDI range using scientific pitch notation.
+  #
+  # See http://en.wikipedia.org/wiki/Scientific_pitch_notation
+  #
+  # @note Because the character '#' cannot be used in the name of a constant,
+  #     the "black key" pitches are all named as flats with 'b' (for example, Gb3 or Cb4)
+  # @note Because the character '-' (minus) cannot be used in the name of a constant,
+  #     the low pitches use '_' (underscore) in place of '-' (minus) (for example C_1).
+  module Pitches
+
+    # The values of all "psuedo constants" defined in this module
+    PITCHES = []
+
+    # The names of all "psuedo constants" defined in this module
+    PITCH_NAMES = []
+
+    128.times do |note_number|
+      pitch = Pitch.from_i( note_number )
+      PITCHES << pitch
+
+      octave_str = pitch.octave.to_s.sub(/-/,'_') # '_1' for -1
+      name = "#{pitch.pitch_class}#{octave_str}"
+      PITCH_NAMES << name
+
+      const_set name, pitch
+    end
+
+    PITCHES.freeze
+    PITCH_NAMES.freeze
+
+    # Lookup the value of an pitch constant by name.
+    # @example lookup value of 'C3'
+    #         MTK::Pitches['C3']
+    # @see Pitch.from_s
+    # @note Unlike {Pitch.from_s} this method will accept either '_' (underscore) or '-' (minus) and treat it like '-' (minus)
+    # @note Unlike {Pitch.from_s} this method only accepts the accidental 'b'
+    def self.[](name)
+      begin
+        const_get name.sub('-','_')
+      rescue
+        nil
+      end
+    end
+
+  end
+
+end

data/lib/mtk/event.rb

@@ -7,9 +7,6 @@ module MTK
     # intensity of the note as a value in the range 0.0 - 1.0
     attr_reader :intensity
 
-    # duration of the note in beats (e.g. 1.0 is a quarter note in 4/4 time signatures)
-    attr_reader :duration
-
     def initialize(intensity, duration)
       @intensity, @duration = intensity, duration
     end
@@ -36,11 +33,23 @@ module MTK
 
     # intensity scaled to the MIDI range 0-127
     def velocity
-      (127 * @intensity).round
+      @velocity ||= (127 * @intensity).round
+    end
+
+    # Duration of the Event in beats (e.g. 1.0 is a quarter note in 4/4 time signatures)
+    # This is the absolute value of the duration attribute used to construct the object.
+    # @see rest?
+    def duration
+      @abs_duration ||= @duration.abs
+    end
+
+    # By convention, any events with negative durations are considered a rest
+    def rest?
+      @duration < 0
     end
 
     def duration_in_pulses(pulses_per_beat)
-      (@duration * pulses_per_beat).round
+      @duration_in_pulses ||= (duration * pulses_per_beat).round
     end
 
     def == other

data/lib/mtk/helper/collection.rb

@@ -0,0 +1,114 @@
+module MTK::Helper
+
+  # Given a method #elements, which returns an Array of elements in the collection,
+  # including this module will make the class Enumerable and provide various methods you'd expect from an Array.
+  module Collection
+    include Enumerable
+
+    # A mutable array of elements in this collection
+    def to_a
+      Array.new(elements) # we construct a new array since some including classes make elements be immutable
+    end
+
+    # The number of elements in this collection
+    def size
+      elements.size
+    end
+    alias length size
+
+    def empty?
+      elements.nil? or elements.size == 0
+    end
+
+    # The each iterator for providing Enumerable functionality
+    def each &block
+      elements.each &block
+    end
+
+    # The first element
+    def first(n=nil)
+      n ? elements.first(n) : elements.first
+    end
+
+    # The last element
+    def last(n=nil)
+      n ? elements.last(n) : elements.last
+    end
+
+    # The element with the given index
+    def [](index)
+      elements[index]
+    end
+
+    def repeat(times=2)
+      full_repetitions, fractional_repetitions = times.floor, times%1  # split into int and fractional part
+      repeated = elements * full_repetitions
+      repeated += elements[0...elements.size*fractional_repetitions]
+      clone_with repeated
+    end
+
+    def permute
+      clone_with elements.shuffle
+    end
+    alias shuffle permute
+
+    def rotate(offset=1)
+      clone_with elements.rotate(offset)
+    end
+
+    def concat(other)
+      other_elements = (other.respond_to? :elements) ? other.elements : other
+      clone_with(elements + other_elements)
+    end
+
+    def reverse
+      clone_with elements.reverse
+    end
+    alias retrograde reverse
+
+    def ==(other)
+      if other.respond_to? :elements
+        if other.respond_to? :options
+          elements == other.elements and @options == other.options
+        else
+          elements == other.elements
+        end
+      else
+        elements == other
+      end
+    end
+
+    # Create a copy of the collection.
+    # In order to use this method, the including class must implement .from_a()
+    def clone
+      clone_with to_a
+    end
+
+    #################################
+    private
+
+    # "clones" the object with the given elements, attempting to maintain any @options
+    # This is designed to work with 2 argument constructors: def initialize(elements, options={})
+    def clone_with elements
+      from_a = self.class.method(:from_a)
+      if from_a.arity == -2
+        from_a[elements, (@options || {})]
+      else
+        from_a[elements]
+      end
+    end
+
+  end
+
+end
+
+if not Array.instance_methods.include? :rotate
+  # Array#rotate is only available in Ruby 1.9, so we may have to implement it
+  class Array
+    def rotate(offset=1)
+      return self if empty?
+      offset %= length
+      self[offset..-1]+self[0...offset]
+    end
+  end
+end

data/lib/mtk/helper/event_builder.rb

@@ -0,0 +1,85 @@
+module MTK
+  module Helper
+
+    # A helper class for {Sequencer}s.
+    # Takes a list of patterns and constructs a list of {Event}s from the next elements in each pattern.
+    class EventBuilder
+
+      DEFAULT_PITCH = MTK::Pitches::C4
+      DEFAULT_INTENSITY = MTK::Intensities::f
+      DEFAULT_DURATION = 1
+
+      def initialize(patterns, options={})
+        @patterns = patterns
+        @options = options
+        @max_interval = options.fetch :max_interval, 12
+        rewind
+      end
+
+      # Build a list of events from the next element in each {Pattern}
+      # @return [Array] an array of events
+      def next
+        pitches = []
+        intensity = @default_intensity
+        duration = @default_duration
+
+        for pattern in @patterns
+          element = pattern.next
+          case element
+            when Pitch         then pitches << element
+            when PitchSet      then pitches += element.pitches
+            when PitchClass    then pitches += pitches_for_pitch_classes([element], @previous_pitch || @default_pitch)
+            when PitchClassSet then pitches += pitches_for_pitch_classes(element, @previous_pitch || @default_pitch)
+            else case pattern.type
+              when :pitch
+                if element.is_a? Numeric
+                  # pitch interval case
+                  if @previous_pitches
+                    pitches += @previous_pitches.map{|pitch| pitch + element }
+                  else
+                    pitches << ((@previous_pitch || @default_pitch) + element)
+                  end
+                end
+              when :intensity then intensity = element
+              when :duration then duration = element
+            end
+          end
+        end
+
+        if not pitches.empty?
+          @previous_pitch = pitches.last
+          @previous_pitches = pitches.length > 1 ? pitches : nil
+          pitches.map{|pitch| Note(pitch,intensity,duration) }
+        else
+          nil
+        end
+      end
+
+      # Reset the EventBuilder to its initial state
+      def rewind
+        @default_pitch = @options.fetch :default_pitch, DEFAULT_PITCH
+        @default_intensity = @options.fetch :default_intensity, DEFAULT_INTENSITY
+        @default_duration = @options.fetch :default_duration, DEFAULT_DURATION
+        @previous_pitch = nil
+        @previous_pitches = nil
+        @patterns.each{|pattern| pattern.rewind }
+      end
+
+      ########################
+      private
+
+      def pitches_for_pitch_classes(pitch_classes, previous_pitch)
+        pitches = []
+        for pitch_class in pitch_classes
+          pitch = previous_pitch.nearest(pitch_class)
+          pitch -= 12 if pitch > @default_pitch+@max_interval # keep within max_distance of start (default is one octave)
+          pitch += 12 if pitch < @default_pitch-@max_interval
+          pitches << pitch
+        end
+        pitches
+      end
+
+    end
+
+  end
+end

data/lib/mtk/{constants → helper}/pseudo_constants.rb

@@ -1,10 +1,11 @@
-module MTK
-  
+module MTK::Helper
+
+
   # Extension for modules that want to define pseudo-constants (constant-like values with lower-case names)
   module PseudoConstants
-  
-    # Define a "constant" as a module method and module function (available both through the module namespace and as a mixin method),
-    # in order to facility defining constant-like values with lower-case names.
+
+    # Define a module method and module function (available both through the module namespace and as a mixin method),
+    # to provide a constant with a lower-case name.
     #
     # @param name [Symbol] the name of the pseudo-constant
     # @param value [Object] the value of the pseudo-constant
@@ -21,5 +22,5 @@ module MTK
     end
 
   end
-  
+
 end

data/lib/mtk/lang/grammar.rb

@@ -0,0 +1,17 @@
+require 'citrus'
+Citrus.load File.join(File.dirname(__FILE__),'mtk_grammar')
+
+module MTK
+  module Lang
+
+    # Parser for the {file:lib/mtk/lang/mtk_grammar.citrus MTK grammar}
+    class Grammar
+
+      def self.parse(syntax, root=:pitch)
+        MTK_Grammar.parse(syntax, :root => root).value
+      end
+
+    end
+
+  end
+end

data/lib/mtk/lang/mtk_grammar.citrus

@@ -0,0 +1,60 @@
+grammar MTK_Grammar
+  include MTK
+
+  rule pitch_sequence
+    ( pitch (space pitch)* ) {
+      Pattern.PitchSequence *captures[:pitch].map{|p| p.value }
+    }
+  end
+
+  rule pitch
+    ( pitch_class int ) {
+      Pitch[pitch_class.value, int.value]
+    }
+  end
+
+  rule pitch_class
+    ( [A-Ga-g] [#b]*2 ) {
+      PitchClass[to_s]
+    }
+  end
+
+  rule interval
+    ( 'P' [1458] | [Mm] [2367] | 'TT' ) {
+      Intervals[to_s]
+    }
+  end
+
+  rule intensity
+    ( ('p'1*3 | 'mp' | 'mf' | 'f'1*3) ('+'|'-')? ) {
+      Intensities[to_s]
+    }
+  end
+
+  rule duration
+    ( [whqesrx] ('.'|'t')* ) {
+      Durations[to_s]
+    }
+  end
+
+  rule number
+    float | int
+  end
+
+  rule float
+    ( '-'? [0-9]+ '.' [0-9]+ ) {
+      to_f
+    }
+  end
+
+  rule int
+    ( '-'? [0-9]+ ) {
+      to_i
+    }
+  end
+
+  rule space
+    [\s]+ { nil }
+  end
+
+end

data/lib/mtk/midi/file.rb

@@ -82,24 +82,18 @@ module MTK
         track = add_track sequence
         channel = 1
 
-        for time, event in timeline
+        for time,events in timeline
           time *= clock_rate
-          case event
-            when Note
+
+          for event in events
+            next if event.rest?
+
+            if event.is_a? Note
               pitch, velocity = event.pitch, event.velocity
               add_event track, time => note_on(channel, pitch, velocity)
               duration = event.duration_in_pulses(clock_rate)
               add_event track, time+duration => note_off(channel, pitch, velocity)
-
-            when Chord
-              velocity = event.velocity
-              duration = event.duration_in_pulses(clock_rate)
-              for pitch in event.pitches
-                pitch = pitch.to_i
-                add_event track, time => note_on(channel, pitch, velocity)
-                add_event track, time+duration => note_off(channel, pitch, velocity)
-              end
-
+            end
           end
         end
         track.recalc_delta_from_times
@@ -160,16 +154,17 @@ module MTK
 
       def add_event track, event_hash
         for time, event in event_hash
-          event.time_from_start = time
+          event.time_from_start = time.round # MIDI file event times must be in whole number pulses (typically 480 or 960 per quarter note)
           track.events << event
           event
         end
       end
 
     end
-
   end
 
+  # Shortcut for MTK::MIDI::File.new
+  # @note Only available if you require 'mtk/midi/file'
   def MIDI_File(f)
     MIDI::File.new(f)
   end

data/lib/mtk/midi/jsound_input.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'jsound'
+
+module MTK
+  module MIDI
+
+    # Provides MIDI input for JRuby via the jsound gem
+    class JSoundInput
+
+      def initialize(input_device)
+        if input_device.is_a? ::JSound::Midi::Device
+          @input = input_device
+        else
+          @input = ::JSound::Midi::INPUTS.send input_device
+        end
+        @recorder = ::JSound::Midi::Devices::Recorder.new(false)
+        @input >> @recorder
+      end
+
+      def record
+        @input.open
+        @recorder.clear
+        @recorder.start
+      end
+
+      def stop
+        @recorder.stop
+        @input.close
+      end
+
+      def to_timeline(options={})
+        bpm = options.fetch :bmp, 120
+        beats_per_second = bpm.to_f/60
+        timeline = Timeline.new
+        note_ons = {}
+        start = nil
+
+        for message,time in @recorder.messages_with_timestamps
+          start = time unless start
+          time -= start
+          time /= beats_per_second
+
+          case message.type
+            when :note_on
+              note_ons[message.pitch] = [message,time]
+
+            when :note_off
+              if note_ons.has_key? message.pitch
+                note_on, start_time = note_ons[message.pitch]
+                duration = time - start_time
+                note = Note.from_midi note_on.pitch, note_on.velocity, duration
+                timeline.add time,note
+              end
+
+            else timeline.add time,message
+          end
+        end
+
+        timeline.quantize! options[:quantize] if options.key? :quantize
+        timeline.shift_to! options[:shift_to] if options.key? :shift_to
+
+        timeline
+      end
+
+    end
+  end
+end
+

data/lib/mtk/midi/jsound_output.rb

@@ -0,0 +1,80 @@
+require 'rubygems'
+require 'jsound'
+require 'gamelan'
+
+module MTK
+  module MIDI
+
+    # Provides MIDI output for JRuby via the jsound gem
+    class JSoundOutput
+
+      attr_reader :device
+
+      def initialize(output, options={})
+        if output.is_a? ::JSound::Midi::Device
+          @device = output
+        else
+          @device = ::JSound::Midi::OUTPUTS.send output
+        end
+
+        @generator = ::JSound::Midi::Devices::Generator.new
+        if options[:monitor]
+          @monitor = ::JSound::Midi::Devices::Monitor.new
+          @generator >> [@monitor, @device]
+        else
+          @generator >> @device
+        end
+        @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
+
+        end_time = timeline.times.last + trailing_buffer
+        @scheduler.at(end_time) { @scheduler.stop }
+
+        thread = @scheduler.run
+        thread.join if not in_background
+      end
+
+      ######################
+      private
+
+      # 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)
+
+      def note_on(pitch, velocity)
+        lambda { @generator.note_on(pitch, velocity) }
+      end
+
+      def note_off(pitch, velocity)
+        lambda { @generator.note_off(pitch, velocity) }
+      end
+
+      def at time, block
+        @scheduler.at(time) { block.call }
+      end
+
+    end
+  end
+end
+

data/lib/mtk/note.rb

@@ -1,6 +1,6 @@
 module MTK
 
-  # A musical #{Event} defined by a {Pitch}, intensity, and duration
+  # A musical {Event} defined by a {Pitch}, intensity, and duration
   class Note < Event
 
     # frequency of the note as a Pitch
@@ -15,18 +15,26 @@ module MTK
       new hash[:pitch], hash[:intensity], hash[:duration]
     end
 
+    def to_hash
+      super.merge({ :pitch => @pitch })
+    end
+
     def self.from_midi(pitch, velocity, beats)
       new Pitches::PITCHES[pitch], velocity/127.0, beats
     end
 
-    def to_hash
-      super.merge({ :pitch => @pitch })
+    def to_midi
+      [pitch.to_i, velocity, duration]
     end
 
     def transpose(interval)
       self.class.new(@pitch+interval, @intensity, @duration)
     end
 
+    def invert(around_pitch)
+      self.class.new(@pitch.invert(around_pitch), @intensity, @duration)
+    end
+
     def == other
       super and other.respond_to? :pitch and @pitch == other.pitch
     end
@@ -41,4 +49,15 @@ module MTK
 
   end
 
+  # Construct a {Note} from any supported type
+  def Note(*anything)
+    anything = anything.first if anything.size == 1
+    case anything
+      when Array then Note.new(*anything)
+      when Note then anything
+      else raise "Note doesn't understand #{anything.class}"
+    end
+  end
+  module_function :Note
+
 end