midilib 2.0.4 → 2.0.5

data/lib/midilib/measure.rb

@@ -2,79 +2,79 @@ require 'midilib/consts'
 
 module MIDI
 
-# The Measure class contains information about a measure from the sequence.
-# The measure data is based on the time signature information from the sequence
-# and is not stored in the sequence itself
-class Measure 
-  # The numerator (top digit) for the measure's time signature
-  attr_reader :numerator
-  # The denominator for the measure's time signature
-  attr_reader :denominator
-  # Start clock tick for the measure
-  attr_reader :start
-  # End clock tick for the measure (inclusive)
-  attr_reader :end
-  # The measure number (1-based)
-  attr_reader :measure_number
-  # The metronome tick for the measure
-  attr_reader :metronome_ticks
-  
-  # Constructor
-  def initialize(meas_no, start_time, duration, numer, denom, met_ticks)
-     @measure_number = meas_no
-     @start = start_time
-     @end = start_time + duration - 1
-     @numerator = numer     
-     @denominator = denom
-     @metronome_ticks = met_ticks
-  end
-  
-  # Returns a detailed string with information about the measure
-  def to_s
-    t = "#{@numerator}/#{2**@denominator}"
-    m = @metronome_ticks.to_f / 24
-    "measure #{@measure_number}  #{@start}-#{@end}  #{t}   #{m} qs metronome"
-  end
-  
-  # Returns +true+ if the event is in the measure
-  def contains_event?(e)
-     (e.time_from_start >= @start) && (e.time_from_start <= @end)
+  # The Measure class contains information about a measure from the sequence.
+  # The measure data is based on the time signature information from the sequence
+  # and is not stored in the sequence itself
+  class Measure
+    # The numerator (top digit) for the measure's time signature
+    attr_reader :numerator
+    # The denominator for the measure's time signature
+    attr_reader :denominator
+    # Start clock tick for the measure
+    attr_reader :start
+    # End clock tick for the measure (inclusive)
+    attr_reader :end
+    # The measure number (1-based)
+    attr_reader :measure_number
+    # The metronome tick for the measure
+    attr_reader :metronome_ticks
+
+    # Constructor
+    def initialize(meas_no, start_time, duration, numer, denom, met_ticks)
+      @measure_number = meas_no
+      @start = start_time
+      @end = start_time + duration - 1
+      @numerator = numer
+      @denominator = denom
+      @metronome_ticks = met_ticks
+    end
+
+    # Returns a detailed string with information about the measure
+    def to_s
+      t = "#{@numerator}/#{2**@denominator}"
+      m = @metronome_ticks.to_f / 24
+      "measure #{@measure_number}  #{@start}-#{@end}  #{t}   #{m} qs metronome"
+    end
+
+    # Returns +true+ if the event is in the measure
+    def contains_event?(e)
+      (e.time_from_start >= @start) && (e.time_from_start <= @end)
+    end
   end
-end
 
-# A specialized container for MIDI::Measure objects, which can be use to map
-# event times to measure numbers. Please note that this object has to be remade
-# when events are deleted/added in the sequence.
-class Measures < Array  
-   # The highest event time in the sequence (at the time when the
-   # object was created)
-   attr_reader :max_time
-   
-   # The ppqd from the sequence
-   attr_reader :ppqd
-  
-   # Constructor
-   def initialize(max_time, ppqd)
+  # A specialized container for MIDI::Measure objects, which can be use to map
+  # event times to measure numbers. Please note that this object has to be remade
+  # when events are deleted/added in the sequence.
+  class Measures < Array
+    # The highest event time in the sequence (at the time when the
+    # object was created)
+    attr_reader :max_time
+
+    # The ppqd from the sequence
+    attr_reader :ppqd
+
+    # Constructor
+    def initialize(max_time, ppqd)
       super(0)
       @max_time = max_time
       @ppqd = ppqd
