midilib 1.0.0 → 1.1.1

data/lib/midilib/event.rb

@@ -23,6 +23,10 @@ class Event
     # decimal # (true). Delta times are always printed as decimal.
     attr_accessor :print_decimal_numbers
 
+    # Determines if to_s outputs MIDI channel numbers from 1-16 instead
+    # of the default 0-15.
+    attr_accessor :print_channel_numbers_from_one
+
     def initialize(status = 0, delta_time = 0)
 	@status = status
 	@delta_time = delta_time
@@ -33,6 +37,9 @@ class Event
 	@is_meta = false
 	@is_system = false
 	@is_realtime = false
+        @is_timesig = false
+        @is_keysig = false        
+	@is_program_change = false
 	@time_from_start = 0	# maintained by tracks
     end
     protected :initialize
@@ -74,13 +81,27 @@ class Event
     def system?
 	return @is_system
     end
+    
+    # Returns +true+ if this is a time signature event.
+    def timesig?
+       return @is_timesig
+    end
+    
+    # Returns +true+ if this is a key signature event.
+    def keysig?
+        return @is_keysig
+    end
 
     # Returns +true+ if this is a realtime status byte.
-
     def realtime?
 	return @is_realtime
     end
 
+    # Returns +true+ if this is a program change.
+    def program_change?
+	return @is_program_change        
+    end
+
     # Quantize this event's time_from_start by moving it to the nearest
     # multiple of +boundary+. See MIDI::Track#quantize. *Note*: does not
     # modify the event's delta_time, though MIDI::Track#quantize calls
@@ -106,6 +127,13 @@ class Event
 	return @print_decimal_numbers ? val.to_s : ('%02x' % val)
     end
 
+    # Returns +val+ as a decimal or hex string, depending upon the value of
+    # @print_decimal_numbers.
+    def channel_to_s(val)
+	val += 1 if @print_channel_numbers_from_one
+	return number_to_s(val)
+    end
+
     def to_s
 	"#{@delta_time}: "
     end
@@ -125,7 +153,7 @@ class ChannelEvent < Event
     protected :initialize
 
     def to_s
-	return super << "ch #{number_to_s(@channel)} "
+	return super << "ch #{channel_to_s(@channel)} "
     end
 
 end
@@ -203,7 +231,7 @@ class PolyPressure < NoteEvent
     end
     def to_s
 	return super <<
-	    "poly press #{number_to_s(@channel)} #{note_to_s} #{number_to_s(@velocity)}"
+	    "poly press #{channel_to_s(@channel)} #{note_to_s} #{number_to_s(@velocity)}"
     end
 end
 
@@ -236,6 +264,7 @@ class ProgramChange < ChannelEvent
     def initialize(channel = 0, program = 0, delta_time = 0)
 	super(PROGRAM_CHANGE, channel, delta_time)
 	@program = program
+	@is_program_change = true
     end
 
     def data_as_bytes
@@ -526,7 +555,9 @@ class Tempo < MetaEvent
 
     # Translates microseconds per quarter note (beat) to beats per minute.
     def Tempo.mpq_to_bpm(mpq)
-	return MICROSECS_PER_MINUTE / mpq
+        # Nov 17 2007: Fixed integer rounding error issue:
+        # 110 bpm (as 545455 msecs) becomes 109.999 (which became 109 bpm)
+	return Integer(MICROSECS_PER_MINUTE.to_f / mpq + 0.49)
     end
 
     def initialize(msecs_per_qnote, delta_time = 0)
@@ -556,4 +587,101 @@ class Tempo < MetaEvent
 	"tempo #{@data} msecs per qnote (#{Tempo.mpq_to_bpm(@data)} bpm)"
     end
 end
+
+# Container for time signature events
+class TimeSig < MetaEvent
+  
+    # Constructor
+    def initialize(numer, denom, clocks, qnotes, delta_time = 0)
+       super(META_TIME_SIG, [numer, denom, clocks, qnotes], delta_time)
+       @is_timesig = true
+    end
+    
+    # Returns the complete event as stored in the sequence
+    def data_as_bytes
+        data = ''
+	data << @status
+	data << @meta_type
+	data << 4
+        data << @data[0]
+        data << @data[1]
+        data << @data[2]
+        data << @data[3]
+    end
+
+    # Calculates the duration (in ticks) for a full measure 
+    def measure_duration(ppqn)       
+       (4 * ppqn * @data[0]) / (2**@data[1])
+    end
+    
+    # Returns the numerator (the top digit) for the time signature
+    def numerator
+       @data[0] 
+    end
+    
+    # Returns the denominator of the time signature. Use it as a power of 2
+    # to get the displayed (lower-part) digit of the time signature.
+    def denominator
+       @data[1]
+    end
+    
+    # Returns the metronome tick duration for the time signature. On
+    # each quarter note, there's 24 ticks.
+    def metronome_ticks
+       @data[2]
+    end
+    
+    # Returns the time signature for the event as a string.
+    # Example: "time sig 3/4"
+    def to_s
+       "time sig #{@data[0]}/#{2**@data[1]}"
+    end
+end
+
+# Container for key signature events  
+class KeySig < MetaEvent
+    
+    # Constructor
+    def initialize(sharpflat, is_minor, delta_time = 0)
+       super(META_KEY_SIG, [sharpflat, is_minor], delta_time)   
+       @is_keysig = true
+    end
+    
+    # Returns the complete event as stored in the sequence
+    def data_as_bytes
+        data = ''
+	data << @status
+	data << @meta_type
+	data << 2
+        data << @data[0]
+        data << @data[1] ? 1 : 0
+    end
+    
+    # Returns true if it's a minor key, false if major key
+    def minor_key?
+       @data[1] 
+    end
+    
+    # Returns true if it's a major key, false if minor key
+    def major_key?
+       !@data[1]
+    end
+    
+    # Returns the number of sharps/flats in the key sig. Negative for flats.
+    def sharpflat
+       @data[0] > 7 ? @data[0] - 256 : @data[0]
+    end
+    
+    # Returns the key signature as a text string.
+    # Example: "key sig A flat major"
+    def to_s
+        majorkeys = ['C flat', 'G flat', 'D flat', 'A flat', 'E flat', 'B flat', 'F', 
+                     'C', 'G', 'D', 'A', 'E', 'B', 'F#', 'C#']
+        minorkeys = ['a flat', 'e flat', 'b flat', 'f', 'c', 'g', 'd', 
+                      'a', 'e', 'b', 'f#', 'c#', 'g#', 'd#', 'a#']
+        minor_key? ? "key sig #{minorkeys[sharpflat + 7]} minor" :
+                 "key sig #{majorkeys[sharpflat + 7]} major"
+    end
+end
+
 end

