midilib 0.8.4

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rubygems'
+require_gem 'rake'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/runtest'
+
+PROJECT_NAME = 'midilib'
+RUBYFORGE_USER = 'jimm'
+RDOC_DIR = 'html'
+
+PKG_FILES = FileList[ 'ChangeLog', 'Credits', 'README', 'Rakefile', 'TODO',
+    'examples/**/*',
+    'html/**/*',
+    'install.rb',
+    'lib/**/*.rb',
+    'test/**/*.rb']
+
+task :default => [:package]
+
+spec = Gem::Specification.new do |s|
+    s.platform = Gem::Platform::RUBY
+    s.name = PROJECT_NAME
+    s.version = `ruby -Ilib -e 'require "midilib/info"; puts MIDI::Version'`.strip
+    s.requirements << 'none'
+
+    s.require_path = 'lib'
+    s.autorequire = PROJECT_NAME
+
+    s.files = PKG_FILES.to_a
+
+    s.has_rdoc = true
+    s.rdoc_options << '--main' << 'README'
+    s.extra_rdoc_files = ['README', 'TODO']
+
+    s.author = 'Jim Menard'
+    s.email = 'jimm@io.com'
+    s.homepage = 'http://midilib.rubyforge.org'
+    s.rubyforge_project = PROJECT_NAME
+
+    s.summary = "MIDI file and event manipulation library"
+    s.description = <<EOF
+midilib is a pure Ruby MIDI library useful for reading and
+writing standard MIDI files and manipulating MIDI event data.
+EOF
+end
+
+# Creates a :package task (also named :gem). Also useful are :clobber_package
+# and :repackage.
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+end
+
+# creates an "rdoc" task
+Rake::RDocTask.new do | rd |
+    rd.main = 'README'
+    rd.title = PROJECT_NAME
+    rd.rdoc_files.include('README', 'TODO', 'lib/**/*.rb')
+end
+
+task :rubyforge => [:rdoc] do
+    Rake::RubyForgePublisher.new(PROJECT_NAME, RUBYFORGE_USER).upload
+end
+
+task :test do
+    Rake::run_tests
+end

data/TODO

@@ -0,0 +1,25 @@
+== Bugs
+
+* None known.
+
+== Features
+
+* Method to translate event's time_from_start to number of milliseconds from
+  start.
+
+* Swing quantizing. (Implied by list email from Carl Youngblood
+  <carl.youngblood@gmail.com>)
+
+* Implement key signature in SeqReader.
+
+* Format 0 files.
+
+* Format 2 files(?).
+
+== Documentation
+
+* Write better docs.
+
+== Tests
+
+* More needed?

data/examples/from_scratch.rb

@@ -0,0 +1,56 @@
+#! /usr/bin/env ruby
+#
+# usage: from_scratch.rb
+#
+# This script shows you how to create a new sequence from scratch and save it
+# to a MIDI file. It creates a file called 'from_scratch.mid'.
+
+# Start looking for MIDI module classes in the directory above this one.
+# This forces us to use the local copy, even if there is a previously
+# installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'midilib/sequence'
+require 'midilib/consts'
+include MIDI
+
+seq = Sequence.new()
+
+# Create a first track for the sequence. This holds tempo events and stuff
+# like that.
+track = Track.new(seq)
+seq.tracks << track
+track.events << Tempo.new(Tempo.bpm_to_mpq(120))
+track.events << MetaEvent.new(META_SEQ_NAME, 'Sequence Name')
+
+# Create a track to hold the notes. Add it to the sequence.
+track = Track.new(seq)
+seq.tracks << track
+
+# Give the track a name and an instrument name (optional).
+track.name = 'My New Track'
+track.instrument = GM_PATCH_NAMES[0]
+
+# Add a volume controller event (optional).
+track.events << Controller.new(0, CC_VOLUME, 127)
+
+# Add events to the track: a major scale. Arguments for note on and note off
+# constructors are channel, note, velocity, and delta_time. Channel numbers
+# start at zero. We use the new Sequence#note_to_delta method to get the
+# delta time length of a single quarter note.
+track.events << ProgramChange.new(0, 1, 0)
+quarter_note_length = seq.note_to_delta('quarter')
+[0, 2, 4, 5, 7, 9, 11, 12].each { | offset |
+  track.events << NoteOnEvent.new(0, 64 + offset, 127, 0)
+  track.events << NoteOffEvent.new(0, 64 + offset, 127, quarter_note_length)
+}
+
+# Calling recalc_times is not necessary, because that only sets the events'
+# start times, which are not written out to the MIDI file. The delta times are
+# what get written out.
+
+# track.recalc_times
+
+File.open('from_scratch.mid', 'wb') { | file |
+	seq.write(file)
+}