-   end
-   
-   # Returns the MIDI::Measure object where the event is located.
-   # Returns +nil+ if the event isn't found in the container (should
-   # never happen if the MIDI::Measures object is up to date).
-   def measure_for_event(e)
-     detect { | m | m.contains_event?(e) }
-   end
-   
-   # Returns the event's time as a formatted MBT string (Measure:Beat:Ticks)
-   # as found in MIDI sequencers.
-   def to_mbt(e)      
-      m = measure_for_event(e)      
-      b = (e.time_from_start.to_f - m.start.to_f) / @ppqd      
-      b *= 24 / m.metronome_ticks      
-      sprintf("%d:%02d:%03d", m.measure_number, b.to_i + 1, (b - b.to_i) * @ppqd)      
-   end
-end
+    end
+
+    # Returns the MIDI::Measure object where the event is located.
+    # Returns +nil+ if the event isn't found in the container (should
+    # never happen if the MIDI::Measures object is up to date).
+    def measure_for_event(e)
+      detect { |m| m.contains_event?(e) }
+    end
+
+    # Returns the event's time as a formatted MBT string (Measure:Beat:Ticks)
+    # as found in MIDI sequencers.
+    def to_mbt(e)
+      m = measure_for_event(e)
+      b = (e.time_from_start.to_f - m.start.to_f) / @ppqd
+      b *= 24 / m.metronome_ticks
+      sprintf("%d:%02d:%03d", m.measure_number, b.to_i + 1, (b - b.to_i) * @ppqd)
+    end
+  end
 
 end

data/lib/midilib/sequence.rb

@@ -4,8 +4,8 @@ require 'midilib/measure.rb'
 
 module MIDI
 
-# A MIDI::Sequence contains MIDI::Track objects.
-class Sequence
+  # A MIDI::Sequence contains MIDI::Track objects.
+  class Sequence
 
     include Enumerable
 
@@ -33,7 +33,7 @@ class Sequence
     # Pulses (i.e. clocks) Per Quarter Note resolution for the sequence
     attr_accessor :ppqn
     # The MIDI file format (0, 1, or 2)
-    attr_accessor :format   
+    attr_accessor :format
     attr_accessor :numer, :denom, :clocks, :qnotes
     # The class to use for reading MIDI from a stream. The default is
     # MIDI::IO::SeqReader. You can change this at any time.
@@ -43,34 +43,32 @@ class Sequence
     attr_accessor :writer_class
 
     def initialize
-	@tracks = Array.new()
-	@ppqn = 480
+      @tracks = Array.new()
+      @ppqn = 480
 
-	# Time signature
-	@numer = 4		# Numer + denom = 4/4 time default
-	@denom = 2
-	@clocks = 24    # Bug fix  Nov 11, 2007 - this is not the same as ppqn!
-	@qnotes = 8
+      # Time signature
+      @numer = 4		# Numer + denom = 4/4 time default
+      @denom = 2
+      @clocks = 24    # Bug fix  Nov 11, 2007 - this is not the same as ppqn!
+      @qnotes = 8
 
-	@reader_class = IO::SeqReader
-	@writer_class = IO::SeqWriter
+      @reader_class = IO::SeqReader
+      @writer_class = IO::SeqWriter
     end
 
     # Sets the time signature.
     def time_signature(numer, denom, clocks, qnotes)
-	@numer = numer
-	@denom = denom
-	@clocks = clocks
-	@qnotes = qnotes
+      @numer = numer
+      @denom = denom
+      @clocks = clocks
+      @qnotes = qnotes
     end
 
     # Returns the song tempo in beats per minute.
     def beats_per_minute
-	return DEFAULT_TEMPO if @tracks.nil? || @tracks.empty?
-	event = @tracks.first.events.detect { | e |
-	    e.kind_of?(MIDI::Tempo)
-	}
-	return event ? (Tempo.mpq_to_bpm(event.tempo)) : DEFAULT_TEMPO
+      return DEFAULT_TEMPO if @tracks.nil? || @tracks.empty?
+      event = @tracks.first.events.detect { |e| e.kind_of?(MIDI::Tempo) }
+      return event ? (Tempo.mpq_to_bpm(event.tempo)) : DEFAULT_TEMPO
     end
     alias_method :bpm, :beats_per_minute
     alias_method :tempo, :beats_per_minute
@@ -125,74 +123,74 @@ class Sequence
     # Returns the name of the first track (track zero). If there are no
     # tracks, returns UNNAMED.
     def name
-	return UNNAMED if @tracks.empty?
-	return @tracks.first.name()
+      return UNNAMED if @tracks.empty?
+      return @tracks.first.name()
     end
 
     # Hands the name to the first track. Does nothing if there are no tracks.
     def name=(name)
-	return if @tracks.empty?
-	@tracks.first.name = name
+      return if @tracks.empty?
+      @tracks.first.name = name
     end
 
     # Reads a MIDI stream.
     def read(io, proc = nil)	# :yields: track, num_tracks, index
