midilib 2.0.5 → 3.0.1

data/lib/midilib/io/seqreader.rb

@@ -1,11 +1,9 @@
-require 'midilib/io/midifile'
-require 'midilib/track'
-require 'midilib/event'
+require_relative 'midifile'
+require_relative '../track'
+require_relative '../event'
 
 module MIDI
-
   module IO
-
     # Reads MIDI files. As a subclass of MIDIFile, this class implements the
     # callback methods for each MIDI event and use them to build Track and
     # Event objects and give the tracks to a Sequence.
@@ -21,118 +19,119 @@ module MIDI
     # track when it is output.
 
     class SeqReader < MIDIFile
-
-      # The optional proc block is called once at the start of the file and
+      # The optional &block is called once at the start of the file and
       # again at the end of each track. There are three arguments to the
       # block: the track, the track number (1 through _n_), and the total
       # number of tracks.
-      def initialize(seq, proc = nil) # :yields: track, num_tracks, index
-	super()
-	@seq = seq
-	@track = nil
-	@chan_mask = 0
-	@update_block = block_given?() ? Proc.new() : proc
+      def initialize(seq, &block) # :yields: track, num_tracks, index
+        super()
+        @seq = seq
+        @track = nil
+        @chan_mask = 0
+        @update_block = block
       end
 
       def header(format, ntrks, division)
-	@seq.format = format
-	@seq.ppqn = division
+        @seq.format = format
+        @seq.ppqn = division
 
-	@ntrks = ntrks
-	@update_block.call(nil, @ntrks, 0) if @update_block
+        @ntrks = ntrks
+        @update_block.call(nil, @ntrks, 0) if @update_block
       end
 
-      def start_track()
-	@track = Track.new(@seq)
-	@seq.tracks << @track
+      def start_track
+        @track = Track.new(@seq)
+        @seq.tracks << @track
 
-	@pending = []
+        @pending = []
       end
 
-      def end_track()
-	# Turn off any pending note on messages
-	@pending.each { |on| make_note_off(on, 64) }
-	@pending = nil
+      def end_track
+        # Turn off any pending note on messages
+        @pending.each { |on| make_note_off(on, 64) }
+        @pending = nil
 
-	# Don't bother adding the META_TRACK_END event to the track.
-	# This way, we don't have to worry about making sure the
-	# last event is always a track end event.
+        # Don't bother adding the META_TRACK_END event to the track.
+        # This way, we don't have to worry about making sure the
+        # last event is always a track end event.
 
-	# Let the track calculate event times from start of track. This is
-	# in lieu of calling Track.add for each event.
-	@track.recalc_times()
+        # Let the track calculate event times from start of track. This is
+        # in lieu of calling Track.add for each event.
+        @track.recalc_times
 
-	# Store bitmask of all channels used into track
-	@track.channels_used = @chan_mask
+        # Store bitmask of all channels used into track
+        @track.channels_used = @chan_mask
 
-	# call update block
-	@update_block.call(@track, @ntrks, @seq.tracks.length) if @update_block
+        # call update block
+        @update_block.call(@track, @ntrks, @seq.tracks.length) if @update_block
       end
 
       def note_on(chan, note, vel)
-	if vel == 0
+        if vel == 0
           note_off(chan, note, 64)
           return
-	end
+        end
 
-	on = NoteOn.new(chan, note, vel, @curr_ticks)
-	@track.events << on
-	@pending << on
-	track_uses_channel(chan)
+        on = NoteOn.new(chan, note, vel, @curr_ticks)
+        @track.events << on
+        @pending << on
+        track_uses_channel(chan)
       end
 
       def note_off(chan, note, vel)
-	# Find note on, create note off, connect the two, and remove
-	# note on from pending list.
-	@pending.each_with_index do |on, i|
-          if on.note == note && on.channel == chan
-            make_note_off(on, vel)
-            @pending.delete_at(i)
-            return
-          end
-	end
-	$stderr.puts "note off with no earlier note on (ch #{chan}, note" +
-          " #{note}, vel #{vel})" if $DEBUG
+        # Find note on, create note off, connect the two, and remove
+        # note on from pending list.
+        @pending.each_with_index do |on, i|
+          next unless on.note == note && on.channel == chan
+
+          make_note_off(on, vel)
+          @pending.delete_at(i)
+          return
+        end
+        if $DEBUG
+          warn "note off with no earlier note on (ch #{chan}, note" +
+               " #{note}, vel #{vel})"
+        end
       end
 
       def make_note_off(on, vel)
