midilib 0.8.4

data/lib/midilib/track.rb

@@ -0,0 +1,115 @@
+require 'midilib/event'
+
+module MIDI
+
+# 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'
+
+    attr_accessor :instrument, :events, :channels_used
+    attr_reader :sequence
+
+    def initialize(sequence)
+	@sequence = sequence
+	@events = Array.new()
+
+	# Bitmask of all channels used. Set when track is read in from
+	# a MIDI file.
+	@channels_used = 0
+    end
+
+    # Return track name. If there is no name, return UNNAMED.
+    def name
+	event = @events.detect { | e |
+	    e.meta? && e.meta_type == META_SEQ_NAME
+	}
+	return event ? event.data : UNNAMED
+    end
+
+    # Set track name. Replaces or creates a name meta-event.
+    def name=(name)
+	event = @events.detect { | e |
+	    e.meta? && 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
+
+    # 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)
+    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).sort_by { | e | e.time_from_start }
+	recalc_delta_from_times(0, list)
+	return list
+    end
+
+    # Quantize every event. +denom+ is the beat denominator. To quantize to
+    # sixteenths pass in a +denom+ of 16.
+    #
+    # Since each event's time_from_start is modified, we call
+    # recalc_delta_from_times after each event quantizes itself.
+    def quantize(denom)
+	boundary = @sequence.ppqn / denom
+	@events.each { | event | event.quantize_to(boundary) }
+	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
+	}
+    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.
+    def recalc_delta_from_times(starting_at=0, list=@events)
+	prev_time_from_start = 0
+	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
+	}
+    end
+
+    # Iterate over events.
+    def each			# :yields: event
+	@events.each { | event | yield event }
+    end
+
+    # Sort events by their time_from_start. After sorting,
+    # recalc_delta_from_times is called to make sure that the delta times
+    # reflect the possibly new event order.
+    def sort
+	@events = @events.sort_by { | e | e.time_from_start }
+	recalc_delta_from_times()
+    end
+end
+
+end

data/lib/midilib/utils.rb

@@ -0,0 +1,36 @@
+module MIDI
+
+# 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'
+    ]
+
+    # 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}"
+    end
+
+    # Given an integer, returns it as a variable length array of bytes (the
+    # format used by MIDI files).
+    #
+    # 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!
+    end
+
+end
+end

data/test/event_equality.rb

@@ -0,0 +1,81 @@
+# This code defines equality operators for all of the event classes. It's
+# used by SeqTester.
+#
+# I don't think it is necessary to include these methods in the base Event
+# classes. If someone disagrees, it would be trivial to move them there.
+
+module MIDI
+
+    class Event
+	def ==(an_obj)
+	    return an_obj.instance_of?(self.class) &&
+		@status == an_obj.status &&
+		@delta_time == an_obj.delta_time &&
+		@time_from_start == an_obj.time_from_start
+	end
+    end
+
+    class ChannelEvent
+	def ==(an_obj)
+	    return super(an_obj) && @channel == an_obj.channel
+	end
+    end
+
+    class NoteEvent < ChannelEvent
+	def ==(an_obj)
+	    return super(an_obj) &&
+		@note == an_obj.note && @velocity == an_obj.velocity
+	end
+    end
+
+    class Controller < ChannelEvent
+	def ==(an_obj)
+	    return super(an_obj) &&
+		@controller == an_obj.controller && @value == an_obj.value
+	end
+    end
+
+    class ProgramChange < ChannelEvent
+	def ==(an_obj)
+	    return super(an_obj) && @program == an_obj.program
+	end
+    end
+
+    class ChannelPressure < ChannelEvent
+	def ==(an_obj)
+	    return super(an_obj) && @pressure == an_obj.pressure
+	end
+    end
+
+    class PitchBend < ChannelEvent
+	def ==(an_obj)
+	    return super(an_obj) && @value == an_obj.value
+	end
+    end
+
+    class SystemExclusive < SystemCommon
+	def ==(an_obj)
+	    return super(an_obj) && @data == an_obj.data
+	end
+    end
+
+    class SongPointer < SystemCommon
+	def ==(an_obj)
+	    return super(an_obj) && @pointer == an_obj.pointer
+	end
+    end
+
+    class SongSelect < SystemCommon
+	def ==(an_obj)
+	    return super(an_obj) && @song == an_obj.song
+	end
+    end
+
+    class MetaEvent < Event
+	def ==(an_obj)
+	    return super(an_obj) && @meta_type == an_obj.meta_type &&
+		@data == an_obj.data
+	end
+    end
+
+end

data/test/test_event.rb