-	reader = @reader_class.new(self, block_given?() ? Proc.new() : proc)
-	reader.read_from(io)
+      reader = @reader_class.new(self, block_given?() ? Proc.new() : proc)
+      reader.read_from(io)
     end
 
     # Writes to a MIDI stream.
     def write(io, proc = nil)	# :yields: track, num_tracks, index
-	writer = @writer_class.new(self, block_given?() ? Proc.new() : proc)
-	writer.write_to(io)
+      writer = @writer_class.new(self, block_given?() ? Proc.new() : proc)
+      writer.write_to(io)
     end
 
     # Iterates over the tracks.
     def each			# :yields: track
-	@tracks.each { | track | yield track }
+      @tracks.each { |track| yield track }
     end
 
     # Returns a Measures object, which is an array container for all measures
     # in the sequence
-    def get_measures      
-       # Collect time sig events and scan for last event time
-       time_sigs = []
-       max_pos = 0
-       @tracks.each  { |t|
-         t.each { |e| 
-           time_sigs << e if e.kind_of?(MIDI::TimeSig)
-           max_pos = e.time_from_start if e.time_from_start > max_pos
-         }
-       }
-       time_sigs.sort { |x,y| x.time_from_start <=> y.time_from_start }      
-      
-       # Add a "fake" time sig event at the very last position of the sequence,
-       # just to make sure the whole sequence is calculated.
-       t = MIDI::TimeSig.new(4, 2, 24, 8, 0)
-       t.time_from_start = max_pos
-       time_sigs << t     
-     
-       # Default to 4/4
-       measure_length = @ppqn * 4
-       oldnumer, olddenom, oldbeats = 4, 2, 24
-           
-       measures = MIDI::Measures.new(max_pos, @ppqn)      
-       curr_pos = 0
-       curr_meas_no = 1
-       time_sigs.each { |te|         
-          meas_count = (te.time_from_start - curr_pos) / measure_length
-          meas_count += 1 if (te.time_from_start - curr_pos) % measure_length > 0
-          1.upto(meas_count) { |i|                  
-              measures << MIDI::Measure.new(curr_meas_no, 
-                          curr_pos, measure_length, oldnumer, olddenom, oldbeats) 
-              curr_meas_no += 1
-              curr_pos += measure_length
-          }
-          oldnumer, olddenom, oldbeats = te.numerator, te.denominator, te.metronome_ticks
-          measure_length = te.measure_duration(@ppqn)        
-       }      
-       measures
+    def get_measures
+      # Collect time sig events and scan for last event time
+      time_sigs = []
+      max_pos = 0
+      @tracks.each  do |t|
+        t.each do |e|
+          time_sigs << e if e.kind_of?(MIDI::TimeSig)
+          max_pos = e.time_from_start if e.time_from_start > max_pos
+        end
+      end
+      time_sigs.sort { |x,y| x.time_from_start <=> y.time_from_start }
+
+      # Add a "fake" time sig event at the very last position of the sequence,
+      # just to make sure the whole sequence is calculated.
+      t = MIDI::TimeSig.new(4, 2, 24, 8, 0)
+      t.time_from_start = max_pos
+      time_sigs << t
+
+      # Default to 4/4
+      measure_length = @ppqn * 4
+      oldnumer, olddenom, oldbeats = 4, 2, 24
+
+      measures = MIDI::Measures.new(max_pos, @ppqn)
+      curr_pos = 0
+      curr_meas_no = 1
+      time_sigs.each do |te|
+        meas_count = (te.time_from_start - curr_pos) / measure_length
+        meas_count += 1 if (te.time_from_start - curr_pos) % measure_length > 0
+        1.upto(meas_count) do |i|
+          measures << MIDI::Measure.new(curr_meas_no, curr_pos, measure_length,
+                                        oldnumer, olddenom, oldbeats)
+          curr_meas_no += 1
+          curr_pos += measure_length
+        end
+        oldnumer, olddenom, oldbeats = te.numerator, te.denominator, te.metronome_ticks
+        measure_length = te.measure_duration(@ppqn)
+      end
+      measures
     end
-    
-end
+
+  end
 end

data/lib/midilib/track.rb

@@ -2,58 +2,56 @@ require 'midilib/event'
 
 module MIDI
 