-	off = NoteOff.new(on.channel, on.note, vel, @curr_ticks)
-	@track.events << off
-	on.off = off
-	off.on = on
+        off = NoteOff.new(on.channel, on.note, vel, @curr_ticks)
+        @track.events << off
+        on.off = off
+        off.on = on
       end
 
       def pressure(chan, note, press)
-	@track.events << PolyPressure.new(chan, note, press, @curr_ticks)
-	track_uses_channel(chan)
+        @track.events << PolyPressure.new(chan, note, press, @curr_ticks)
+        track_uses_channel(chan)
       end
 
       def controller(chan, control, value)
-	@track.events << Controller.new(chan, control, value, @curr_ticks)
-	track_uses_channel(chan)
+        @track.events << Controller.new(chan, control, value, @curr_ticks)
+        track_uses_channel(chan)
       end
 
       def pitch_bend(chan, lsb, msb)
-	@track.events << PitchBend.new(chan, (msb << 7) + lsb, @curr_ticks)
-	track_uses_channel(chan)
+        @track.events << PitchBend.new(chan, (msb << 7) + lsb, @curr_ticks)
+        track_uses_channel(chan)
       end
 
       def program(chan, program)
-	@track.events << ProgramChange.new(chan, program, @curr_ticks)
-	track_uses_channel(chan)
+        @track.events << ProgramChange.new(chan, program, @curr_ticks)
+        track_uses_channel(chan)
       end
 
       def chan_pressure(chan, press)
-	@track.events << ChannelPressure.new(chan, press, @curr_ticks)
-	track_uses_channel(chan)
+        @track.events << ChannelPressure.new(chan, press, @curr_ticks)
+        track_uses_channel(chan)
       end
 
       def sysex(msg)
-	@track.events << SystemExclusive.new(msg, @curr_ticks)
+        @track.events << SystemExclusive.new(msg, @curr_ticks)
       end
 
       def meta_misc(type, msg)
-	@track.events << MetaEvent.new(type, msg, @curr_ticks)
+        @track.events << MetaEvent.new(type, msg, @curr_ticks)
       end
 
       # --
@@ -144,18 +143,16 @@ module MIDI
       # ++
 
       def text(type, msg)
-	case type
-        when META_TEXT, META_LYRIC, META_CUE
+        case type
+        when META_TEXT, META_LYRIC, META_CUE, META_SEQ_NAME, META_COPYRIGHT
           @track.events << MetaEvent.new(type, msg, @curr_ticks)
-	when META_SEQ_NAME, META_COPYRIGHT
-          @track.events << MetaEvent.new(type, msg, 0)
-	when META_INSTRUMENT
+        when META_INSTRUMENT
           @track.instrument = msg
-	when META_MARKER
+        when META_MARKER
           @track.events << Marker.new(msg, @curr_ticks)
-	else
-          $stderr.puts "text = #{msg}, type = #{type}" if $DEBUG
-	end
+        else
+          warn "text = #{msg}, type = #{type}" if $DEBUG
+        end
       end
 
       # --
@@ -163,13 +160,13 @@ module MIDI
       # we don't have to worry about always making sure the last event is
       # always a track end event. We just have to make sure to write one when
       # the track is output back to a file.
-      #  	def eot()
-      #  	    @track.events << MetaEvent.new(META_TRACK_END, nil, @curr_ticks)
-      #  	end
+      #          def eot()
+      #              @track.events << MetaEvent.new(META_TRACK_END, nil, @curr_ticks)
+      #          end
       # ++
 
       def time_signature(numer, denom, clocks, qnotes)
-	@seq.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,7 +176,7 @@ module MIDI
       # ++
 
       def tempo(microsecs)
-	@track.events << Tempo.new(microsecs, @curr_ticks)
+        @track.events << Tempo.new(microsecs, @curr_ticks)
       end
 
       def key_signature(sharpflat, is_minor)
