midilib 0.8.4

data/lib/midilib/io/seqreader.rb

@@ -0,0 +1,198 @@
+require 'midilib/io/midifile'
+require 'midilib/track'
+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
+	super()
+	@seq = seq
+	@track = nil
+	@chan_mask = 0
+	@update_block = block_given?() ? Proc.new() : proc
+    end
+
+    def header(format, ntrks, division)
+	@seq.format = format
+	@seq.ppqn = division
+
+	@ntrks = ntrks
+	@update_block.call(nil, @ntrks, 0) if @update_block
+    end
+
+    def start_track()
+	@track = Track.new(@seq)
+	@seq.tracks << @track
+
+	@pending = []
+    end
+
+    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.
+
+	# 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
+
+	# call update block
+	@update_block.call(@track, @ntrks, @seq.tracks.length) if @update_block
+    end
+
+    def note_on(chan, note, vel)
+	if vel == 0
+	    note_off(chan, note, 64)
+	    return
+	end
+
+	on = NoteOnEvent.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 { | on, i |
+	    if on.note == note && on.channel == chan
+		make_note_off(on, vel)
+		@pending.delete_at(i)
+		return
+	    end
+	}
+	$stderr.puts "note off with no earlier note on (ch #{chan}, note" +
+	    " #{note}, vel #{vel})" if $DEBUG
+    end
+
+    def make_note_off(on, vel)
+	off = NoteOffEvent.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)
+    end
+
+    def controller(chan, control, value)
+	@track.events << Controller.new(chan, control, value, @curr_ticks)
+	track_uses_channel(chan)
+    end
+
+    def pitch_bend(chan, msb, lsb)
+	@track.events << PitchBend.new(chan, (msb << 8) + lsb, @curr_ticks)
+	track_uses_channel(chan)
+    end
+
+    def program(chan, program)
+	@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)
+    end
+
+    def sysex(msg)
+	@track.events << SystemExclusive.new(msg, @curr_ticks)
+    end
+
+    def meta_misc(type, msg)
+	@track.events << MetaEvent.new(type, msg, @curr_ticks)
+    end
+
+# --
+#      def sequencer_specific(type, msg)
+#      end
+
+#      def sequence_number(num)
+#      end
+# ++
+
+    def text(type, msg)
+	case type
+	when META_SEQ_NAME
+	    @track.events << MetaEvent.new(META_SEQ_NAME, msg, 0)
+	when META_INSTRUMENT
+	    @track.instrument = msg
+	when META_MARKER
+	    @track.events << Marker.new(msg, @curr_ticks)
+	else
+	    $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)
+	@seq.time_signature(numer, denom, clocks, qnotes)
+    end
+
+# --
+#      def smpte(hour, min, sec, frame, fract)
+#      end
+# ++
+
+    def tempo(microsecs)
+	@track.events << Tempo.new(microsecs, @curr_ticks)
+    end
+
+# --
+#      def key_signature(sharpflat, is_minor)
+#      end
+
+#      def arbitrary(msg)
+#      end
+# ++
+
+    # 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

data/lib/midilib/io/seqwriter.rb

@@ -0,0 +1,151 @@
+# Writes MIDI files.
+
+require 'midilib/event'
+require 'midilib/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
+    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 { | track, i |
+	    write_track(track)
+	    @update_block.call(track, @seq.tracks.length, i) if @update_block
+	}
+    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)
+    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 { | 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
+
+	    # running status byte
+	    status = possibly_munge_due_to_running_status_byte(data,
+							       prev_status)
+
+	    @bytes_written += @io.write(data)
+
+	    prev_event = event
+	    prev_status = status
+	}
+
+	# Write track end event.
+	event = MetaEvent.new(META_TRACK_END)
+	write_var_len(0)
+	@bytes_written += @io.write(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] = ''	# 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] = ''	# delete status byte
+	    else
+		data[0] = status
+	    end
+	    return status
+	else
+	    # Can't compress data
+	    return 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 += @io.write(data)
+    end
+
+    def write_var_len(val)
+	buffer = Utils.as_var_len(val)
+	@bytes_written += @io.write(buffer)
+    end
+
+    def write16(val)
+	val = (-val | 0x8000) if val < 0
+
+	buffer = ''
+	buffer << ((val >> 8) & 0xff)
+	buffer << (val & 0xff)
+
+	@bytes_written += @io.write(buffer)
+    end
+
+    def write32(val)
+	val = (-val | 0x80000000) if val < 0
+
+	buffer = ''
+	buffer << ((val >> 24) & 0xff)
+	buffer << ((val >> 16) & 0xff)
+	buffer << ((val >> 8) & 0xff)
+	buffer << (val & 0xff)
+
+	@bytes_written += @io.write(buffer)
+    end
+end
+
+end
+end

data/lib/midilib/sequence.rb

@@ -0,0 +1,144 @@
+require 'midilib/io/seqreader'
+require 'midilib/io/seqwriter'
+
+module MIDI
+
+# A MIDI::Sequence contains MIDI::Track objects.
+class Sequence
+
+    include Enumerable
+
+    UNNAMED = 'Unnamed Sequence'
+    DEFAULT_TEMPO = 120
+
+    NOTE_TO_LENGTH = {
+      'whole' => 4.0,
+      'half' => 2.0,
+      'quarter' => 1.0,
+      'eighth' => 0.5,
+      '8th' => 0.5,
+      'sixteenth' => 0.25,
+      '16th' => 0.25,
+      'thirty second' => 0.125,
+      'thirtysecond' => 0.125,
+      '32nd' => 0.125,
+      'sixty fourth' => 0.0625,
+      'sixtyfourth' => 0.0625,
+      '64th' => 0.0625
+    }
+
+    attr_accessor :tracks, :ppqn, :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.
+    attr_accessor :reader_class
+    # The class to use for writeing MIDI from a stream. The default is
+    # MIDI::IO::SeqWriter. You can change this at any time.
+    attr_accessor :writer_class
+
+    def initialize
+	@tracks = Array.new()
+	@ppqn = 480
+
+	# Time signature
+	@numer = 4		# Numer + denom = 4/4 time default
+	@denom = 2
+	@clocks = @ppqn
+	@qnotes = 8
+
+	@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
+    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
+    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))
+    end
+
+    # Given a note length name like "whole", "dotted quarter", or "8th
+    # triplet", return the length of that note in quarter notes as a
+    # floating-point number, suitable for use as an argument to
+    # length_to_delta.
+    #
+    # Legal names are any value in NOTE_TO_LENGTH, optionally prefixed by
+    # "dotted_" and/or suffixed by "_triplet". So, for example,
+    # "dotted_quarter_triplet" returns the length of a dotted quarter-note
+    # triplet and "32nd" returns 1/32.
+    def note_to_length(name)
+      name.strip!
+      name =~ /^(dotted)?(.*?)(triplet)?$/
+      dotted, note_name, triplet = $1, $2, $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
+    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.
+    #
+    # See also note_to_delta and note_to_length.
+    def length_to_delta(length)
+      return (@ppqn * length).to_i
+    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()
+    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
+    end
+
+    # 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
+
+    # 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)
+    end
+
+    # Iterates over the tracks.
+    def each			# :yields: track
+	@tracks.each { | track | yield track }
+    end
+
+end
+end