midilib 2.0.4 → 2.0.5

data/lib/midilib/io/seqreader.rb

@@ -4,54 +4,54 @@ require 'midilib/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.
-#
-# We append new events to the end of a track's event list, bypassing a call
-# to Track.#add. This means that we must call Track.recalc_times at the end
-# of the track so it can update each event with its time from the track's
-# start (see end_track below).
-#
-# META_TRACK_END events are not added to tracks. This way, we don't have to
-# worry about making sure the last event is always a track end event. We
-# rely on the SeqWriter to append a META_TRACK_END event to each track when
-# it is output.
-
-class SeqReader < MIDIFile
-
-    # The optional proc 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
+  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.
+    #
+    # We append new events to the end of a track's event list, bypassing a
+    # call to Track.#add. This means that we must call Track.recalc_times at
+    # the end of the track so it can update each event with its time from
+    # the track's start (see end_track below).
+    #
+    # META_TRACK_END events are not added to tracks. This way, we don't have
+    # to worry about making sure the last event is always a track end event.
+    # We rely on the SeqWriter to append a META_TRACK_END event to each
+    # track when it is output.
+
+    class SeqReader < MIDIFile
+
+      # The optional proc 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
-    end
+      end
 
-    def header(format, ntrks, division)
+      def header(format, ntrks, division)
 	@seq.format = format
 	@seq.ppqn = division
 
 	@ntrks = ntrks
 	@update_block.call(nil, @ntrks, 0) if @update_block
-    end
+      end
 
-    def start_track()
+      def start_track()
 	@track = Track.new(@seq)
 	@seq.tracks << @track
 
 	@pending = []
-    end
+      end
 
-    def end_track()
+      def end_track()
 	# Turn off any pending note on messages
-	@pending.each { | on | make_note_off(on, 64) }
+	@pending.each { |on| make_note_off(on, 64) }
 	@pending = nil
 
 	# Don't bother adding the META_TRACK_END event to the track.
@@ -67,136 +67,136 @@ class SeqReader < MIDIFile
 
 	# call update block
 	@update_block.call(@track, @ntrks, @seq.tracks.length) if @update_block
-    end
+      end
 
-    def note_on(chan, note, vel)
+      def note_on(chan, note, vel)
 	if vel == 0
-	    note_off(chan, note, 64)
-	    return
+          note_off(chan, note, 64)
+          return
 	end
 
 	on = NoteOn.new(chan, note, vel, @curr_ticks)
 	@track.events << on
 	@pending << on
 	track_uses_channel(chan)
-    end
+      end
 
-    def note_off(chan, note, vel)
+      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 { | on, i |
-	    if on.note == note && on.channel == chan
-		make_note_off(on, vel)
-		@pending.delete_at(i)
-		return
-	    end
-	}
+	@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
-    end
+          " #{note}, vel #{vel})" if $DEBUG
+      end
 
-    def make_note_off(on, vel)
+      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
-    end
+      end
 
-    def pressure(chan, note, press)
+      def pressure(chan, note, press)
 	@track.events << PolyPressure.new(chan, note, press, @curr_ticks)
 	track_uses_channel(chan)
-    end
+      end
 
-    def controller(chan, control, value)
+      def controller(chan, control, value)
 	@track.events << Controller.new(chan, control, value, @curr_ticks)
 	track_uses_channel(chan)
-    end
+      end
 
-    def pitch_bend(chan, lsb, msb)
+      def pitch_bend(chan, lsb, msb)
 	@track.events << PitchBend.new(chan, (msb << 7) + lsb, @curr_ticks)
 	track_uses_channel(chan)
-    end
+      end
 
-    def program(chan, program)
+      def program(chan, program)
 	@track.events << ProgramChange.new(chan, program, @curr_ticks)
 	track_uses_channel(chan)
-    end
+      end
 
-    def chan_pressure(chan, press)
+      def chan_pressure(chan, press)
 	@track.events << ChannelPressure.new(chan, press, @curr_ticks)
 	track_uses_channel(chan)
-    end
+      end
 
-    def sysex(msg)
+      def sysex(msg)
 	@track.events << SystemExclusive.new(msg, @curr_ticks)
-    end
+      end
 
-    def meta_misc(type, msg)
+      def meta_misc(type, msg)
 	@track.events << MetaEvent.new(type, msg, @curr_ticks)
-    end
+      end
 
-# --
-#      def sequencer_specific(type, msg)
-#      end
+      # --
+      #      def sequencer_specific(type, msg)
+      #      end
 
-#      def sequence_number(num)
-#      end
-# ++
+      #      def sequence_number(num)
+      #      end
+      # ++
 
-    def text(type, msg)
+      def text(type, msg)
 	case type
         when META_TEXT, META_LYRIC, META_CUE
-            @track.events << MetaEvent.new(type, msg, @curr_ticks)
+          @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
+          @track.events << MetaEvent.new(type, msg, 0)
+	when META_INSTRUMENT
+          @track.instrument = msg
 	when META_MARKER
-	    @track.events << Marker.new(msg, @curr_ticks)
+          @track.events << Marker.new(msg, @curr_ticks)
 	else
-	    $stderr.puts "text = #{msg}, type = #{type}" if $DEBUG
+          $stderr.puts "text = #{msg}, type = #{type}" if $DEBUG
 	end
-    end
-
-# --
-    # Don't bother adding the META_TRACK_END event to the track. This way,
-    # 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 time_signature(numer, denom, clocks, qnotes)
+      end
+
+      # --
+      # Don't bother adding the META_TRACK_END event to the track. This way,
+      # 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 time_signature(numer, denom, clocks, qnotes)
 	@seq.time_signature(numer, denom, clocks, qnotes)
         @track.events << TimeSig.new(numer, denom, clocks, qnotes, @curr_ticks)