data/examples/reader2text.rb

@@ -0,0 +1,220 @@
+#! /usr/bin/env ruby
+#
+# usage: reader2text.rb [midi_file]
+#
+# This script translates a MIDI file into text. It subclasses MIDI::MIDIFile
+# and overrides the methods that are called when various events are seen
+# in the file.
+#
+# For a simpler way to do the same thing, see seq2text.rb.
+#
+
+# Start looking for MIDI module classes in the directory above this one.
+# This forces us to use the local copy, even if there is a previously
+# installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'midilib/sequence'
+require 'midilib/io/midifile'
+
+DEFAULT_MIDI_TEST_FILE = 'NoFences.mid'
+
+class TextTranslator < MIDI::IO::MIDIFile
+
+    def initialize(seq, proc = nil)
+	super()
+	@seq = seq
+	@track = nil
+	@update_block = block_given?() ? Proc.new() : proc
+    end
+
+    # Generate a unique number for a channel/note combination. This is used
+    # to remember pending note on events.
+    def note_hash(chan, note)
+	return (chan << 8) + note
+    end
+
+    # Print a delta time.
+    def pdelta
+	print "#{@curr_ticks}: "
+    end
+
+# The remaining methods are overrides of methods in MIDI::IO::MIDIFile.
+
+    def header(format, ntrks, division)
+	puts "header: format = #{format}, ntrks = #{ntrks}," +
+	    " division = #{division}"
+
+	@ntrks = ntrks
+	@update_block.call(nil, @ntrks, 0) if @update_block
+    end
+
+    def start_track()
+	pdelta()
+	puts "track start"
+
+	@pending = []
+	@chan_mask = 0
+    end
+
+    def end_track()
+	pdelta()
+	puts "track end; chans used bitmask = #{@chan_mask}"
+	# Write message for any pending note on messages
+	@pending.each_with_index { | num, chan |
+	    puts "pending note off missing for chan #{num >> 8}," +
+		" note #{num & 0xff}" if note_obj
+	}
+	@pending = nil
+
+	# call update block
+	@update_block.call(@track, @ntrks, @seq.tracks.length) if @update_block
+    end
+
+    def note_on(chan, note, vel)
+	pdelta()
+	if vel == 0
+	    print "(note on, vel 0) "
+	    note_off(chan, note, 64)
+	    return
+	end
+
+	puts "note on chan #{chan}, note #{note}, vel #{vel}"
+	@pending << note_hash(chan, note)
+	track_uses_channel(chan)
+    end
+
+    def note_off(chan, note, vel)
+	pdelta()
+	# Find note on, create note off, connect the two, and remove
+	# note on from pending list.
+	pnum = note_hash(chan, note)
+	@pending.each_with_index { | num, i |
+	    if pnum == num
+		puts "note off chan #{chan}, note #{note}, vel #{vel}"
+		@pending.delete_at(i)
+		return
+	    end
+	}
+	puts "note off with no earlier note on (ch #{chan}, note" +
+	    " #{note}, vel #{vel})"
+    end
+
+    def pressure(chan, note, press)
+	pdelta()
+	puts "pressure chan #{chan}, note #{note}, press #{press}"
+	track_uses_channel(chan)
+    end
+
+    def controller(chan, control, value)
+	pdelta()
+	puts "controller chan #{chan}, control #{control}, value #{value}"
+	track_uses_channel(chan)
+    end
+
+    def pitch_bend(chan, msb, lsb)
+	pdelta()
+	puts "pitch bend chan #{chan}, msb #{msb}, lsb #{lsb}"
+	track_uses_channel(chan)
+    end
+
+    def program(chan, program)
+	pdelta()
+	puts "program chan #{chan}, program #{program}"
+	track_uses_channel(chan)
+    end
+
+    def chan_pressure(chan, press)
+	pdelta()
+	puts "chan press chan #{chan}, press #{press}"
+	track_uses_channel(chan)
+    end
+
+    def sysex(msg)
+	pdelta()
+	puts "sysex size #{msg.length}"
+    end
+
+    def meta_misc(type, msg)
+	pdelta()
+	puts "meta misc type #{type}, length #{msg.length}"
+    end
+
+    def sequencer_specific(type, msg)
+	pdelta()
+	puts "sequencer specific type #{type}, msg #{msg.length}"
+    end
+
+    def sequence_number(num)
+	pdelta()
+	puts "sequence number #{num}"
+    end
+
+    def text(type, msg)
+	pdelta()
+	case type
+	when MIDI::META_SEQ_NAME
+	    puts "seq or track name #{msg}"
+	when MIDI::META_INSTRUMENT
+	    puts "instrument name #{msg}"
+	when MIDI::META_MARKER
+	    puts "marker #{msg}"
+	else
+	    puts "text = #{msg}, type = #{type}"
+	end
+    end
+
+    def eot()
+	pdelta()
+	puts "end of track event"
+    end
+
+    def time_signature(numer, denom, clocks, qnotes)
+	pdelta()
+	puts "time sig numer #{numer}, denom #{denom}, clocks #{clocks}," +
+	    " qnotes #{qnotes}"
+    end
+
+    def smpte(hour, min, sec, frame, fract)
+	pdelta()
+	puts "smpte #{hour}:#{min}.#{sec}, frame #{frame}, fract #{fract}"
+    end
+
+    def tempo(microsecs)
+	pdelta()
+	bpm = 1.0 / microsecs	# quarter notes per microsecond
+	bpm *= 1000000.0	# quarter notes per second
+	bpm *= 60.0		# quarter notes per minute
+	puts "tempo microsecs pqn = #{microsecs} (#{bpm} bpm)"
+    end
+
+    def key_signature(sharpflat, is_minor)
+	pdelta()
+	puts "key sig sharpflat #{sharpflat}, is_minor #{is_minor}"
+    end
+
+    def arbitrary(msg)
+	pdelta()
+	puts "arbitrary length = #{msg.length}"
+    end
+
+    def track_uses_channel(chan)
+	@chan_mask = @chan_mask | (1 << chan)
+    end
+
+end
+
+# ================================================================
+
+seq = MIDI::Sequence.new()
+
+# Specify what class to use when reading the MIDI file.
+seq.reader_class = TextTranslator
+
+File.open(ARGV[0] || DEFAULT_MIDI_TEST_FILE, 'rb') { | file |
+    # The block we pass in to Sequence.read is called at the end of every
+    # track read. It is optional, but is useful for progress reports.
+    seq.read(file) { | track, num_tracks, i |
+	puts "read track #{track ? track.name : ''} (#{i} of #{num_tracks})"
+    }
+}

