jmtk 0.0.3.3-java → 0.4-java

data/lib/mtk/core/pitch.rb

@@ -2,6 +2,8 @@ module MTK
   module Core
 
     # A frequency represented by a {PitchClass}, an integer octave, and an offset in semitones.
+    #
+    # @see Lang::Pitches
     class Pitch
 
       include Comparable

data/lib/mtk/core/pitch_class.rb

@@ -4,10 +4,10 @@ module MTK
     # A set of all pitches that are an integer number of octaves apart.
     # A {Pitch} has the same PitchClass as the pitches one or more octaves away.
     # @see https://en.wikipedia.org/wiki/Pitch_class
-    #
+    # @see Lang::PitchClasses
     class PitchClass
 
-      # The normalized names of the 12 pitch classes in the chromatic scale.
+      # The preferred names of the 12 pitch classes in the chromatic scale.
       # The index of each {#name} is the pitch class's numeric {#value}.
       NAMES = %w( C Db D Eb E F Gb G Ab A Bb B ).freeze
 
@@ -15,7 +15,7 @@ module MTK
       # organized such that each index contains the allowed names of the pitch class with a {#value} equal to that index.
       # @see VALID_NAMES
       VALID_NAMES_BY_VALUE =
-      [ # (valid names ), # value # normalized name
+      [ # (valid names ), # value # preferred name
         %w( B#  C  Dbb ), #   0   #   C
         %w( B## C# Db  ), #   1   #   Db
         %w( C## D  Ebb ), #   2   #   D
@@ -48,6 +48,9 @@ module MTK
 
       # The value of this pitch class.
       # An integer from 0..11 that indexes this pitch class in {PITCH_CLASSES} and the {#name} in {NAMES}.
+      #
+      # This value is fairly arbitrary and just used for sorting purposes and mod 12 arithmetic when composing
+      # directly with pitch classes.
       attr_reader :value
 
 

data/lib/mtk/events/event.rb

@@ -51,7 +51,7 @@ module MTK
       end
 
       def to_h
-        hash = {:type => @type}
+        hash = {type: @type}
         hash[:value] = @value unless @value.nil?
         hash[:duration] = @duration unless @duration.nil?
         hash[:number] = @number unless @number.nil?
@@ -82,6 +82,7 @@ module MTK
         @duration.length
       end
 
+      # True if this event represents a rest, false otherwise.
       # By convention, any events with negative durations are a rest
       def rest?
         @duration.rest?

data/lib/mtk/events/note.rb

@@ -2,7 +2,7 @@ module MTK
 
   module Events
 
-    # A musical {Event} defined by a {Pitch}, intensity, and duration
+    # A musical {Event} defined by a {Core::Pitch}, {Core::Intensity}, and {Core::Duration}
     class Note < Event
 
       DEFAULT_DURATION  = MTK::Core::Duration[1]

data/lib/mtk/events/parameter.rb

@@ -2,6 +2,7 @@ module MTK
 
   module Events
 
+    # A non-note event such as pitch bend, pressure (aftertouch), or control change (CC)
     class Parameter < Event
 
       def self.from_midi(status, data1, data2)

data/lib/mtk/events/rest.rb

@@ -0,0 +1,85 @@
+module MTK
+
+  module Events
+
+    # An interval of silence.
+    #
+    # By convention, MTK uses {Core::Duration}s with negative values for rests. This class forces the {#duration}
+    # to always have a negative value.
+    #
+    # @note Because a negative durations indicate rests, other {Event} classes may represent rests too.
+    #       Therefore, you should always determine if an {Event} is a rest via the {#rest?} method, instead
+    #       of seeing if the class is an MTK::Events::Rest
+    class Rest < Event
+
+      def initialize(duration, channel=nil)
+        super :rest, duration:duration, channel:channel
+        self.duration = @duration # force to be a rest
+      end
+
+      def self.from_h(hash)
+        new(hash[:duration], hash[:channel])
+      end
+
+      # Assign the duration, forcing to a negative value to indicate this is a rest.
+      def duration= duration
+        super
+        @duration = -@duration unless @duration.rest? # force to be a rest
+      end
+
+      # Rests don't have a corresponding value in MIDI, so this is nil
+      # @return nil
+      def midi_value
+        nil
+      end
+
+      # Rests don't have a corresponding value in MIDI, so this is a no-op
+      def midi_value= value
+      end
+
+      def to_s
+        "Rest(#{@duration})"
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} @duration=#{@duration.inspect}" +
+            if @channel then ", @channel=#{@channel}>" else '>' end
+      end
+
+    end
+  end
+
+
+  # Construct a {Events::Rest} from a list of any supported type for the arguments: pitch, intensity, duration, channel
+  def Rest(*anything)
+    anything = anything.first if anything.size == 1
+    case anything
+      when MTK::Events::Rest then anything
+      when MTK::Events::Event then MTK::Events::Rest.new(anything.duration, anything.channel)
+      when Numeric then MTK::Events::Rest.new(anything)
+      when Duration then MTK::Events::Rest.new(anything)
+
+      when Array
+        duration = nil
+        channel = nil
+        unknowns = []
+        anything.each do |item|
+          case item
+            when MTK::Core::Duration then duration = item
+            else unknowns << item
+          end
+        end
+
+        duration  = MTK.Duration(unknowns.shift)  if duration.nil?  and not unknowns.empty?
+        raise "MTK::Rest() couldn't find a duration in arguments: #{anything.inspect}" if duration.nil?
+        channel = unknowns.shift.to_i if channel.nil? and not unknowns.empty?
+
+        MTK::Events::Rest.new(duration, channel)
+
+      else
+        raise "MTK::Rest() doesn't understand #{anything.class}"
+    end
+  end
+  module_function :Rest
+
+end

data/lib/mtk/events/timeline.rb

@@ -212,8 +212,12 @@ module MTK
       def to_s
         times = self.times
         last = times.last
-        width = sprintf("%d",last).length + 3 # nicely align the '=>' against the longest number
-        times.map{|t| sprintf("%#{width}.2f",t)+" => #{@timeline[t].join ', '}" }.join "\n"
+        if last
+          width = sprintf("%d",last).length + 3 # nicely align the '=>' against the longest number
+          times.map{|t| sprintf("%#{width}.2f",t)+" => #{@timeline[t].join ', '}" }.join "\n"
+        else
+          ''
+        end
       end
 
       def inspect

data/lib/mtk/io/jsound_input.rb

@@ -50,7 +50,7 @@ module MTK
       def to_timeline(options={})
         bpm = options.fetch :bmp, 120
         beats_per_second = bpm.to_f/60
-        timeline = Timeline.new
+        timeline = MTK::Events::Timeline.new
         note_ons = {}
         start = nil
 
@@ -59,7 +59,13 @@ module MTK
           time -= start
           time /= beats_per_second
 
-          case message.type
+          message_type = message.type
+          message_type = :note_off if message_type == :note_on and message.velocity == 0
+          # TODO: this will need to be made more robust when we support off velocities
+
+          next if message_type == :unknown # Ignore garbage messages
+
+          case message_type
             when :note_on
               note_ons[message.pitch] = [message,time]
 
@@ -71,7 +77,7 @@ module MTK
                 timeline.add time,note
               end
 
-            else timeline.add time, MTK::Events::Parameter.from_midi([message.type, message.channel], message.data1, message.data2)
+            else timeline.add time, MTK::Events::Parameter.from_midi([message_type, message.channel], message.data1, message.data2)
           end
         end
 

data/lib/mtk/io/midi_file.rb

@@ -41,6 +41,10 @@ module MTK
               case event
                 when ::MIDI::NoteOn
                   note_ons[event.note] = [time,event]
+                  # TODO: handle note ons with velocity 0 as a note off (use output from Logic Pro as a test case)
+                  # This isn't actually necessary right now as midilibs seqreader#note_on automatically
+                  # converts note ons with velocity 0 to note offs. In the future, for full off velocity support,
+                  # I'll need to monkey patch midilib and update the code here
 
                 when ::MIDI::NoteOff
                   on_time,on_event = note_ons.delete(event.note)
@@ -99,7 +103,11 @@ module MTK
                 pitch, velocity = event.midi_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)
+                # TODO: use note_off events when supporting off velocities
+                # add_event track, time+duration => note_off(channel, pitch, velocity)
+                # NOTE: cannot test the following line of code properly right now, because midilib automatically converts
+                # note ons with velocity 0 to note offs when reading files. See comments in #to_timelines in this file
+                add_event track, time+duration => note_on(channel, pitch, 0) # we use note ons with velocity 0 to indicate no off velocity
 
               when :control
                 add_event track, time => cc(channel, event.number, event.midi_value)
@@ -182,8 +190,10 @@ module MTK
 
       def add_track sequence, opts={}
         track = ::MIDI::Track.new(sequence)
-        track.name = opts.fetch :name, ''
+        track_name = opts[:name]
+        track.name = track_name if track_name
         sequence.tracks << track
+        sequence.format = if sequence.tracks.length > 1 then 1 else 0 end
         track
       end
 
@@ -207,3 +217,29 @@ module MTK
 
 end
 
+
+####################################################################################
+# MONKEY PATCHING to prevent blank instrument name meta events from being generated
+# This can be removed if my pull request https://github.com/jimm/midilib/pull/5
+# is merged into midilib and a new gem is released with these changes.
+
+# @private
+module MIDI
+  module IO
+    class SeqWriter
+      alias original_write_instrument write_instrument
+      def write_instrument(instrument)
+        original_write_instrument(instrument) unless instrument.nil?
+      end
+
+      # Also monkey patching write_header to support alternate MIDI file formats
+      def write_header
+        @io.print 'MThd'
+        write32(6)
+        write16(@seq.format || 1)
+        write16(@seq.tracks.length)
+        write16(@seq.ppqn)
+      end
+    end
+  end
+end

data/lib/mtk/io/midi_input.rb

@@ -80,7 +80,7 @@ module MTK
       end
 
       def to_timeline
-        Timeline.new
+        MTK::Events::Timeline.new
       end
 
     end

data/lib/mtk/io/midi_output.rb

@@ -105,8 +105,12 @@ module MTK
                 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) }
+                # Set a lower priority (via level:1) for note-ons, so legato notes at the same pitch don't
+                # prematurely chop off the next note, by ensuring all note-offs at the same timepoint occur first.
+                @scheduler.at(time, level: 1) { note_on(pitch,velocity,channel) }
+                @scheduler.at(time + duration) { note_on(pitch,0,channel) }
+                # TODO: use a proper note off message whenever we support off velocities
+                #@scheduler.at(time + duration) { note_off(pitch,velocity,channel) }
 
               when :control
                 @scheduler.at(time) { control(event.number, event.midi_value, channel) }
@@ -127,7 +131,10 @@ module MTK
           end
         end
 
-        end_time = timeline.times.last + trailing_buffer
+        end_time = timeline.times.last
+        final_events = timeline[end_time]
+        max_length = final_events.inject(0) {|max,event| len = event.length; max > len ? max : len } || 0
+        end_time += max_length + trailing_buffer
         @scheduler.at(end_time) { @scheduler.stop }
 
         thread = @scheduler.run
@@ -192,4 +199,88 @@ unless $__RUNNING_RSPEC_TESTS__ # I can't get this working on Travis-CI, problem
   else
     require 'mtk/io/unimidi_output'
   end
-end
+end
+
+
+
+####################################################################################
+# MONKEY PATCHING gamelan to ensure note-offs come before note-ons
+# when they occur at the same scheduler time.
+# This patch applies https://github.com/jvoorhis/gamelan/commit/20d93f4e5d86517bd5c6f9212a0dcdbf371d1ea1
+# to provide the priority/level feature for the scheduler (see @scheduler.at() calls for notes above).
+# This patch should not be necessary when gamelan gem > 0.3 is released
+
+# @private
+module Gamelan
+
+  DEFAULT_PRIORITY = 0
+  NOTEON_PRIORITY  = 0
+  CC_PRIORITY      = -1
+  PC_PRIORITY      = -2
+  NOTEOFF_PRIORITY = -3
+
+  class Priority < Struct.new(:time, :level)
+    include Comparable
+    def <=>(prio)
+      self.to_a <=> prio.to_a
+    end
+  end
+
+  if defined?(JRUBY_VERSION)
+
+    class Queue
+      def initialize(scheduler)
+        @scheduler = scheduler
+        @queue     = PriorityQueue.new(10000) { |a,b|
+          a.priority <=> b.priority
+        }
+      end
+
+      def ready?
+        if top = @queue.peek
+          top.delay < @scheduler.phase
+        else
+          false
+        end
+      end
+    end
+
+  else
+
+    class Queue
+      def push(task)
+        @queue.push(task, task.priority)
+      end
+      alias << push
+
+      def ready?
+        if top = @queue.min
+          top[1].time < @scheduler.phase
+        else
+          false
+        end
+      end
+    end
+
+  end
+
+  class Scheduler < Timer
+    def at(delay, options = {}, &task)
+      options = { :delay => delay, :scheduler => self }.merge(options)
+      @queue << Task.new(options, &task)
+    end
+  end
+
+  class Task
+    attr_reader :level, :priority
+
+    def initialize(options, &block)
+      @scheduler = options[:scheduler]
+      @delay     = options[:delay].to_f
+      @level     = options[:level] || DEFAULT_PRIORITY
+      @priority  = Priority.new(@delay, @level)
+      @proc      = block
+      @args      = options[:args] || []
+    end
+  end
+end

data/lib/mtk/io/unimidi_input.rb

@@ -59,7 +59,7 @@ module MTK
 
         bpm = options.fetch :bmp, 120
         beats_per_second = bpm.to_f/60
-        timeline = Timeline.new
+        timeline = MTK::Events::Timeline.new
         note_ons = {}
         start = nil
 
@@ -69,9 +69,13 @@ module MTK
           time /= beats_per_second
 
           if message.is_a? MTK::Events::Event
-            timeline.add time,message
+            timeline.add time,message unless message.type == :unknown
           else
-            case message.type
+            message_type = message.type
+            message_type = :note_off if message_type == :note_on and message.velocity == 0
+            # TODO: this will need to be made more robust when we support off velocities
+
+            case message_type
             when :note_on
               pitch = message.pitch
               note_ons[pitch] = [message,time]

data/lib/mtk/lang/durations.rb

@@ -5,51 +5,56 @@ module MTK
 
     # 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 in order to support the lower case names,
+    # it was necessary to define them as "pseudo constant" methods.
+    # Like constants, these methods are available either through the module (MTK::Lang::Durations::q) or
+    # via mixin (include MTK::Lang::Durations; q). They are listed under the "Instance Attribute Summary" of this page.
     #
-    # 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.
+    # These values assume the quarter note is one beat, so you may find they work best with 4/4 and other */4 time signatures
+    # (although it's certainly possible to use them with less common time signatures like 5/8).
     #
     # @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
+    # @see Core::Duration
+    # @see Events::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+
-
+      # @private
+      # @!macro [attach] define_duration
+      #   $3: $4 beat(s)
+      #   @!attribute [r]
+      #   @return [MTK::Core::Duration] duration of $4 beat(s)
+      def self.define_duration name, value, description, beats
+        define_constant name, value
+      end
+      
+      
       # whole note
-      # @macro [attach] durations.define_constant
+      # @macro [attach] durations.define_duration
       #   @attribute [r]
-      #   @return [$2] number of beats for $1
-      define_constant 'w', MTK::Core::Duration[4]
+      #   @return [$2] duration for $1
+      define_duration 'w', MTK::Core::Duration[4], 'whole note', 4
+
+      define_duration 'h', MTK::Core::Duration[2], 'half note', 2
 
-      # half note
-      define_constant 'h', MTK::Core::Duration[2]
+      define_duration 'q', MTK::Core::Duration[1], 'quarter note', 1
 
-      # quarter note
-      define_constant 'q', MTK::Core::Duration[1]
+      define_duration 'e', MTK::Core::Duration[Rational(1,2)], 'eighth note', '1/2'
 
-      # eight note
-      define_constant 'i', MTK::Core::Duration[Rational(1,2)]
+      define_duration 's', MTK::Core::Duration[Rational(1,4)], 'sixteenth note', '1/4'
 
-      # sixteenth note
-      define_constant 's', MTK::Core::Duration[Rational(1,4)]
+      define_duration 'r', MTK::Core::Duration[Rational(1,8)], 'thirty-second note', '1/8'
 
-      # thirty-second note
-      define_constant 'r', MTK::Core::Duration[Rational(1,8)]
+      define_duration 'x', MTK::Core::Duration[Rational(1,16)], 'sixty-fourth note', '1/16'
 
-      # 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
+      # All "psuedo constants" defined in this module
+      DURATIONS = [w, h, q, e, s, r, x].freeze
 
       # The names of all "psuedo constants" defined in this module
+      # @see MTK::Core::Duration::NAMES
       DURATION_NAMES = MTK::Core::Duration::NAMES
 
     end