@@ -0,0 +1,116 @@
+# Start looking for MIDI classes in the directory above this one.
+# This forces us to use the local copy of MIDI, even if there is
+# a previously installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+require 'midilib'
+
+class EventTester < Test::Unit::TestCase
+
+    def test_note_on
+	e = MIDI::NoteOnEvent.new
+	assert_equal(MIDI::NOTE_ON, e.status)
+	assert_equal(0, e.channel)
+	assert_equal(64, e.note)
+	assert_equal(64, e.velocity)
+	assert_equal(0, e.delta_time)
+	assert_equal(0, e.time_from_start)
+    end
+
+    def test_quantize
+	e = MIDI::NoteOnEvent.new
+	e.quantize_to(4)
+	assert_equal(0, e.time_from_start)
+
+	# Each value in this array is the expected quantized value of
+	# its index in the array.
+
+	# Test with quantize_to(4)
+	[0, 0, 4, 4, 4, 4, 8, 8, 8, 8, 12, 12, 12, 12, 16].each_with_index {
+	    | after, before |
+	    e.time_from_start = before
+	    e.quantize_to(4)
+	    assert_equal(after, e.time_from_start)
+	}
+
+	# Test with quantize_to(6)
+	[0, 0, 0, 6, 6, 6, 6, 6, 6, 12, 12, 12, 12, 12, 12,
+	 18, 18, 18, 18, 18, 18, 24].each_with_index {
+	    | after, before |
+	    e.time_from_start = before
+	    e.quantize_to(6)
+	    assert_equal(after, e.time_from_start)
+	}
+    end
+
+    def test_to_s
+	e = MIDI::NoteOnEvent.new
+	assert_equal("0: ch 00 on 40 40", e.to_s)
+	e.print_decimal_numbers = true
+	assert_equal("0: ch 0 on 64 64", e.to_s)
+	e.print_note_names = true
+	assert_equal("0: ch 0 on E4 64", e.to_s)
+	e.print_decimal_numbers = false
+	assert_equal("0: ch 00 on E4 40", e.to_s)
+    end
+
+    def test_bools_note_on
+      e = MIDI::NoteOnEvent.new
+      assert(e.channel?)
+      assert(e.note?)
+      assert(e.note_on?)
+      assert(!e.note_off?)
+      assert(!e.meta?)
+      assert(!e.system?)
+      assert(!e.realtime?)
+    end
+
+    def test_bools_note_off
+      e = MIDI::NoteOffEvent.new
+      assert(e.channel?)
+      assert(e.note?)
+      assert(!e.note_on?)
+      assert(e.note_off?)
+      assert(!e.meta?)
+      assert(!e.system?)
+      assert(!e.realtime?)
+    end
+
+    def test_bools_realtime
+      e = MIDI::Clock.new
+      assert(!e.channel?)
+      assert(!e.note?)
+      assert(!e.meta?)
+      assert(!e.system?)
+      assert(e.realtime?)
+    end
+
+    def test_bools_controller
+      e = MIDI::Controller.new
+      assert(e.channel?)
+      assert(!e.note?)
+      assert(!e.meta?)
+      assert(!e.system?)
+      assert(!e.realtime?)
+    end
+
+    def test_bools_meta
+      e = MIDI::MetaEvent.new(MIDI::META_SEQ_NUM)
+      assert(!e.channel?)
+      assert(!e.note?)
+      assert(e.meta?)
+      assert(!e.system?)
+      assert(!e.realtime?)
+    end
+
+    def test_bools_system
+      e = MIDI::TuneRequest.new
+      assert(!e.channel?)
+      assert(!e.note?)
+      assert(!e.meta?)
+      assert(e.system?)
+      assert(!e.realtime?)
+    end
+
+end

data/test/test_io.rb