-# This is taken from
-# http://github.com/adamjmurray/cosy/blob/master/lib/cosy/helper/midi_file_renderer_helper.rb
-# with permission from Adam Murray, who originally suggested this fix.
-# See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
-# First we need to add some API infrastructure:
-class MIDI::Array < ::Array
-  # This code borrowed from 'Moser' http://codesnippets.joyent.com/posts/show/1699
-  
-  # A stable sorting algorithm that maintains the relative order of equal elements
-  def mergesort(&cmp)
-    if cmp == nil
-      cmp = lambda { |a, b| a <=> b }
-    end
-    if size <= 1
-      self.dup
-    else
-      halves = split.map{ |half|
-        half.mergesort(&cmp)
-      }
-      merge(*halves, &cmp)
+  # This is taken from
+  # http://github.com/adamjmurray/cosy/blob/master/lib/cosy/helper/midi_file_renderer_helper.rb
+  # with permission from Adam Murray, who originally suggested this fix.
+  # See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
+  # First we need to add some API infrastructure:
+  class MIDI::Array < ::Array
+    # This code borrowed from 'Moser' http://codesnippets.joyent.com/posts/show/1699
+
+    # A stable sorting algorithm that maintains the relative order of equal elements
+    def mergesort(&cmp)
+      if cmp == nil
+        cmp = lambda { |a, b| a <=> b }
+      end
+      if size <= 1
+        self.dup
+      else
+        halves = split.map { |half| half.mergesort(&cmp) }
+        merge(*halves, &cmp)
+      end
     end
-  end
 
-  protected
-  def split
-    n = (length / 2).floor - 1
-    [self[0..n], self[n+1..-1]]
-  end
+    protected
+    def split
+      n = (length / 2).floor - 1
+      [self[0..n], self[n+1..-1]]
+    end
 
-  def merge(first, second, &predicate)
-    result = []
-    until first.empty? || second.empty?
-      if predicate.call(first.first, second.first) <= 0
-        result << first.shift
-      else
-        result << second.shift
+    def merge(first, second, &predicate)
+      result = []
+      until first.empty? || second.empty?
+        if predicate.call(first.first, second.first) <= 0
+          result << first.shift
+        else
+          result << second.shift
+        end
       end
+      result.concat(first).concat(second)
     end
-    result.concat(first).concat(second)
   end
-end
 
-# A Track is a list of events.
-#
-# When you modify the +events+ array, make sure to call recalc_times so
-# each Event gets its +time_from_start+ recalculated.
-#
-# A Track also holds a bitmask that specifies the channels used by the track.
-# This bitmask is set when the track is read from the MIDI file by an
-# IO::SeqReader but is _not_ kept up to date by any other methods.
+  # A Track is a list of events.
+  #
+  # When you modify the +events+ array, make sure to call recalc_times so
+  # each Event gets its +time_from_start+ recalculated.
+  #
+  # A Track also holds a bitmask that specifies the channels used by the track.
+  # This bitmask is set when the track is read from the MIDI file by an
+  # IO::SeqReader but is _not_ kept up to date by any other methods.
 
-class Track
+  class Track
 
     include Enumerable
 
@@ -63,62 +61,58 @@ class Track
     attr_reader :sequence
 
     def initialize(sequence)
-	@sequence = sequence
-	@events = Array.new()
+      @sequence = sequence
+      @events = Array.new()
 
-	# Bitmask of all channels used. Set when track is read in from
-	# a MIDI file.
-	@channels_used = 0
+      # Bitmask of all channels used. Set when track is read in from
+      # a MIDI file.
+      @channels_used = 0
     end
 
     # Return track name. If there is no name, return UNNAMED.
     def name
-	event = @events.detect { | e |
-	    e.kind_of?(MetaEvent) && e.meta_type == META_SEQ_NAME
-	}
-	return event ? event.data_as_str : UNNAMED
+      event = @events.detect { |e| e.kind_of?(MetaEvent) && e.meta_type == META_SEQ_NAME }
+      event ? event.data_as_str : UNNAMED
     end
 
     # Set track name. Replaces or creates a name meta-event.
     def name=(name)
-	event = @events.detect { | e |
-	    e.kind_of?(MetaEvent) && e.meta_type == META_SEQ_NAME
-	}
-	if event
-	    event.data = name
-	else
-	    event = MetaEvent.new(META_SEQ_NAME, name, 0)
-	    @events[0, 0] = event
-	end
+      event = @events.detect { |e| e.kind_of?(MetaEvent) && e.meta_type == META_SEQ_NAME }
+      if event
+        event.data = name
+      else
+        event = MetaEvent.new(META_SEQ_NAME, name, 0)
+        @events[0, 0] = event
+      end
     end
 
     def instrument