-    end
+      end
 
-# --
-#      def smpte(hour, min, sec, frame, fract)
-#      end
-# ++
+      # --
+      #      def smpte(hour, min, sec, frame, fract)
+      #      end
+      # ++
 
-    def tempo(microsecs)
+      def tempo(microsecs)
 	@track.events << Tempo.new(microsecs, @curr_ticks)
-    end
+      end
 
-    def key_signature(sharpflat, is_minor)
-      @track.events << KeySig.new(sharpflat, is_minor, @curr_ticks)
-    end
+      def key_signature(sharpflat, is_minor)
+        @track.events << KeySig.new(sharpflat, is_minor, @curr_ticks)
+      end
 
-# --
-#      def arbitrary(msg)
-#      end
-# ++
+      # --
+      #      def arbitrary(msg)
+      #      end
+      # ++
 
-    # Return true if the current track uses the specified channel.
-    def track_uses_channel(chan)
+      # Return true if the current track uses the specified channel.
+      def track_uses_channel(chan)
 	@chan_mask = @chan_mask | (1 << chan)
-    end
+      end
 
-end
+    end
 
-end
+  end
 end

data/lib/midilib/io/seqwriter.rb

@@ -5,36 +5,36 @@ require 'midilib/utils'
 
 module MIDI
 
-module IO
+  module IO
 
-class SeqWriter
+    class SeqWriter
 
-    def initialize(seq, proc = nil) # :yields: num_tracks, index
+      def initialize(seq, proc = nil) # :yields: num_tracks, index
 	@seq = seq
 	@update_block = block_given?() ? Proc.new() : proc
-    end
+      end
 
-    # Writes a MIDI format 1 file.
-    def write_to(io)
+      # 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 { | track, i |
-	    write_track(track)
-	    @update_block.call(track, @seq.tracks.length, i) if @update_block
-	}
-    end
+	@seq.tracks.each_with_index do |track, i|
+          write_track(track)
+          @update_block.call(track, @seq.tracks.length, i) if @update_block
+	end
+      end
 
-    def write_header
+      def write_header
 	@io.print 'MThd'
 	write32(6)
 	write16(1)		# Ignore sequence format; write as format 1
 	write16(@seq.tracks.length)
 	write16(@seq.ppqn)
-    end
+      end
 
-    def write_track(track)
+      def write_track(track)
 	@io.print 'MTrk'
 	track_size_file_pos = @io.tell()
 	write32(0)		# Dummy byte count; overwritten later
@@ -44,23 +44,22 @@ class SeqWriter
 
 	prev_event = nil
 	prev_status = 0
-	track.events.each { | event |
-	    if !event.kind_of?(Realtime)
-		write_var_len(event.delta_time)
-	    end
+	track.events.each do |event|
+          if !event.kind_of?(Realtime)
+            write_var_len(event.delta_time)
+          end
 
-	    data = event.data_as_bytes()
-	    status = data[0] # status byte plus channel number, if any
+          data = event.data_as_bytes()
+          status = data[0] # status byte plus channel number, if any
 
-	    # running status byte
-	    status = possibly_munge_due_to_running_status_byte(data,
-							       prev_status)
+          # running status byte
+          status = possibly_munge_due_to_running_status_byte(data, prev_status)
 
-	    @bytes_written += write_bytes(data)
+          @bytes_written += write_bytes(data)
 
-	    prev_event = event
-	    prev_status = status
-	}
+          prev_event = event
+          prev_status = status
+	end
 
 	# Write track end event.
 	event = MetaEvent.new(META_TRACK_END)
@@ -72,12 +71,12 @@ class SeqWriter
 	@io.seek(track_size_file_pos)
 	write32(@bytes_written)
 	@io.seek(0, ::IO::SEEK_END)
-    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)
+      # 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
 
@@ -91,49 +90,49 @@ class SeqWriter
 	# 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
+          data[0,1] = []	# delete status byte from data
+          return 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
-	    status = NOTE_ON + chan
-	    if prev_status == NOTE_ON
-		data[0,1] = []	# delete status byte
-	    else
-		data[0] = status
-	    end
-	    return status
+          # 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
+          status = NOTE_ON + chan
+          if prev_status == NOTE_ON
+            data[0,1] = []	# delete status byte
+          else
+            data[0] = status
+          end
+          return status
 	else
-	    # Can't compress data
-	    return status + chan
+          # Can't compress data
+          return status + chan
 	end
-    end
+      end
 
-    def write_instrument(instrument)
+      def write_instrument(instrument)
 	event = MetaEvent.new(META_INSTRUMENT, instrument)
 	write_var_len(0)
 	data = event.data_as_bytes()
 	@bytes_written += write_bytes(data)
-    end
+      end
 
-    def write_var_len(val)
+      def write_var_len(val)
 	buffer = Utils.as_var_len(val)
 	@bytes_written += write_bytes(buffer)
-    end
+      end
 
-    def write16(val)
+      def write16(val)
 	val = (-val | 0x8000) if val < 0
 
 	buffer = []
 	@io.putc((val >> 8) & 0xff)
 	@io.putc(val & 0xff)
 	@bytes_written += 2
-    end
+      end
 
-    def write32(val)
+      def write32(val)
 	val = (-val | 0x80000000) if val < 0
 
 	@io.putc((val >> 24) & 0xff)
@@ -141,13 +140,13 @@ class SeqWriter
 	@io.putc((val >> 8) & 0xff)
 	@io.putc(val & 0xff)
 	@bytes_written += 4
-    end
+      end
 
-    def write_bytes(bytes)
+      def write_bytes(bytes)
 	bytes.each { |b| @io.putc(b) }
 	bytes.length
+      end
     end
-end
 
-end
+  end
 end