@@ -193,10 +190,8 @@ module MIDI
 
       # Return true if the current track uses the specified channel.
       def track_uses_channel(chan)
-	@chan_mask = @chan_mask | (1 << chan)
+        @chan_mask |= (1 << chan)
       end
-
     end
-
   end
 end

data/lib/midilib/io/seqwriter.rb

@@ -1,55 +1,61 @@
 # Writes MIDI files.
 
-require 'midilib/event'
-require 'midilib/utils'
+require_relative '../event'
+require_relative '../utils'
 
 module MIDI
-
   module IO
-
     class SeqWriter
-
-      def initialize(seq, proc = nil) # :yields: num_tracks, index
-	@seq = seq
-	@update_block = block_given?() ? Proc.new() : proc
+      def initialize(seq, midi_format = 1, &block) # :yields: num_tracks, index
+        @seq = seq
+        @midi_format = midi_format || 1
+        @update_block = block
       end
 
       # Writes a MIDI format 1 file.
       def write_to(io)
-	@io = io
-	@bytes_written = 0
-	write_header()
-	@update_block.call(nil, @seq.tracks.length, 0) if @update_block
-	@seq.tracks.each_with_index do |track, i|
+        if @midi_format == 0
+          # merge tracks before writing
+          merged_seq = Sequence.new
+          merged_track = Track.new(merged_seq)
+          merged_seq.tracks << merged_track
+          @seq.each do |track|
+            merged_track.merge(track.events)
+          end
+          @seq = merged_seq # replace
+        end
+
+        @io = io
+        @bytes_written = 0
+        write_header
+        @update_block.call(nil, @seq.tracks.length, 0) if @update_block
+        @seq.tracks.each_with_index do |track, i|
           write_track(track)
           @update_block.call(track, @seq.tracks.length, i) if @update_block
-	end
+        end
       end
 
       def write_header
-	@io.print 'MThd'
-	write32(6)
-	write16(1)		# Ignore sequence format; write as format 1
-	write16(@seq.tracks.length)
-	write16(@seq.ppqn)
+        @io.print 'MThd'
+        write32(6)
+        write16(@midi_format) # Ignore sequence format; write as format 1 or 0, default 1
+        write16(@seq.tracks.length)
+        write16(@seq.ppqn)
       end
 
       def write_track(track)
-	@io.print 'MTrk'
-	track_size_file_pos = @io.tell()
-	write32(0)		# Dummy byte count; overwritten later
-	@bytes_written = 0	# Reset after previous write
-
-	write_instrument(track.instrument)
-
-	prev_event = nil
-	prev_status = 0
-	track.events.each do |event|
-          if !event.kind_of?(Realtime)
-            write_var_len(event.delta_time)
-          end
+        @io.print 'MTrk'
+        track_size_file_pos = @io.tell
+        write32(0)                # Dummy byte count; overwritten later
+        @bytes_written = 0        # Reset after previous write
 
-          data = event.data_as_bytes()
+        write_instrument(track.instrument)
+
+        prev_status = 0
+        track.events.each do |event|
+          write_var_len(event.delta_time) unless event.is_a?(Realtime)
+
+          data = event.data_as_bytes
           status = data[0] # status byte plus channel number, if any
 
           # running status byte
@@ -57,96 +63,95 @@ module MIDI
 
           @bytes_written += write_bytes(data)
 
-          prev_event = event
           prev_status = status
-	end
-
-	# Write track end event.
-	event = MetaEvent.new(META_TRACK_END)
-	write_var_len(0)
-	@bytes_written += write_bytes(event.data_as_bytes())
-
-	# Go back to beginning of track data and write number of bytes,
-	# then come back here to end of file.
-	@io.seek(track_size_file_pos)
-	write32(@bytes_written)
-	@io.seek(0, ::IO::SEEK_END)
+        end
+
+        # Write track end event.
+        event = MetaEvent.new(META_TRACK_END)
+        write_var_len(0)
+        @bytes_written += write_bytes(event.data_as_bytes)
+
+        # Go back to beginning of track data and write number of bytes,
+        # then come back here to end of file.
+        @io.seek(track_size_file_pos)
+        write32(@bytes_written)
+        @io.seek(0, ::IO::SEEK_END)
       end
 
       # If we can use a running status byte, delete the status byte from
       # the given data. Return the status to remember for next time as the
       # running status byte for this event.
       def possibly_munge_due_to_running_status_byte(data, prev_status)