-	MetaEvent.bytes_as_str(@instrument)
+      MetaEvent.bytes_as_str(@instrument)
     end
 
     def instrument=(str_or_bytes)
-	@instrument = case str_or_bytes
-		      when String
-			    MetaEvent.str_as_bytes(str_or_bytes)
-		      else
-			    str_or_bytes
-		      end
+      @instrument = case str_or_bytes
+                    when String
+                      MetaEvent.str_as_bytes(str_or_bytes)
+                    else
+                      str_or_bytes
+                    end
     end
 
     # Merges an array of events into our event list. After merging, the
     # events' time_from_start values are correct so you don't need to worry
     # about calling recalc_times.
     def merge(event_list)
-	@events = merge_event_lists(@events, event_list)
+      @events = merge_event_lists(@events, event_list)
     end
 
     # Merges two event arrays together. Does not modify this track.
     def merge_event_lists(list1, list2)
-	recalc_times(0, list1)
-	recalc_times(0, list2)
-        list = list1 + list2
-	recalc_delta_from_times(0, list)
-	return list
+      recalc_times(0, list1)
+      recalc_times(0, list2)
+      list = list1 + list2
+      recalc_delta_from_times(0, list)
+      return list
     end
 
     # Quantize every event. length_or_note is either a length (1 = quarter,
@@ -128,24 +122,24 @@ class Track
     # Since each event's time_from_start is modified, we call
     # recalc_delta_from_times after each event quantizes itself.
     def quantize(length_or_note)
-	delta = case length_or_note
-		when String
-		    @sequence.note_to_delta(length_or_note)
-		else
-		    @sequence.length_to_delta(length_or_note.to_i)
-		end
-	@events.each { | event | event.quantize_to(delta) }
-	recalc_delta_from_times
+      delta = case length_or_note
+              when String
+                @sequence.note_to_delta(length_or_note)
+              else
+                @sequence.length_to_delta(length_or_note.to_i)
+              end
+      @events.each { |event| event.quantize_to(delta) }
+      recalc_delta_from_times
     end
 
     # Recalculate start times for all events in +list+ from starting_at to
     # end.
     def recalc_times(starting_at=0, list=@events)
-	t = (starting_at == 0) ? 0 : list[starting_at - 1].time_from_start
-	list[starting_at .. -1].each { | e |
-	    t += e.delta_time
-	    e.time_from_start = t
-	}
+      t = (starting_at == 0) ? 0 : list[starting_at - 1].time_from_start
+      list[starting_at .. -1].each do |e|
+        t += e.delta_time
+        e.time_from_start = t
+      end
     end
 
     # The opposite of recalc_times: recalculates delta_time for each event
@@ -153,23 +147,23 @@ class Track
     # merging two event lists. As a side-effect, elements from starting_at
     # are sorted by time_from_start.
     def recalc_delta_from_times(starting_at=0, list=@events)
-	prev_time_from_start = 0
-	# We need to sort the sublist. sublist.sort! does not do what we want.
-        # We call mergesort instead of Array.sort because sort is not stable
-        # (it can mix up the order of events that have the same start time).
-        # See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
-	list[starting_at .. -1] = MIDI::Array.new(list[starting_at .. -1]).mergesort { | e1, e2 |
-	    e1.time_from_start <=> e2.time_from_start
-	}
-	list[starting_at .. -1].each { | e |
-	    e.delta_time = e.time_from_start - prev_time_from_start
-	    prev_time_from_start = e.time_from_start
-	}
+      prev_time_from_start = 0
+      # We need to sort the sublist. sublist.sort! does not do what we want.
+      # We call mergesort instead of Array.sort because sort is not stable
+      # (it can mix up the order of events that have the same start time).
+      # See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
+      list[starting_at .. -1] = MIDI::Array.new(list[starting_at .. -1]).mergesort do |e1, e2|
+        e1.time_from_start <=> e2.time_from_start
+      end
+      list[starting_at .. -1].each do |e|
+        e.delta_time = e.time_from_start - prev_time_from_start
+        prev_time_from_start = e.time_from_start
+      end
     end
 
     # Iterate over events.
     def each			# :yields: event
-	@events.each { | event | yield event }
+      @events.each { |event| yield event }
     end
 
     # Sort events by their time_from_start. After sorting,
@@ -180,6 +174,6 @@ class Track
     # the events first. This method may go away in a future release, or at
     # least be aliased to recalc_delta_from_times.
     alias_method :sort, :recalc_delta_from_times
-end
+  end
 
 end