midilib 2.0.2 → 3.0.1

data/lib/midilib/sequence.rb

@@ -1,12 +1,10 @@
-require 'midilib/io/seqreader'
-require 'midilib/io/seqwriter'
-require 'midilib/measure.rb'
+require_relative 'io/seqreader'
+require_relative 'io/seqwriter'
+require_relative 'measure'
 
 module MIDI
-
-# A MIDI::Sequence contains MIDI::Track objects.
-class Sequence
-
+  # A MIDI::Sequence contains MIDI::Track objects.
+  class Sequence
     include Enumerable
 
     UNNAMED = 'Unnamed Sequence'
@@ -33,7 +31,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,43 +41,49 @@ class Sequence
     attr_accessor :writer_class
 
     def initialize
-	@tracks = Array.new()
-	@ppqn = 480
+      @tracks = []
+      @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.is_a?(MIDI::Tempo) }
+      event ? Tempo.mpq_to_bpm(event.tempo) : DEFAULT_TEMPO
+    end
+    alias bpm beats_per_minute
+    alias tempo beats_per_minute
+
+    # Pulses (also called ticks) are the units of delta times and event
+    # time_from_start values. This method converts a number of pulses to a
+    # float value that is a time in seconds.
+    def pulses_to_seconds(pulses)
+      (pulses.to_f / @ppqn.to_f / beats_per_minute) * 60.0
     end
-    alias_method :bpm, :beats_per_minute
-    alias_method :tempo, :beats_per_minute
 
     # Given a note length name like "whole", "dotted quarter", or "8th
     # triplet", return the length of that note in quarter notes as a delta
     # time.
     def note_to_delta(name)
-      return length_to_delta(note_to_length(name))
+      length_to_delta(note_to_length(name))
     end
 
     # Given a note length name like "whole", "dotted quarter", or "8th
@@ -94,98 +98,107 @@ class Sequence
     def note_to_length(name)
       name.strip!
       name =~ /^(dotted)?(.*?)(triplet)?$/
-      dotted, note_name, triplet = $1, $2, $3
+      dotted = Regexp.last_match(1)
+      note_name = Regexp.last_match(2)
+      triplet = Regexp.last_match(3)
       note_name.strip!
       mult = 1.0
       mult = 1.5 if dotted
       mult /= 3.0 if triplet
       len = NOTE_TO_LENGTH[note_name]
       raise "Sequence.note_to_length: \"#{note_name}\" not understood in \"#{name}\"" unless len
-      return len * mult
+
+      len * mult
     end
 
     # Translates +length+ (a multiple of a quarter note) into a delta time.
     # For example, 1 is a quarter note, 1.0/32.0 is a 32nd note, 1.5 is a
     # dotted quarter, etc. Be aware when using division; 1/32 is zero due to
     # integer mathematics and rounding. Use floating-point numbers like 1.0
-    # and 32.0. This method always returns an integer.
+    # and 32.0. This method always returns an integer by calling `.round` on
+    # the floating-point result.
     #
     # See also note_to_delta and note_to_length.
     def length_to_delta(length)
-      return (@ppqn * length).to_i
+      (@ppqn * length).round
     end
 
     # 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?
+
+      @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)
+    def read(io, &block) # :yields: track, num_tracks, index
+      reader = @reader_class.new(self, &block)
+      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)
+    # Writes to a MIDI stream. +midi_format+ defaults to 1.
+    def write(io, midi_format = 1, &block) # :yields: track, num_tracks, index
+      writer = @writer_class.new(self, midi_format, &block)
+      writer.write_to(io)
     end
 
     # Iterates over the tracks.
-    def each			# :yields: track
-	@tracks.each { | track | yield track }
+    def each(&block) # :yields: track
+      @tracks.each(&block)
     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.is_a?(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 = 4
+      olddenom = 2
+      oldbeats = 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 = te.numerator
+        olddenom = te.denominator
+        oldbeats = te.metronome_ticks
+        measure_length = te.measure_duration(@ppqn)
+      end
+      measures
     end
-    
-end
+  end
 end

data/lib/midilib/track.rb

@@ -1,60 +1,17 @@
-require 'midilib/event'
+require_relative 'event'
+require_relative 'mergesort'
 
 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)
-    end
-  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
-      end
-    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.
-
-class Track
-
+  # 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
     include Enumerable
 
     UNNAMED = 'Unnamed'
@@ -63,62 +20,59 @@ class Track
     attr_reader :sequence
 
     def initialize(sequence)
-	@sequence = sequence
-	@events = Array.new()
+      @sequence = sequence
+      @events = []
 
-	# 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
+      @instrument = nil
     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.is_a?(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.is_a?(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)
+      list
     end
 
     # Quantize every event. length_or_note is either a length (1 = quarter,
@@ -128,48 +82,48 @@ 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
-	}
+    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 do |e|
+        t += e.delta_time
+        e.time_from_start = t
+      end
     end
 
     # The opposite of recalc_times: recalculates delta_time for each event
     # from each event's time_from_start. This is useful, for example, when
     # 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
-	}
+    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] = mergesort(list[starting_at..-1]) 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 }
+    def each(&block) # :yields: event
+      @events.each(&block)
     end
 
     # Sort events by their time_from_start. After sorting,
@@ -179,7 +133,6 @@ class Track
     # Note: this method is redundant, since recalc_delta_from_times sorts
     # 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
-
+    alias sort recalc_delta_from_times
+  end
 end

data/lib/midilib/utils.rb

@@ -1,18 +1,16 @@
 module MIDI
-
-# Utility methods.
-class Utils
-
+  # Utility methods.
+  class Utils
     # MIDI note names. NOTE_NAMES[0] is 'C', NOTE_NAMES[1] is 'C#', etc.
     NOTE_NAMES = [
-	'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'
+      'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'
     ]
 
     # Given a MIDI note number, return the name and octave as a string.
-    def Utils.note_to_s(num)
-	note = num % 12
-	octave = num / 12
-	return "#{NOTE_NAMES[note]}#{octave - 1}"
+    def self.note_to_s(num)
+      note = num % 12
+      octave = num / 12
+      "#{NOTE_NAMES[note]}#{octave - 1}"
     end
 
     # Given an integer, returns it as a variable length array of bytes (the
@@ -21,16 +19,15 @@ class Utils
     # The converse operation--converting a var len into a number--requires
     # input from a stream of bytes. Therefore we don't supply it here. That is
     # a part of the MIDIFile class.
-    def Utils.as_var_len(val)
-	buffer = []
-	buffer << (val & 0x7f)
-	val = (val >> 7)
-	while val > 0
-	    buffer << (0x80 + (val & 0x7f))
-	    val = (val >> 7)
-	end
-	return buffer.reverse!
+    def self.as_var_len(val)
+      buffer = []
+      buffer << (val & 0x7f)
+      val = (val >> 7)
+      while val > 0
+        buffer << (0x80 + (val & 0x7f))
+        val = (val >> 7)
+      end
+      buffer.reverse!
     end
-
-end
+  end
 end

data/lib/midilib.rb

@@ -5,11 +5,11 @@
 #
 # See the README.rdoc file or http://midilib.rubyforge.org for details.
 
-require 'midilib/info'
-require 'midilib/sequence'
-require 'midilib/track'
-require 'midilib/io/seqreader'
-require 'midilib/io/seqwriter'
+require_relative 'midilib/info'
+require_relative 'midilib/sequence'
+require_relative 'midilib/track'
+require_relative 'midilib/io/seqreader'
+require_relative 'midilib/io/seqwriter'
 
 # --
 # consts.rb, utils.rb, and event.rb are included by these files.