@@ -0,0 +1,55 @@
+# Start looking for MIDI classes in the directory above this one.
+# This forces us to use the local copy of MIDI, even if there is
+# a previously installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+# Add current directory so we can find event_equality
+$LOAD_PATH[0, 0] = File.dirname(__FILE__)
+
+require 'test/unit'
+require 'midilib'
+require 'event_equality'
+
+class IOTester < Test::Unit::TestCase
+
+    SEQ_TEST_FILE = File.join(File.dirname(__FILE__), 'test.mid')
+    OUTPUT_FILE = 'testout.mid'
+
+    def compare_tracks(t0, t1)
+	assert_equal(t0.name, t1.name, 'track names differ')
+	assert_equal(t0.events.length, t1.events.length,
+		     'number of track events differ')
+	t0.each_with_index { | ev0, i |
+	    assert_equal(ev0, t1.events[i], 'events differ')
+	}
+	assert_equal(t0.instrument, t1.instrument)
+    end
+
+    def compare_sequences(s0, s1)
+	assert_equal(s0.name, s1.name, 'sequence names differ')
+	assert_equal(s0.tracks.length, s1.tracks.length,
+		     'number of tracks differ')
+	s0.each_with_index { | track0, i |
+	    compare_tracks(track0, s1.tracks[i])
+	}
+    end
+
+    def test_read_and_write
+	seq0 = MIDI::Sequence.new()
+
+	puts if $DEBUG
+	puts '    reading file' if $DEBUG
+	File.open(SEQ_TEST_FILE, 'rb') { | f | seq0.read(f) }
+
+	puts '    writing file' if $DEBUG
+	File.open(OUTPUT_FILE, 'wb') { | f | seq0.write(f) }
+
+	puts '    reading file' if $DEBUG
+	seq1 = MIDI::Sequence.new()
+	File.open(OUTPUT_FILE, 'rb') { | f | seq1.read(f) }
+
+	puts '    comparing sequences' if $DEBUG
+	compare_sequences(seq0, seq1)
+	File.delete(OUTPUT_FILE)
+    end
+
+end

data/test/test_sequence.rb

@@ -0,0 +1,68 @@
+# Start looking for MIDI classes in the directory above this one.
+# This forces us to use the local copy of MIDI, even if there is
+# a previously installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+require 'midilib'
+
+class SequenceTester < Test::Unit::TestCase
+
+    def setup
+	@seq = MIDI::Sequence.new
+	@track = MIDI::Track.new(@seq)
+	@seq.tracks << @track
+	3.times { @track.events << MIDI::NoteOnEvent.new(0, 64, 64, 100) }
+	@track.recalc_times
+    end
+
+    def test_basics
+	assert_equal(120, @seq.beats_per_minute)
+	assert_equal(1, @seq.tracks.length)
+	assert_equal(MIDI::Track::UNNAMED, @seq.name)
+	assert_equal(MIDI::Sequence::DEFAULT_TEMPO, @seq.bpm)
+    end
+
+    def test_length_to_delta
+      assert_equal(480, @seq.ppqn)
+      assert_equal(480, @seq.length_to_delta(1))
+      assert_equal(240, @seq.length_to_delta(0.5))
+
+      @seq.ppqn = 12
+      assert_equal(12, @seq.ppqn)
+      assert_equal(12, @seq.length_to_delta(1))
+      assert_equal(6, @seq.length_to_delta(0.5))
+      assert_equal(5, @seq.length_to_delta(0.49))
+    end
+
+    def test_note_to_length
+      assert_equal(1, @seq.note_to_length('quarter'))
+      assert_equal(4, @seq.note_to_length('whole'))
+      assert_equal(1.5, @seq.note_to_length('dotted quarter'))
+      assert_equal(1.0 / 3.0, @seq.note_to_length('quarter triplet'))
+      assert_equal(0.5, @seq.note_to_length('dotted quarter triplet'))
+      assert_equal(1.0 / 4, @seq.note_to_length('sixteenth'))
+      assert_equal(1.0 / 4, @seq.note_to_length('16th'))
+      assert_equal(1.0 / 8, @seq.note_to_length('thirty second'))
+      assert_equal(1.0 / 8, @seq.note_to_length('32nd'))
+      assert_equal(1.0 / 16, @seq.note_to_length('sixty fourth'))
+      assert_equal(1.0 / 16, @seq.note_to_length('sixtyfourth'))
+      assert_equal(1.0 / 16, @seq.note_to_length('64th'))
+    end
+
+    def test_note_to_delta
+      assert_equal(480, @seq.note_to_delta('quarter'))
+      assert_equal(480 * 4, @seq.note_to_delta('whole'))
+      assert_equal(720, @seq.note_to_delta('dotted quarter'))
+      assert_equal(480 / 3.0, @seq.note_to_delta('quarter triplet'))
+      assert_equal((480 / 3.0) * 1.5,
+		   @seq.note_to_delta('dotted quarter triplet'))
+      assert_equal(480 / 4, @seq.note_to_delta('sixteenth'))
+      assert_equal(480 / 4, @seq.note_to_delta('16th'))
+      assert_equal(480 / 8, @seq.note_to_delta('thirty second'))
+      assert_equal(480 / 8, @seq.note_to_delta('32nd'))
+      assert_equal(480 / 16, @seq.note_to_delta('sixty fourth'))
+      assert_equal(480 / 16, @seq.note_to_delta('sixtyfourth'))
+      assert_equal(480 / 16, @seq.note_to_delta('64th'))
+    end
+end