data/examples/seq2text.rb

@@ -0,0 +1,41 @@
+#! /usr/bin/env ruby
+#
+# usage: seq2text.rb [midi_file]
+#
+# This script translates a MIDI file into text. It reads the file into
+# a MIDI::Sequence and calls to_s for each event.
+#
+# For a different (and more verbose) way to do the same thing, see
+# reader2tex.rb.
+#
+
+# Start looking for MIDI module classes in the directory above this one.
+# This forces us to use the local copy, even if there is a previously
+# installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'midilib/sequence'
+
+DEFAULT_MIDI_TEST_FILE = 'NoFences.mid'
+
+# Read from MIDI file
+seq = MIDI::Sequence.new()
+
+File.open(ARGV[0] || DEFAULT_MIDI_TEST_FILE, 'rb') { | file |
+    # The block we pass in to Sequence.read is called at the end of every
+    # track read. It is optional, but is useful for progress reports.
+    seq.read(file) { | track, num_tracks, i |
+	puts "read track #{track ? track.name : ''} (#{i} of #{num_tracks})"
+    }
+}
+
+seq.each { | track |
+    puts "*** track name \"#{track.name}\""
+    puts "instrument name \"#{track.instrument}\""
+    puts "#{track.events.length} events"
+    track.each { | e |
+	e.print_decimal_numbers = true # default = false (print hex)
+	e.print_note_names = true # default = false (print note numbers)
+	puts e
+    }
+}

data/examples/strings.rb

@@ -0,0 +1,34 @@
+#! /usr/bin/env ruby
+#
+# usage: strings.rb [midi_file]
+#
+# Prints all strings (track names, etc.) found in the MIDI file.
+#
+
+# Start looking for MIDI module classes in the directory above this one.
+# This forces us to use the local copy, even if there is a previously
+# installed version out there somewhere.
+$LOAD_PATH[0, 0] = File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'midilib/sequence'
+require 'midilib/consts'
+
+DEFAULT_MIDI_TEST_FILE = 'NoFences.mid'
+
+seq = MIDI::Sequence.new()
+File.open(ARGV[0] || DEFAULT_MIDI_TEST_FILE, 'rb') { | file |
+    # The block we pass in to Sequence.read is called at the end of every
+    # track read. It is optional, but is useful for progress reports.
+    seq.read(file) { | track, num_tracks, i |
+	puts "read track #{track ? track.name : ''} (#{i} of #{num_tracks})"
+    }
+}
+
+include MIDI
+seq.each { | track |
+    track.each { | event |
+	puts event.data if event.meta? &&
+	    [META_TEXT, META_COPYRIGHT, META_SEQ_NAME, META_INSTRUMENT,
+	     META_LYRIC, META_CUE, META_MARKER].include?(event.meta_type)
+    }
+}