-	status = data[0]
-	return status if status >= 0xf0 || prev_status >= 0xf0
-
-	chan = (status & 0x0f)
-	return status if chan != (prev_status & 0x0f)
-
-	status = (status & 0xf0)
-	prev_status = (prev_status & 0xf0)
-
-	# Both events are on the same channel. If the two status bytes are
-	# exactly the same, the rest is trivial. If it's note on/note off,
-	# we can combine those further.
-	if status == prev_status
-          data[0,1] = []	# delete status byte from data
-          return status + chan
-	elsif status == NOTE_OFF && data[2] == 64
+        status = data[0]
+        return status if status >= 0xf0 || prev_status >= 0xf0
+
+        chan = (status & 0x0f)
+        return status if chan != (prev_status & 0x0f)
+
+        status = (status & 0xf0)
+        prev_status = (prev_status & 0xf0)
+
+        # Both events are on the same channel. If the two status bytes are
+        # exactly the same, the rest is trivial. If it's note on/note off,
+        # we can combine those further.
+        if status == prev_status
+          data[0, 1] = [] # delete status byte from data
+          status + chan
+        elsif status == NOTE_OFF && data[2] == 64
           # If we see a note off and the velocity is 64, we can store
           # a note on with a velocity of 0. If the velocity isn't 64
           # then storing a note on would be bad because the would be
           # changed to 64 when reading the file back in.
-          data[2] = 0		# set vel to 0; do before possible shrinking
+          data[2] = 0 # set vel to 0; do before possible shrinking
           status = NOTE_ON + chan
           if prev_status == NOTE_ON
-            data[0,1] = []	# delete status byte
+            data[0, 1] = [] # delete status byte
           else
             data[0] = status
           end
-          return status
-	else
+          status
+        else
           # Can't compress data
-          return status + chan
-	end
+          status + chan
+        end
       end
 
       def write_instrument(instrument)
-	event = MetaEvent.new(META_INSTRUMENT, instrument)
-	write_var_len(0)
-	data = event.data_as_bytes()
-	@bytes_written += write_bytes(data)
+        return if instrument.nil?
+
+        event = MetaEvent.new(META_INSTRUMENT, instrument)
+        write_var_len(0)
+        data = event.data_as_bytes
+        @bytes_written += write_bytes(data)
       end
 
       def write_var_len(val)
-	buffer = Utils.as_var_len(val)
-	@bytes_written += write_bytes(buffer)
+        buffer = Utils.as_var_len(val)
+        @bytes_written += write_bytes(buffer)
       end
 
       def write16(val)
-	val = (-val | 0x8000) if val < 0
+        val = (-val | 0x8000) if val < 0
 
-	buffer = []
-	@io.putc((val >> 8) & 0xff)
-	@io.putc(val & 0xff)
-	@bytes_written += 2
+        @io.putc((val >> 8) & 0xff)
+        @io.putc(val & 0xff)
+        @bytes_written += 2
       end
 
       def write32(val)
-	val = (-val | 0x80000000) if val < 0
+        val = (-val | 0x80000000) if val < 0
 
-	@io.putc((val >> 24) & 0xff)
-	@io.putc((val >> 16) & 0xff)
-	@io.putc((val >> 8) & 0xff)
-	@io.putc(val & 0xff)
-	@bytes_written += 4
+        @io.putc((val >> 24) & 0xff)
+        @io.putc((val >> 16) & 0xff)
+        @io.putc((val >> 8) & 0xff)
+        @io.putc(val & 0xff)
+        @bytes_written += 4
       end
 
       def write_bytes(bytes)
-	bytes.each { |b| @io.putc(b) }
-	bytes.length
+        bytes.each { |b| @io.putc(b) }
+        bytes.length
       end
     end
-
   end
 end

data/lib/midilib/measure.rb

@@ -1,80 +1,78 @@
-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
+require_relative '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
+      format('%d:%02d:%03d', m.measure_number, b.to_i + 1, (b - b.to_i) * @ppqd)
+    end
+  end
+end