data/lib/midilib/info.rb

@@ -1,8 +1,8 @@
 module MIDI
 
     VERSION_MAJOR = 1
-    VERSION_MINOR = 0
-    VERSION_TWEAK = 0
+    VERSION_MINOR = 1
+    VERSION_TWEAK = 1
     Version = "#{VERSION_MAJOR}.#{VERSION_MINOR}.#{VERSION_TWEAK}"
     Copyright = 'Copyright (c) 2003-2007 by Jim Menard <jimm@io.com>'
 

data/lib/midilib/io/midifile.rb

@@ -54,10 +54,11 @@ class MIDIFile
     end
 
     # This default getc implementation tries to read a single character
-    # from io.
+    # from io and returns it as an integer.
     def getc
 	@bytes_to_be_read -= 1
-	return @io.getc()
+	c = @io.getc()
+	c.respond_to?(:bytes) ? c.bytes.first : c
     end
 
     # The default error handler.

data/lib/midilib/io/seqreader.rb

@@ -145,9 +145,11 @@ class SeqReader < MIDIFile
 
     def text(type, msg)
 	case type
-	when META_SEQ_NAME
-	    @track.events << MetaEvent.new(META_SEQ_NAME, msg, 0)
-	when META_INSTRUMENT
+        when META_TEXT, META_LYRIC, META_CUE
+            @track.events << MetaEvent.new(type, msg, @curr_ticks)
+	when META_SEQ_NAME, META_COPYRIGHT
+	    @track.events << MetaEvent.new(type, msg, 0)
+	when META_INSTRUMENT         
 	    @track.instrument = msg
 	when META_MARKER
 	    @track.events << Marker.new(msg, @curr_ticks)
@@ -168,6 +170,7 @@ class SeqReader < MIDIFile
 
     def time_signature(numer, denom, clocks, qnotes)
 	@seq.time_signature(numer, denom, clocks, qnotes)
+        @track.events << TimeSig.new(numer, denom, clocks, qnotes, @curr_ticks)
     end
 
 # --
@@ -179,10 +182,11 @@ class SeqReader < MIDIFile
 	@track.events << Tempo.new(microsecs, @curr_ticks)
     end
 
-# --
-#      def key_signature(sharpflat, is_minor)
-#      end
+    def key_signature(sharpflat, is_minor)
+      @track.events << KeySig.new(sharpflat, is_minor, @curr_ticks)
+    end
 
+# --
 #      def arbitrary(msg)
 #      end
 # ++

data/lib/midilib/measure.rb

@@ -0,0 +1,80 @@
+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)
+  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)
+      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

data/lib/midilib/sequence.rb

@@ -1,5 +1,6 @@
 require 'midilib/io/seqreader'
 require 'midilib/io/seqwriter'
+require 'midilib/measure.rb'
 
 module MIDI
 
@@ -27,7 +28,12 @@ class Sequence
       '64th' => 0.0625
     }
 
-    attr_accessor :tracks, :ppqn, :format
+    # Array with all tracks for the sequence
+    attr_accessor :tracks
+    # 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 :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,7 +49,7 @@ class Sequence
 	# Time signature
 	@numer = 4		# Numer + denom = 4/4 time default
 	@denom = 2
-	@clocks = @ppqn
+	@clocks = 24    # Bug fix  Nov 11, 2007 - this is not the same as ppqn!
 	@qnotes = 8
 
 	@reader_class = IO::SeqReader
@@ -124,7 +130,6 @@ class Sequence
 
     # Reads a MIDI stream.
     def read(io, proc = nil)	# :yields: track, num_tracks, index
-	@tracks = Array.new()
 	reader = @reader_class.new(self, block_given?() ? Proc.new() : proc)
 	reader.read_from(io)
     end
@@ -140,5 +145,47 @@ class Sequence
 	@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.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
+    end
+    
 end
 end