MIDI.lua

#!/usr/bin/lua
--require 'DataDumper'   -- http://lua-users.org/wiki/DataDumper
local M = {} -- public interface
M.Version = 'VERSION'
M.VersionDate = 'DATESTAMP'
-- 20170917 6.8 fix 153: bad argument #1 to 'char' and round dtime
-- 20160702 6.7 to_millisecs() now handles set_tempo across multiple Tracks
-- 20150921 6.5 segment restores controllers as well as patch and tempo
-- 20150920 6.4 segment respects a set_tempo exactly on the start time
-- 20150628 6.3 absent any set_tempo, default is 120bpm (see MIDI filespec 1.1)
-- 20150422 6.2 works with lua5.3
-- 20140609 6.1 switch pod and doc over to using moonrocks 
-- 20140108 6.0 in lua5.2 require('posix') returns the posix table
-- 20120504 5.9 add the contents of mid_opus_tracks()
-- 20111129 5.7 _encode handles empty tracks; score2stats num_notes_by_channel
-- 20111111 5.6 fix patch 45 and 46 in Number2patch, should be Pizz and Harp
-- 20110115 5.5 add mix_opus_tracks()
-- 20110126 5.4 "previous message repeated N times" to save space on stderr
-- 20110126 5.3 robustness fix if one note_on and multiple note_offs
-- 20110125 5.2 opus2score terminates unended notes at the end of the track
-- 20110124 5.1 the warnings in midi2opus display track_num
-- 20110122 5.0 sysex2midimode.get pythonism eliminated
-- 20110119 4.9 copyright_text_event "time" item was missing
-- 20110110 4.8 note_on with velocity=0 treated as a note-off
-- 20110109 4.7 many global vars localised, passes lualint :-)
-- 20110108 4.6 duplicate int2sevenbits removed, passes lualint -r
-- 20110108 4.5 related end_track bugs fixed around line 516
-- 20110108 4.4 null text_event bug fixed
-- 20101026 4.3 segment() remembers all patch_changes, not just the list values
-- 20101010 4.2 play_score() uses posix.fork if available
-- 20101009 4.2 merge_scores() moves aside conflicting channels correctly
-- 20101006 4.1 concatenate_scores() deepcopys also its 1st score
-- 20101006 4.1 segment() uses start_time and end_time named arguments
-- 20101005 4.1 timeshift() must not pad the set_tempo command
-- 20101003 4.0 pitch2note_event must be chapitch2note_event
-- 20100918 3.9 set_sequence_number supported, FWIW
-- 20100918 3.8 timeshift and segment accept named args
-- 20100913 3.7 first released version

---------------------------- private -----------------------------
local sysex2midimode = {
	["\126\127\09\01\247"] = 1,
	["\126\127\09\02\247"] = 0,
	["\126\127\09\03\247"] = 2,
}

local previous_warning = '' -- 5.4
local previous_times = 0    -- 5.4
local function clean_up_warnings() -- 5.4
	-- Call this before returning from any publicly callable function
	-- whenever there's a possibility that a warning might have been printed
	-- by the function, or by any private functions it might have called.
	if previous_times > 1 then
		io.stderr:write('  previous message repeated '
		 ..previous_times..' times\n')
	elseif previous_times > 0 then
		io.stderr:write('  previous message repeated\n')
	end
	previous_times = 0
	previous_warning = ''
end
local function warn(str)
	if str == previous_warning then -- 5.4
		previous_times = previous_times + 1
	else
		clean_up_warnings()
		io.stderr:write(str,'\n')
		previous_warning = str
	end
end
local function die(str)
	clean_up_warnings()
	io.stderr:write(str,'\n')
	os.exit(1)
end
local function round(x) return math.floor(x+0.5) end

local function readOnly(t)  -- Programming in Lua, page 127
	local proxy = {}
	local mt = {
		__index = t,
		__newindex = function (t, k, v)
			die("attempt to update a read-only table")
		end
	}
	setmetatable(proxy, mt)
	return proxy
end

local function dict(a)
	local d = {}
	if a == nil then return d end
	for k,v in ipairs(a) do d[v] = true end
	return d
end

local function sorted_keys(t)
	local a = {}
	for k,v in pairs(t) do a[#a+1] = k end
	table.sort(a)
	return  a
end

local function int2byte(i)
	return string.char(math.floor((i+0.5) % 256))
end

local function int2sevenbits(i)
	return string.char(math.floor((i+0.5) % 128))
end

local function int2twobytes(i)
	local b1 = math.floor(i/256) % 256
	local b2 = i % 256
	return string.char(b1,b2)
end

local function twobytes2int(s)
	return 256*string.byte(string.sub(s,1)) + string.byte(string.sub(s,2))
end

local function int2fourbytes(i)
	local b1 = math.floor(i/16777216) % 256
	local b2 = math.floor(i/65536) % 256
	local b3 = math.floor(i/256) % 256
	local b4 = i % 256
	return string.char(b1,b2,b3,b4)
end

local function fourbytes2int(s)
	return 16777216*string.byte(string.sub(s,1)) +
	 65536 * string.byte(string.sub(s,2)) +
	 256*string.byte(string.sub(s,3)) + string.byte(string.sub(s,4))
end

local function read_14_bit(byte_a)
	-- decode a 14 bit quantity from two bytes,
	return string.byte(byte_a,1) + 128 * string.byte(byte_a,2)
end

local function write_14_bit(integer)
	-- encode a 14 bit quantity into two bytes,
	return string.char(integer % 128, math.floor(integer/128) % 128)
	-- return string.char((integer/128) % 128, integer % 128) 
end

local function ber_compressed_int(integer)
--[[BER compressed integer (not an ASN.1 BER, see perlpacktut for
details).  Its bytes represent an unsigned integer in base 128,
most significant digit first, with as few digits as possible.
Bit eight (the high bit) is set on each byte except the last.
]]
-- stderr.write('integer = ..',integer)
	-- warn('integer = '..tostring(integer)..' type '..type(integer))
	if integer == 0 then return '\000' end
	local ber = { string.char(integer % 128) }
	while integer > 127 do
		integer = math.floor(integer/128)
		local seven_bits = integer % 128
		table.insert(ber, 1, string.char(128+seven_bits))
	end
	return table.concat(ber)
end

local function str2ber_int(s, start)
--[[Given (a string, and a position within it), returns
(the ber_integer at that position, and the position after the ber_integer).
]]
	local i = start
	local integer = 0
	while true do
		local byte = string.byte(s, i)
		integer = integer + (byte%128)
		if byte < 127.5 then
			return integer, i+1
		end
		if i >= #s then
			warn('str2ber_int: no end-of-integer found')
			return 0, start
		end
		i = i + 1
		integer = integer * 128
	end
end

local function some_text_event(which_kind, text)
	if not which_kind then which_kind = 1 end
	if not text then text = 'some_text' end
	return '\255'..int2sevenbits(which_kind)..ber_compressed_int(text:len())..text
end

local function copy(t)
	local new_table = {}
	for k, v in pairs(t) do new_table[k] = v end
	return new_table
end

local function deepcopy(object)  -- http://lua-users.org/wiki/CopyTable
	local lookup_table = {}
	local function _copy(object)
		if type(object) ~= "table" then
			return object
		elseif lookup_table[object] then
			return lookup_table[object]
		end
		local new_table = {}
		lookup_table[object] = new_table
		for index, value in pairs(object) do
			new_table[_copy(index)] = _copy(value)
		end
		return setmetatable(new_table, getmetatable(object))
	end
	return _copy(object)
end

local function _decode(trackdata, exclude, include, event_callback, exclusive_event_callback, no_eot_magic)
--[[Decodes MIDI track data into an opus-style list of events.
The options:
  'exclude' is a dictionary-table of event types which will be ignored
  'include' (and no exclude), makes exclude an array of all
      possible events, /minus/ what include specifies
  'event_callback' is a function
  'exclusive_event_callback' is a function
]]

	if not trackdata then trackdata= '' end
	if not exclude then exclude = {} end
	if not include then include = {} end
	if include and not exclude then exclude = M.All_events end  -- 4.6

	local event_code = -1 -- used for running status
	local event_count = 0
	local events = {}

	local i = 1     -- in Lua, i is the pointer to within the trackdata
	while i < #trackdata do   -- loop while there's anything to analyze
		local eot = false -- when True event registrar aborts this loop 4.6,4.7
   		event_count = event_count + 1

		local E = {} -- event; feed it to the event registrar at the end. 4.7

		-- Slice off the delta time code, and analyze it
		local time
		time, i = str2ber_int(trackdata, i)

		-- Now let's see what we can make of the command
		local first_byte = string.byte(trackdata,i); i = i+1

		if first_byte < 240 then  -- It's a MIDI event
			if first_byte % 256 > 127 then
				event_code = first_byte
			else
				-- It wants running status; use last event_code value
				i = i-1
				if event_code == -1 then
					warn("Running status not set; Aborting track.")
					return {}
				end
			end

			local command = math.floor(event_code / 16) * 16
			local channel = event_code % 16
			local parameter
			local param1
			local param2

			if command == 246 then  --  0-byte argument
				--pass
			elseif command == 192 or command == 208 then  --  1-byte arg
				parameter = string.byte(trackdata, i); i = i+1
			else -- 2-byte argument could be BB or 14-bit
				param1 = string.byte(trackdata, i); i = i+1
				param2 = string.byte(trackdata, i); i = i+1
			end

			----------------- MIDI events -----------------------

			local continue = false
			if command      == 128 then
				if exclude['note_off'] then
					continue = true
				else
					E = {'note_off', time, channel, param1, param2}
				end
			elseif command == 144 then
				if exclude['note_on'] then
					continue = true
				else
					E = {'note_on', time, channel, param1, param2}
				end
			elseif command == 160 then
				if exclude['key_after_touch'] then
					continue = true
				else
					E = {'key_after_touch',time,channel,param1,param2}
				end
			elseif command == 176 then
				if exclude['control_change'] then
					continue = true
				else
					E = {'control_change',time,channel,param1,param2}
				end
			elseif command == 192 then
				if exclude['patch_change'] then
					continue = true
				else
					E = {'patch_change', time, channel, parameter}
				end
			elseif command == 208 then
				if exclude['channel_after_touch'] then
					continue = true
				else
					E = {'channel_after_touch', time, channel, parameter}
				end
			elseif command == 224 then
				if exclude['pitch_wheel_change'] then
					continue = true
				else -- the 2 param bytes are a 14-bit int
					E = {'pitch_wheel_change', time, channel,
					 128*param2+param1-8192}
				end
			else
				warn("Shouldn't get here; command="..tostring(command))
			end

		elseif first_byte == 255 then  -- It's a Meta-Event!
			local command = string.byte(trackdata, i); i = i+1
			local length
			length, i = str2ber_int(trackdata, i)
			if (command      == 0) then
				if length == 2 then  -- 3.9
					E = {'set_sequence_number', time,
					 twobytes2int(string.sub(trackdata,i,i+1)) }
				else
					warn('set_sequence_number: length must be 2, not '
					 .. tostring(length))
					E = {'set_sequence_number', time, 0}
				end

			-- Defined text events ------
			elseif command == 1 then
				E = {'text_event', time, string.sub(trackdata,i,i+length-1)}
			elseif command == 2 then  -- 4.9
				E = {'copyright_text_event', time, string.sub(trackdata,i,i+length-1)}
			elseif command == 3 then
				E = {'track_name',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 4 then
				E = {'instrument_name',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 5 then
				E = {'lyric',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 6 then
				E = {'marker',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 7 then
				E = {'cue_point',time, string.sub(trackdata,i,i+length-1)}

			-- Reserved but apparently unassigned text events -------------
			elseif command == 8 then
				E = {'text_event_08',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 9 then
				E = {'text_event_09',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 10 then
				E = {'text_event_0a',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 11 then
				E = {'text_event_0b',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 12 then
				E = {'text_event_0c',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 13 then
				E = {'text_event_0d',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 14 then
				E = {'text_event_0e',time, string.sub(trackdata,i,i+length-1)}
			elseif command == 15 then
				E = {'text_event_0f',time, string.sub(trackdata,i,i+length-1)}
			
			-- Now the sticky events -------------------------------------
			elseif command == 47 then
				E = {'end_track', time}
				-- The code for handling this, oddly, comes LATER,
				-- in the event registrar.
			elseif command == 81 then -- DTime, Microseconds/Crochet
				if length ~= 3 then
					warn('set_tempo event, but length='..length)
				end
				E = {'set_tempo', time,
					string.byte(trackdata,i) * 65536
					+ string.byte(trackdata,i+1) * 256
					+ string.byte(trackdata,i+2)
				}
			elseif command == 84 then
				if length ~= 5 then   -- DTime, HR, MN, SE, FR, FF
					warn('smpte_offset event, but length='..length)
				end
				E = {'smpte_offset', time,
					string.byte(trackdata,i),
					string.byte(trackdata,i+1),
					string.byte(trackdata,i+2),
					string.byte(trackdata,i+3),
					string.byte(trackdata,i+4)
				}
			elseif command == 88 then
				if length ~= 4 then   -- DTime, NN, DD, CC, BB
					warn('time_signature event, but length='..length)
				end
				E = {'time_signature', time,
					string.byte(trackdata,i),
					string.byte(trackdata,i+1),
					string.byte(trackdata,i+2),
					string.byte(trackdata,i+3)
				}
			elseif command == 89 then
				if length ~= 2 then   -- DTime, SF(signed), MI
					warn('key_signature event, but length='..length)
				end
				local b1 = string.byte(trackdata,i)
				if b1 > 127 then b1 = b1 - 256 end   -- signed byte :-(
				local b2 = string.byte(trackdata,i+1)
				-- list(struct.unpack(">bB",trackdata[0:2]))}
				E = {'key_signature', time, b1, b2 }
			elseif (command == 127) then
				E = {'sequencer_specific',time,
					string.sub(trackdata,i,i+length-1)}
			else
				E = {'raw_meta_event', time, command,
					string.sub(trackdata,i,i+length-1)}
				--"[uninterpretable meta-event command of length length]"
				-- DTime, Command, Binary Data
				-- It's uninterpretable; record it as raw_data.
			end

			-- Pointer += length; --  Now move Pointer
			i = i + length
			-- Hmm... in lua, we should be using Pointer again....
			-- trackdata =  string.sub(trackdata, length+1)

		--#####################################################################
		elseif first_byte == 240 or first_byte == 247 then
			-- Note that sysexes in MIDI /files/ are different than sysexes
			-- in MIDI transmissions!! The vast majority of system exclusive
			-- messages will just use the F0 format. For instance, the
			-- transmitted message F0 43 12 00 07 F7 would be stored in a
			-- MIDI file as F0 05 43 12 00 07 F7. As mentioned above, it is
			-- required to include the F7 at the end so that the reader of the
			-- MIDI file knows that it has read the entire message. (But the F7
			-- is omitted if this is a non-final block in a multiblock sysex;
			-- but the F7 (if there) is counted in the message's declared
			-- length, so we don't have to think about it anyway.)
			--command = trackdata.pop(0)
			local length
			length, i = str2ber_int(trackdata, i)
			if first_byte == 240 then
				-- 20091008 added ISO-8859-1 to get an 8-bit str
				E = {'sysex_f0', time, string.sub(trackdata,i,i+length-1)}
			else
				E = {'sysex_f7', time, string.sub(trackdata,i,i+length-1)}
			end
			i = i + length
			-- trackdata =  string.sub(trackdata, length+1)

		--#####################################################################
		-- Now, the MIDI file spec says:
		--  <track data> = <MTrk event>+
		--  <MTrk event> = <delta-time> <event>
		--  <event> = <MIDI event> | <sysex event> | <meta-event>
		-- I know that, on the wire, <MIDI event> can include note_on,
		-- note_off, and all the other 8x to Ex events, AND Fx events
		-- other than F0, F7, and FF -- namely, <song position msg>,
		-- <song select msg>, and <tune request>.
		--
		-- Whether these can occur in MIDI files is not clear specified
		-- from the MIDI file spec.  So, I'm going to assume that
		-- they CAN, in practice, occur.  I don't know whether it's
		-- proper for you to actually emit these into a MIDI file.
		
		elseif first_byte == 242 then   -- DTime, Beats
			--  <song position msg> ::=     F2 <data pair>
			E = {'song_position', time, read_14_bit(string.sub(trackdata,i))}
			trackdata = string.sub(trackdata,3)

		elseif first_byte == 243 then -- <song select> ::= F3 <data singlet>
			-- E=['song_select', time, struct.unpack('>B',trackdata.pop(0))[0]]
			E = {'song_select', time, string.byte(trackdata,i)}
			-- trackdata = trackdata[1:]
			trackdata = string.sub(trackdata,2)
			-- DTime, Thing (what?! song number?  whatever ...)

		elseif first_byte == 246 then   -- DTime
			E = {'tune_request', time}
			-- What would a tune request be doing in a MIDI /file/?

		--########################################################
		-- ADD MORE META-EVENTS HERE.  TODO:
		-- f1 -- MTC Quarter Frame Message. One data byte follows
		--     the Status; it's the time code value, from 0 to 127.
		-- f8 -- MIDI clock.    no data.
		-- fa -- MIDI start.    no data.
		-- fb -- MIDI continue. no data.
		-- fc -- MIDI stop.     no data.
		-- fe -- Active sense.  no data.
		-- f4 f5 f9 fd -- unallocated

--[[
		elseif (first_byte > 240) { -- Some unknown kinda F-series event ####
			-- Here we only produce a one-byte piece of raw data.
			-- But the encoder for 'raw_data' accepts any length of it.
			E = [ 'raw_data', time, substr(trackdata,Pointer,1) ]
			-- DTime and the Data (in this case, the one Event-byte)
			++Pointer;  -- itself

]]
		elseif first_byte > 240 then  -- Some unknown F-series event
			-- Here we only produce a one-byte piece of raw data.
			E = {'raw_data', time, string.byte(trackdata,i)}  -- 4.6
			trackdata = string.sub(trackdata,2)  -- 4.6
		else  -- Fallthru.
			warn(string.format("Aborting track.  Command-byte first_byte=0x%x",first_byte)) --4.6
			break
		end
		-- End of the big if-group


		--#####################################################################
		--  THE EVENT REGISTRAR...
		-- warn('3: E='+str(E))
		if E and  E[1] == 'end_track' then
			-- This is the code for exceptional handling of the EOT event.
			eot = true
			if not no_eot_magic then
				if E[2] > 0 then  -- a null text-event to carry the delta-time
					E = {'text_event', E[2], ''}  -- 4.4
				else
					E = nil   -- EOT with a delta-time of 0; ignore it.
				end
			end
		end

		if E and not exclude[E[1]] then
			--if ( $exclusive_event_callback ):
			--    &{ $exclusive_event_callback }( @E );
			--else
			--    &{ $event_callback }( @E ) if $event_callback;
			events[#events+1] = E
		end
		if eot then break end
	end
	-- End of the big "Event" while-block

	return events
end

local function _encode(events_lol)
	local no_running_status = false
	local no_eot_magic      = false   -- 4.6
	local never_add_eot     = false   -- 4.6
	local unknown_callback  = false   -- 4.6
	local data = {} -- what I'll store the chunks of byte-data in

	-- This is so my end_track magic won't corrupt the original
	local events = deepcopy(events_lol)

	if not never_add_eot then -- One way or another, tack on an 'end_track'
		if #events > 0 then   -- 5.7
			local last = events[#events] -- 4.5, 4.7
			if not (last[1] == 'end_track') then  -- no end_track already
				if (last[1] == 'text_event' and last[3] == '') then -- 4.5,4.6
					-- 0-length text event at track-end. 
					if no_eot_magic then
						-- Exceptional case: don't mess with track-final
						-- 0-length text_events; just peg on an end_track
						events.append({'end_track', 0})
					else
						-- NORMAL CASE: replace with an end_track, leaving DTime
						last[1] = 'end_track'
					end
				else
					-- last event was neither 0-length text_event nor end_track
					events[#events+1] = {'end_track', 0}
				end
			end
		else  -- an eventless track!
			events = { {'end_track', 0},}
		end
	end

	-- maybe_running_status = not no_running_status  -- unused? 4.7
	local last_status = -1 -- 4.7

	for k,E in ipairs(events) do
		-- get rid of the two pop's and increase the other E[] indices by two
		if not E then break end

		local event = E[1] -- 4.7
		if #event < 1 then break end

		local dtime = round(E[2]) -- 4.7 6.8
		-- print('event='..event..' dtime='..dtime)

		local event_data = '' -- 4.7

		if    -- MIDI events -- eligible for running status
			 event	== 'note_on'
			 or event == 'note_off'
			 or event == 'control_change'
			 or event == 'key_after_touch'
			 or event == 'patch_change'
			 or event == 'channel_after_touch'
			 or event == 'pitch_wheel_change'   then

			-- This block is where we spend most of the time.  Gotta be tight.
			local status = nil     -- 4.7
			local parameters = nil -- 4.7
			if (event == 'note_off') then
				status = 128 + (E[3] % 16)
				parameters = int2sevenbits(E[4]%128)..int2sevenbits(E[5]%128)
			elseif event == 'note_on' then
				status = 144 + (E[3] % 16)
				parameters = int2sevenbits(E[4]) .. int2sevenbits(E[5])
			elseif event == 'key_after_touch' then
				status = 160 + (E[3] % 16)
				parameters = int2sevenbits(E[4]) .. int2sevenbits(E[5])
			elseif event == 'control_change' then
				status = 176 + (E[3] % 16)
				parameters = int2sevenbits(E[4]) .. int2sevenbits(E[5])
			elseif event == 'patch_change' then
				status = 192 + (E[3] % 16)
				parameters = int2sevenbits(E[4])
			elseif event == 'channel_after_touch' then
				status = 208 + (E[3] % 16)
				parameters = int2sevenbits(E[4])
			elseif event == 'pitch_wheel_change' then
				status = 224 + (E[3] % 16)
				parameters =  write_14_bit(E[4] + 8192)
			else
				warn("BADASS FREAKOUT ERROR 31415!")
			end

			-- And now the encoding

			data[#data+1] = ber_compressed_int(dtime)
			if (status ~= last_status) or no_running_status then
				data[#data+1] = int2byte(status)
			end
			data[#data+1] = parameters
			last_status = status
			-- break
		else
			-- Not a MIDI event.
			last_status = -1

			if event == 'raw_meta_event' then
				event_data = some_text_event(E[3], E[4])
			elseif (event == 'set_sequence_number') then  -- 3.9
				event_data = some_text_event(0, int2twobytes(E[3]))

			-- Text Meta-events...
			-- a case for a dict, I think (pjb) ...
			elseif (event == 'text_event') then
				event_data = some_text_event(1, E[3])
			elseif (event == 'copyright_text_event') then
				event_data = some_text_event(2, E[3])
			elseif (event == 'track_name') then
				event_data = some_text_event(3, E[3])
			elseif (event == 'instrument_name') then
				event_data = some_text_event(4, E[3])
			elseif (event == 'lyric') then
				event_data = some_text_event(5, E[3])
			elseif (event == 'marker') then
				event_data = some_text_event(6, E[3])
			elseif (event == 'cue_point') then
				event_data = some_text_event(7, E[3])
			elseif (event == 'text_event_08') then
				event_data = some_text_event(8, E[3])
			elseif (event == 'text_event_09') then
				event_data = some_text_event(9, E[3])
			elseif (event == 'text_event_0a') then
				event_data = some_text_event(10, E[3])
			elseif (event == 'text_event_0b') then
				event_data = some_text_event(11, E[3])
			elseif (event == 'text_event_0c') then
				event_data = some_text_event(12, E[3])
			elseif (event == 'text_event_0d') then
				event_data = some_text_event(13, E[3])
			elseif (event == 'text_event_0e') then
				event_data = some_text_event(14, E[3])
			elseif (event == 'text_event_0f') then
				event_data = some_text_event(15, E[3])
			-- End of text meta-events

			elseif (event == 'end_track') then
				event_data = '\255\47\0'
			elseif (event == 'set_tempo') then
				--event_data = struct.pack(">BBwa*", 0xFF, 0x51, 3,
				--			  substr( struct.pack('>I', E[0]), 1, 3))
				event_data = '\255\81\03' .. string.sub(int2fourbytes(E[3]),2)
				-- XXX don't understand that ?!
			elseif (event == 'smpte_offset') then
				event_data = '\255\84\05' ..
					string.char(E[3],E[4],E[5],E[6],E[7])
			elseif (event == 'time_signature') then
				event_data = '\255\88\04' .. string.char(E[3],E[4],E[5],E[6])
			elseif (event == 'key_signature') then
				local e3 = E[3]; if e3<0 then e3 = 256+e3 end  -- signed byte
				event_data = '\255\89\02' .. string.char(e3,E[4])
			elseif (event == 'sequencer_specific') then
				event_data = some_text_event(127, E[3])
			-- End of Meta-events

			-- Other Things...
			elseif (event == 'sysex_f0') then
				event_data =
				 "\240"..ber_compressed_int(string.len(E[3]))..E[3]
			elseif (event == 'sysex_f7') then
				event_data =
				 "\247"..ber_compressed_int(string.len(E[3]))..E[3]
			elseif (event == 'song_position') then
				 event_data = "\242"..write_14_bit( E[3] )
			elseif (event == 'song_select') then
				 event_data = "\243"..string.char(E[3])
			elseif (event == 'tune_request') then
				 event_data = "\246"
			elseif (event == 'raw_data') then
				warn("_encode: raw_data event not supported")
				break
			-- End of Other Stuff

			-- The Big Fallthru
			else
				if not unknown_callback then
					warn("Unknown event: "..tostring(event))
				end
				break
			end

			--print "Event $event encoded part 2\n"
			--if str(type(event_data)).find('str') >= 0 then
			--	event_data = bytearray(event_data.encode('Latin1', 'ignore'))
			--end
			if event_data and (#event_data > 0) then -- how could it be empty?
				-- data.append(struct.pack('>wa*', dtime, event_data))
				-- print(' event_data='+str(event_data))
				data[#data+1] = ber_compressed_int(dtime)
				data[#data+1] = event_data
			end
		end
	end
	return table.concat(data)
end

local function consistentise_ticks(scores) -- 3.6
	-- used by mix_scores, merge_scores, concatenate_scores
	if #scores == 1 then return deepcopy(scores) end
	local are_consistent = true
	local ticks = scores[1][1]
	for iscore = 2,#scores do
		if scores[iscore][1] ~= ticks then
			are_consistent = false
			break
		end
	end
	if are_consistent then return deepcopy(scores) end
	local new_scores = {}
	for ks,score in ipairs(scores) do
		new_scores[ks] = M.opus2score(M.to_millisecs(M.score2opus(score)))
	end
	return new_scores
end

-------------------------- public ------------------------------
M.All_events = readOnly{
	note_off=true, note_on=true, key_after_touch=true, control_change=true,
	patch_change=true, channel_after_touch=true, pitch_wheel_change=true,
	text_event=true, copyright_text_event=true, track_name=true,
	instrument_name=true, lyric=true, marker=true, cue_point=true,
	text_event_08=true, text_event_09=true, text_event_0a=true,
	text_event_0b=true, text_event_0c=true, text_event_0d=true,
	text_event_0e=true, text_event_0f=true,
	end_track=true, set_tempo=true, smpte_offset=true,
	time_signature=true, key_signature=true,
	sequencer_specific=true, raw_meta_event=true,
	sysex_f0=true, sysex_f7=true,
	song_position=true, song_select=true, tune_request=true,
}
-- And three dictionaries:
M.Number2patch = readOnly{   -- General MIDI patch numbers:
[0]='Acoustic Grand',
[1]='Bright Acoustic',
[2]='Electric Grand',
[3]='Honky-Tonk',
[4]='Electric Piano 1',
[5]='Electric Piano 2',
[6]='Harpsichord',
[7]='Clav',
[8]='Celesta',
[9]='Glockenspiel',
[10]='Music Box',
[11]='Vibraphone',
[12]='Marimba',
[13]='Xylophone',
[14]='Tubular Bells',
[15]='Dulcimer',
[16]='Drawbar Organ',
[17]='Percussive Organ',
[18]='Rock Organ',
[19]='Church Organ',
[20]='Reed Organ',
[21]='Accordion',
[22]='Harmonica',
[23]='Tango Accordion',
[24]='Acoustic Guitar(nylon)',
[25]='Acoustic Guitar(steel)',
[26]='Electric Guitar(jazz)',
[27]='Electric Guitar(clean)',
[28]='Electric Guitar(muted)',
[29]='Overdriven Guitar',
[30]='Distortion Guitar',
[31]='Guitar Harmonics',
[32]='Acoustic Bass',
[33]='Electric Bass(finger)',
[34]='Electric Bass(pick)',
[35]='Fretless Bass',
[36]='Slap Bass 1',
[37]='Slap Bass 2',
[38]='Synth Bass 1',
[39]='Synth Bass 2',
[40]='Violin',
[41]='Viola',
[42]='Cello',
[43]='Contrabass',
[44]='Tremolo Strings',
[45]='Pizzicato Strings',
[46]='Orchestral Harp',
[47]='Timpani',
[48]='String Ensemble 1',
[49]='String Ensemble 2',
[50]='SynthStrings 1',
[51]='SynthStrings 2',
[52]='Choir Aahs',
[53]='Voice Oohs',
[54]='Synth Voice',
[55]='Orchestra Hit',
[56]='Trumpet',
[57]='Trombone',
[58]='Tuba',
[59]='Muted Trumpet',
[60]='French Horn',
[61]='Brass Section',
[62]='SynthBrass 1',
[63]='SynthBrass 2',
[64]='Soprano Sax',
[65]='Alto Sax',
[66]='Tenor Sax',
[67]='Baritone Sax',
[68]='Oboe',
[69]='English Horn',
[70]='Bassoon',
[71]='Clarinet',
[72]='Piccolo',
[73]='Flute',
[74]='Recorder',
[75]='Pan Flute',
[76]='Blown Bottle',
[77]='Skakuhachi',
[78]='Whistle',
[79]='Ocarina',
[80]='Lead 1 (square)',
[81]='Lead 2 (sawtooth)',
[82]='Lead 3 (calliope)',
[83]='Lead 4 (chiff)',
[84]='Lead 5 (charang)',
[85]='Lead 6 (voice)',
[86]='Lead 7 (fifths)',
[87]='Lead 8 (bass+lead)',
[88]='Pad 1 (new age)',
[89]='Pad 2 (warm)',
[90]='Pad 3 (polysynth)',
[91]='Pad 4 (choir)',
[92]='Pad 5 (bowed)',
[93]='Pad 6 (metallic)',
[94]='Pad 7 (halo)',
[95]='Pad 8 (sweep)',
[96]='FX 1 (rain)',
[97]='FX 2 (soundtrack)',
[98]='FX 3 (crystal)',
[99]='FX 4 (atmosphere)',
[100]='FX 5 (brightness)',
[101]='FX 6 (goblins)',
[102]='FX 7 (echoes)',
[103]='FX 8 (sci-fi)',
[104]='Sitar',
[105]='Banjo',
[106]='Shamisen',
[107]='Koto',
[108]='Kalimba',
[109]='Bagpipe',
[110]='Fiddle',
[111]='Shanai',
[112]='Tinkle Bell',
[113]='Agogo',
[114]='Steel Drums',
[115]='Woodblock',
[116]='Taiko Drum',
[117]='Melodic Tom',
[118]='Synth Drum',
[119]='Reverse Cymbal',
[120]='Guitar Fret Noise',
[121]='Breath Noise',
[122]='Seashore',
[123]='Bird Tweet',
[124]='Telephone Ring',
[125]='Helicopter',
[126]='Applause',
[127]='Gunshot',
}

M.Notenum2percussion = readOnly{   -- General MIDI Percussion (on Channel 9):
[33]='Metronome Click',
[34]='Metronome Bell',
[35]='Acoustic Bass Drum',
[36]='Bass Drum 1',
[37]='Side Stick',
[38]='Acoustic Snare',
[39]='Hand Clap',
[40]='Electric Snare',
[41]='Low Floor Tom',
[42]='Closed Hi-Hat',
[43]='High Floor Tom',
[44]='Pedal Hi-Hat',
[45]='Low Tom',
[46]='Open Hi-Hat',
[47]='Low-Mid Tom',
[48]='Hi-Mid Tom',
[49]='Crash Cymbal 1',
[50]='High Tom',
[51]='Ride Cymbal 1',
[52]='Chinese Cymbal',
[53]='Ride Bell',
[54]='Tambourine',
[55]='Splash Cymbal',
[56]='Cowbell',
[57]='Crash Cymbal 2',
[58]='Vibraslap',
[59]='Ride Cymbal 2',
[60]='Hi Bongo',
[61]='Low Bongo',
[62]='Mute Hi Conga',
[63]='Open Hi Conga',
[64]='Low Conga',
[65]='High Timbale',
[66]='Low Timbale',
[67]='High Agogo',
[68]='Low Agogo',
[69]='Cabasa',
[70]='Maracas',
[71]='Short Whistle',
[72]='Long Whistle',
[73]='Short Guiro',
[74]='Long Guiro',
[75]='Claves',
[76]='Hi Wood Block',
[77]='Low Wood Block',
[78]='Mute Cuica',
[79]='Open Cuica',
[80]='Mute Triangle',
[81]='Open Triangle',
}

M.Event2channelindex = readOnly{ ['note']=4, ['note_off']=3, ['note_on']=3,
 ['key_after_touch']=3, ['control_change']=3, ['patch_change']=3,
 ['channel_after_touch']=3, ['pitch_wheel_change']=3,
}

function M.concatenate_scores(scores)
	-- the deepcopys are needed if input_scores are refs to the same table
	-- e.g. if invoked by midisox's repeat()
	local input_scores = consistentise_ticks(scores) -- 3.6
	local output_score = deepcopy(input_scores[1])   -- 4.2
	for i = 2,#input_scores do
		local input_score = input_scores[i]
		local output_stats = M.score2stats(output_score)
		local delta_ticks = output_stats['nticks']
		for itrack = 2,#input_score do
			if itrack > #output_score then -- new output track if doesn't exist
				output_score[#output_score+1] = {}
			end
			for k,event in ipairs(input_score[itrack]) do
				local new_event = copy(event)
				new_event[2] = new_event[2] + delta_ticks
				table.insert(output_score[itrack], new_event)
				-- output_score[itrack][-1][1] += delta_ticks  -- hmm...
			end
		end
	end
	return output_score
end

function M.grep(score, t)
	if score == nil then return {1000,{},} end
	local ticks = score[1]
	local new_score = {ticks,{},}
	if not t or type(t) ~= 'table' then return new_score end
	local channels = dict(t)
	local itrack = 2 while itrack <= #score do
		new_score[itrack] = {}
		for k,event in ipairs(score[itrack]) do
			local channel_index = M.Event2channelindex[event[1]]
			if channel_index then
				if channels[event[channel_index]] then
					table.insert(new_score[itrack], event)
				end
			else
				table.insert(new_score[itrack], event)
			end
		end
		itrack = itrack + 1
	end
	return new_score
end

function M.merge_scores(scores)
	local output_score = {1000,}
	local channels_so_far = {}
	local all_channels = dict{0,1,2,3,4,5,6,7,8,10,11,12,13,14,15}
	for ks,input_score in ipairs(consistentise_ticks(scores)) do -- 3.6
		local new_stats = M.score2stats(input_score)
		local new_channels = dict(new_stats['channels_total']) -- 4.2 dict
		new_channels[9] = nil  -- 2.8 cha9 must remain cha9 (in GM)
		for j,channel in ipairs(sorted_keys(new_channels)) do  -- 4.2 to catch 0
			if channels_so_far[channel] then
				local free_channels = copy(all_channels)
				for k,v in pairs(channels_so_far) do
					if v then free_channels[k] = nil end
				end
				for k,v in pairs(new_channels) do
					if v then free_channels[k] = nil end
				end
				-- consistently choose lowest avaiable, to ease testing
				local free_channel = nil
                local fcs = sorted_keys(free_channels)
				if #fcs > 0 then
                    free_channel = fcs[1]
				else
					break
				end
				for itrack = 2,#input_score do
					for k3,input_event in ipairs(input_score[itrack]) do
						local ci = M.Event2channelindex[input_event[1]]
						if ci and input_event[ci]==channel then
							input_event[ci] = free_channel
						end
					end
				end
				channels_so_far[free_channel] = true
			end
			channels_so_far[channel] = true
		end
	   	for itrack = 2,#input_score do
			output_score[#output_score+1] = input_score[itrack]
		end
	end
	return output_score
end

function M.mix_opus_tracks(input_tracks) -- 5.5
	-- must convert each track to absolute times !
	local output_score = {1000, {}}
	for ks,input_track in ipairs(input_tracks) do -- 5.8
		local input_score = M.opus2score({1000, input_track})
		for k,event in ipairs(input_score[2]) do
			table.insert(output_score[2], event)
		end
	end
	table.sort(output_score[2], function (e1,e2) return e1[2]<e2[2] end) 
	local output_opus = M.score2opus(output_score)
	return output_opus[2]
end

function M.mix_scores(input_scores)
	local output_score = {1000, {}}
	for ks,input_score in ipairs(consistentise_ticks(input_scores)) do -- 3.6
	   	for itrack = 2,#input_score do
			for k,event in ipairs(input_score[itrack]) do
				table.insert(output_score[2], event)
			end
		end
	end
	return output_score
end

function M.midi2ms_score(midi)
	return M.opus2score(M.to_millisecs(M.midi2opus(midi)))
end

function M.midi2opus(s)
	if not s then s = '' end
	--my_midi=bytearray(midi)
	if #s < 4 then return {1000,{},} end
	local i = 1
	local id = string.sub(s, i, i+3); i = i+4
	if id ~= 'MThd' then
		warn("midi2opus: midi starts with "..id.." instead of 'MThd'")
		clean_up_warnings()
		return {1000,{},}
	end
	-- h:short; H:unsigned short; i:int; I:unsigned int;
	-- l:long; L:unsigned long; f:float; d:double.
	-- [length, format, tracks_expected, ticks] = struct.unpack(
	--  '>IHHH', bytes(my_midi[4:14]))  is this 10 bytes or 14 ?
	-- NOT 2+4+4+4 grrr...   'MHhd'+4+2+2+2 !
	local length          = fourbytes2int(string.sub(s,i,i+3)); i = i+4
	local format          = twobytes2int(string.sub(s,i,i+1)); i = i+2
	local tracks_expected = twobytes2int(string.sub(s,i,i+1)); i = i+2
	local ticks           = twobytes2int(string.sub(s,i,i+1)); i = i+2
	if length ~= 6 then
		warn("midi2opus: midi header length was "..tostring(length).." instead of 6")
		clean_up_warnings()
		return {1000,{},}
	end
	local my_opus = {ticks,}
	local track_num = 1   -- 5.1
	while i < #s-8 do
		local track_type   = string.sub(s, i, i+3); i = i+4
		if track_type ~= 'MTrk' then
			warn('midi2opus: Warning: track #'..track_num..' type is '..track_type.." instead of 'MTrk'")
		end
		local track_length = fourbytes2int(string.sub(s,i,i+3)); i = i+4
		if track_length > #s then
			warn('midi2opus: track #'..track_num..' length '..track_length..' is too large')
			clean_up_warnings()
			return my_opus  -- 4.9
		end
		local my_midi_track = string.sub(s, i, i+track_length-1) -- 4.7
		i = i+track_length
		local my_track = _decode(my_midi_track) -- 4.7
		my_opus[#my_opus+1] = my_track
		track_num = track_num + 1   -- 5.1
	end
	clean_up_warnings()
	return my_opus
end

function M.midi2score(midi)
	return M.opus2score(M.midi2opus(midi))
end

function M.play_score(score)
	if not score then return end
	local midi
	if M.score_type(score) == 'opus' then
		midi = M.opus2midi(score)
	else
		midi = M.score2midi(score)
	end
	local posix  -- 6.0 in lua5.2 require posix returns the posix table
	pcall(function() posix = require 'posix' end)
	if posix and posix.fork then   -- 4.2
		local pid = posix.fork()
        if pid == 0 then
			local p = assert(io.popen("aplaymidi -", 'w'))  -- background
            p:write(midi) ; p:close() ; os.exit(0)
        end
	else
		local fn = os.tmpname()
		local fh = assert(io.open(fn, 'w'));  fh:write(midi);  fh:close()
		os.execute("aplaymidi "..fn..' ; rm '..fn..' &')
	end
end

function M.opus2midi(opus)
	if #opus < 2 then opus = {1000, {},} end
	-- tracks = copy.deepcopy(opus)
	local ntracks = #opus - 1
	local ticks = opus[1]
	local format
	if ntracks == 1 then format = 0 else format = 1 end
	local my_midi = "MThd\00\00\00\06" ..
	 int2twobytes(format) .. int2twobytes(ntracks) .. int2twobytes(ticks)
	-- struct.pack('>HHH',format,ntracks,ticks)
	--for track in tracks:
	for i = 2, #opus do
		local events = _encode(opus[i])
		-- should really do an array and then concat...
		my_midi = my_midi .. 'MTrk' .. int2fourbytes(#events) .. events
	end
	clean_up_warnings()
	return my_midi
end

function M.opus2score(opus)
	if opus == nil or #opus < 2 then return {1000,{},} end
	local ticks = opus[1]
	local score = {ticks,}
	local itrack = 2; while itrack <= #opus do
		local opus_track = opus[itrack]
		local ticks_so_far = 0
		local score_track = {}
		local chapitch2note_on_events = {}   -- 4.0
		local k; for k,opus_event in ipairs(opus_track) do
			ticks_so_far = ticks_so_far + opus_event[2]
			if opus_event[1] == 'note_off' or
			 (opus_event[1] == 'note_on' and opus_event[5] == 0) then -- 4.8
				local cha = opus_event[3]  -- 4.0
				local pitch = opus_event[4]
				local key = cha*128 + pitch  -- 4.0
				local pending_notes = chapitch2note_on_events[key] -- 5.3
				if pending_notes and #pending_notes > 0 then
					local new_e = table.remove(pending_notes, 1)
					new_e[3] = ticks_so_far - new_e[2]
					score_track[#score_track+1] = new_e
				elseif pitch > 127 then
					warn('opus2score: note_off with no note_on, bad pitch='
					 ..tostring(pitch))
				else
					warn('opus2score: note_off with no note_on cha='
					 ..tostring(cha)..' pitch='..tostring(pitch))
				end
			elseif opus_event[1] == 'note_on' then
				local cha = opus_event[3]  -- 4.0
				local pitch = opus_event[4]
				local new_e = {'note',ticks_so_far,0,cha,pitch,opus_event[5]}
				local key = cha*128 + pitch  -- 4.0
				if chapitch2note_on_events[key] then
					table.insert(chapitch2note_on_events[key], new_e)
				else
					chapitch2note_on_events[key] = {new_e,}
				end
			else
				local new_e = copy(opus_event)
				new_e[2] = ticks_so_far
				score_track[#score_track+1] = new_e
			end
		end
		-- check for unterminated notes (Oisín) -- 5.2
		for chapitch,note_on_events in pairs(chapitch2note_on_events) do
			for k,new_e in ipairs(note_on_events) do
				new_e[3] = ticks_so_far - new_e[2]
				score_track[#score_track+1] = new_e
				--warn("adding unterminated note: {'"..new_e[1].."', "..new_e[2]
				-- ..', '..new_e[3]..', '..new_e[4]..', '..new_e[5]..'}')
				warn("opus2score: note_on with no note_off cha="..new_e[4]
				 ..' pitch='..new_e[5]..'; adding note_off at end')
			end
		end
		score[#score+1] = score_track
		itrack = itrack + 1
	end
	clean_up_warnings()
	return score
end

function M.score2opus(score)
	if score == nil or #score < 2 then return {1000,{},} end
	local ticks = score[1]
	local opus = {ticks,}
	local itrack = 2; while itrack <= #score do
		local score_track = score[itrack]
		local time2events = {}
		local k,scoreevent; for k,scoreevent in ipairs(score_track) do
			local continue = false
			if scoreevent[1] == 'note' then
				local note_on_event = {'note_on',scoreevent[2],
				 scoreevent[4],scoreevent[5],scoreevent[6]}
				local note_off_event = {'note_off',scoreevent[2]+scoreevent[3],
				 scoreevent[4],scoreevent[5],scoreevent[6]}
				if time2events[note_on_event[2]] then
				   table.insert(time2events[note_on_event[2]], note_on_event)
				else
				   time2events[note_on_event[2]] = {note_on_event,}
				end
				if time2events[note_off_event[2]] then
				   table.insert(time2events[note_off_event[2]], note_off_event)
				else
				   time2events[note_off_event[2]] = {note_off_event,}
				end
				continue = true
			end
			if not continue then
				if time2events[scoreevent[2]] then
					table.insert(time2events[scoreevent[2]], scoreevent)
				else
					time2events[scoreevent[2]] = {scoreevent, }
				end
			end
		end
		local sorted_times = {}  -- list of keys
		for k,v in pairs(time2events) do
			sorted_times[#sorted_times+1] = k
		end
		table.sort(sorted_times)
		local sorted_events = {} -- once-flattened list of values sorted by key
		for k,time in ipairs(sorted_times) do
			for k2,v in ipairs(time2events[time]) do
				--sorted_events[#sorted_events+1] = v NOPE, must copy!
				sorted_events[#sorted_events+1] = {}
				for k3,v3 in ipairs(v) do
					table.insert(sorted_events[#sorted_events],v3)
				end
			end
		end
		local abs_time = 0
		for k,event in ipairs(sorted_events) do  -- abs times => delta times
			local delta_time = event[2] - abs_time
			abs_time = event[2]
			event[2] = delta_time
		end
		opus[#opus+1] = sorted_events
		itrack = itrack + 1
	end
	clean_up_warnings()
	return opus
end

function M.score_type(t)
	if t == nil or type(t) ~= 'table' or #t < 2 then return '' end
	local i = 2   -- ignore first element  -- 4.7
	while i <= #t do
		local k,event; for k,event in ipairs(t[i]) do
			if event[1] == 'note' then
				return 'score'
			elseif event[1] == 'note_on' then
				return 'opus'
			end
		end
		i = i + 1
	end
	return ''
end

function M.score2midi(score)
	return M.opus2midi(M.score2opus(score))
end

function M.score2stats(opus_or_score)
--[[ returns a table:
 bank_select (array of 2-element arrays {msb,lsb}),
 channels_by_track (table, by track, of arrays),
 channels_total (array),
 general_midi_mode (array),
 ntracks,
 nticks,
 num_notes_by_channel (table of numbers),
 patch_changes_by_track (table of tables),
 patch_changes_total (array),
 percussion (a dictionary histogram of channel-9 events),
 pitches (dict histogram of pitches on channels other than 9),
 pitch_range_by_track (table, by track, of two-member-arrays),
 pitch_range_sum (sum over tracks of the pitch_ranges)
]]
	local bank_select_msb = -1
	local bank_select_lsb = -1
	local bank_select = {}
	local channels_by_track = {}
	local channels_total    = {}
	local general_midi_mode = {}
	local num_notes_by_channel = {} -- 5.7
	local patches_used_by_track  = {}
	local patches_used_total     = {}
	local patch_changes_by_track = {}
	local patch_changes_total    = {}
	local percussion = {} -- histogram of channel 9 "pitches"
	local pitches    = {} -- histogram of pitch-occurrences channels 0-8,10-15
	local pitch_range_sum = 0   -- u pitch-ranges of each track
	local pitch_range_by_track = {}
	local is_a_score = true
	if opus_or_score == nil then
		return {bank_select={}, channels_by_track={}, channels_total={},
		 general_midi_mode={}, ntracks=0, nticks=0,
		 num_notes_by_channel={},
		 patch_changes_by_track={}, patch_changes_total={},
		 percussion={}, pitches={}, pitch_range_by_track={},
		 ticks_per_quarter=0, pitch_range_sum=0
		}
	end
	local ticks_per_quarter = opus_or_score[1]
	local nticks = 0 -- 4.7
	for i = 2,#opus_or_score do  -- ignore first element, which is ticks
		local highest_pitch = 0  -- 4.7
		local lowest_pitch = 128 -- 4.7
		local channels_this_track = {}      -- 4.7
		local patch_changes_this_track = {} -- 4.7
		for k,event in ipairs(opus_or_score[i]) do
			if event[1] == 'note' then
				num_notes_by_channel[event[4]] = (num_notes_by_channel[event[4]] or 0) + 1
				if event[4] == 9 then
					percussion[event[5]] = (percussion[event[5]] or 0) + 1
				else
					pitches[event[5]]    = (pitches[event[5]] or 0) + 1
					if event[5] > highest_pitch then
						highest_pitch = event[5]
					end
					if event[5] < lowest_pitch then
						lowest_pitch = event[5]
					end
				end
				channels_this_track[event[4]] = true
				channels_total[event[4]] = true
				local finish_time = event[2] + event[3] -- 4.7
				if finish_time > nticks then
					nticks = finish_time
				end
			elseif event[1] == 'note_on' then
				is_a_score = false   -- 4.6
				num_notes_by_channel[event[3]] = (num_notes_by_channel[event[3]] or 0) + 1
				if event[3] == 9 then
					percussion[event[4]] = (percussion[event[4]] or 0) + 1
				else
					pitches[event[4]]    = (pitches[event[4]] or 0) + 1
					if event[4] > highest_pitch then
						highest_pitch = event[4]
					end
					if event[4] < lowest_pitch then
						lowest_pitch = event[4]
					end
				end
				channels_this_track[event[3]] = true
				channels_total[event[3]] = true
			elseif event[1] == 'note_off' then
				local finish_time = event[2] -- 4.7
				if finish_time > nticks then
					nticks = finish_time
				end
			elseif event[1] == 'patch_change' then
				patch_changes_this_track[event[3]] = event[4]
				patch_changes_total[event[4]] = true
			elseif event[1] == 'control_change' then
				if event[4] == 0 then  -- bank select MSB
					bank_select_msb = event[5]
				elseif event[4] == 32 then  -- bank select LSB
					bank_select_lsb = event[5]
				end
				if bank_select_msb >= 0 and bank_select_lsb >= 0 then
					table.insert(bank_select,{bank_select_msb,bank_select_lsb})
					bank_select_msb = -1
					bank_select_lsb = -1
				end
			elseif event[1] == 'sysex_f0' then
				if sysex2midimode[event[3]] then
				table.insert(general_midi_mode,sysex2midimode[event[3]]) -- 5.0
				end
			end
			if is_a_score then
				if event[2] > nticks then
					nticks = event[2]
				end
			else
				nticks = nticks + event[2]
			end
		end
		if lowest_pitch == 128 then
			lowest_pitch = 0
		end
		table.insert(channels_by_track, sorted_keys(channels_this_track))
		table.insert(patch_changes_by_track, patch_changes_this_track) -- 4.2
		table.insert(pitch_range_by_track, {lowest_pitch,highest_pitch})
		pitch_range_sum = pitch_range_sum + highest_pitch - lowest_pitch
		i = i + 1
	end

	return {
		bank_select=bank_select,
		channels_by_track=channels_by_track,
		channels_total=sorted_keys(channels_total),
		general_midi_mode=general_midi_mode,
		ntracks=#opus_or_score-1,
		nticks=nticks,
		num_notes_by_channel=num_notes_by_channel,
		patch_changes_by_track=patch_changes_by_track,
		patch_changes_total=sorted_keys(patch_changes_total),
		percussion=percussion,
		pitches=pitches,
		pitch_range_by_track=pitch_range_by_track,
		pitch_range_sum=pitch_range_sum,
		ticks_per_quarter=ticks_per_quarter
	}
end

function M.segment(...)
	local args = {...}  -- 3.8
	local score, start, endt, tracks = ...
	if #args == 1 and type(args[1][1]) == 'table' then
		score = args[1][1]
		start = args[1]['start_time'] -- 4.1
		endt = args[1]['end_time']    -- 4.1
		tracks = args[1]['tracks']
	end
	if not score == nil or type(score) ~= 'table' or #score < 2 then
		return {1000, {},}
	end
	if not start then start = 0 end -- 4.1
	if not endt  then endt  = 1000000000 end
	if not tracks then tracks = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15} end
	local new_score = {score[1],}
	local my_type = M.score_type(score)
	if my_type == '' then
		return new_score
	end
	if my_type == 'opus' then
		-- more difficult (disconnecting note_on's from their note_off's)...
		warn("segment: opus format is not supported\n")
		clean_up_warnings()
		return new_score
	end
	tracks = dict(tracks)  -- convert list to lookup
	for i = 2,#score do   -- ignore ticks; we count in ticks anyway
		if tracks[i-1] then
			local new_track = {}
			local channel2cc_num  = {} -- recentest controlchange before start
			local channel2cc_val  = {}
			local channel2cc_time = {}
			local channel2patch_num = {} -- recentest patchchange before start
			local channel2patch_time = {}
			local set_tempo_num = 500000 -- recentest tempochange 6.3
			local set_tempo_time = 0
			local earliest_note_time = endt
			for k,event in ipairs(score[i]) do
				if event[1] == 'control_change' then  -- 6.5
					local cc_time = channel2cc_time[event[3]] or 0
					if event[2]<=start and event[2]>=cc_time then
						channel2cc_num[event[3]]  = event[4]
						channel2cc_val[event[3]]  = event[5]
						channel2cc_time[event[3]] = event[2]
					end
				elseif event[1] == 'patch_change' then
					local patch_time = channel2patch_time[event[3]] or 0 -- 4.7
					if event[2]<=start and event[2]>=patch_time then  -- 2.0
						channel2patch_num[event[3]]  = event[4]
						channel2patch_time[event[3]] = event[2]
					end
				elseif event[1] == 'set_tempo' then   -- 6.4 <=start not <start
					if (event[2]<=start) and (event[2]>=set_tempo_time) then
						set_tempo_num  = event[3]
						set_tempo_time = event[2]
					end
				end
				if event[2] >= start and event[2] <= endt then
					new_track[#new_track+1]= event
					if event[1] == 'note' and event[2]<earliest_note_time then
						earliest_note_time = event[2]
					end
				end
			end
			if #new_track > 0 then
				new_track[#new_track+1] = ({'set_tempo', start, set_tempo_num})
				for k,c in ipairs(sorted_keys(channel2patch_num)) do -- 4.3
					new_track[#new_track+1] =
					 ({'patch_change', start, c, channel2patch_num[c]})
				end
				for k,c in ipairs(sorted_keys(channel2cc_num)) do -- 6.5
					new_track[#new_track+1] = ({'control_change', start, c,
					  channel2cc_num[c],  channel2cc_val[c]})
				end
				new_score[#new_score+1] = (new_track)
			end
		end
	end
	clean_up_warnings()
	return new_score
end

function M.timeshift(...)
	local args = {...}  -- 3.8
	local score, shift, start_time, from_time, tracks_array = ...
	if #args == 1 and type(args[1][1]) == 'table' then
		score = args[1][1]
		shift = args[1]['shift']
		start_time = args[1]['start_time']
		from_time = args[1]['from_time']
		tracks_array = args[1]['tracks']
	end
	if score == nil or #score < 2 then return {1000, {},} end
	if from_time == nil then from_time = 0 end
	if not tracks_array then
		tracks_array = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}
	end
	local new_score = {score[1],}
	local my_type = M.score_type(score)
	if my_type == '' then return new_score end
	if my_type == 'opus' then
		warn("timeshift: opus format is not supported\n")
		clean_up_warnings()
		return new_score
	end
	if shift ~= nil and start_time ~= nil then
		warn("timeshift: shift and start_time specified: ignoring shift\n")
		shift = nil
	end
	if shift == nil then
		if start_time == nil or start_time < 0 then
			start_time = 0
		end
		-- shift = start_time - from_time
	end

	local tracks = dict(tracks_array)  -- convert list to lookup
	local earliest = 1000000000
	if start_time ~= nil or shift < 0 then -- find the earliest event
		for i = 2,#score do   -- ignore first element (ticks)
			if tracks[i-1] then
				for k,event in ipairs(score[i]) do
					local continue2 = false
					if event[2] < from_time then
						-- just inspect the to_be_shifted events
						continue2 = true
					end
					if not continue2 then
						if event[2] < earliest then
							earliest = event[2]
						end
					end
				end
			end
		end
	end
	if earliest > 999999999 then
		earliest = 0
	end
	if shift == nil then
		shift = start_time - earliest
	elseif (earliest + shift) < 0 then
		start_time = 0
		shift = 0 - earliest
	end

	local i = 2   -- ignore first element (ticks) -- 4.7
	while i <= #score do
		if not tracks[i-1] then
			new_score[#new_score+1] = deepcopy(score[i])
			i = i + 1
		else
			local new_track = {} -- 4.7
			for k,event in ipairs(score[i]) do
				local continue = false
				local new_event = copy(event) -- 4.7
				if new_event[2] >= from_time then
					-- 4.1 must not rightshift set_tempo
					if new_event[1] ~= 'set_tempo' or shift<0 then
						new_event[2] = new_event[2] + shift
					end
				elseif (shift < 0) and (new_event[2] >= (from_time+shift)) then
					continue = true
				end
				if not continue then
					new_track[#new_track+1] = new_event
				end
			end
			if #new_track > 0 then
				new_score[#new_score+1] = new_track
			end
			i = i + 1
		end
	end
	clean_up_warnings()
	return new_score
end

function M.to_millisecs(old_opus)   -- 6.7
	if old_opus == nil then return {1000,{},}; end
	local old_tpq  = old_opus[1]
	local new_opus = {1000,}
	-- 6.7 first go through building a dict of set_tempos by absolute-tick
	local ticks2tempo = {}
	local itrack = 2
	while itrack <= #old_opus do
		local ticks_so_far = 0
		local k; for k,old_event in ipairs(old_opus[itrack]) do
			if old_event[1] == 'note' then
				warn('to_millisecs needs an opus, not a score')
				clean_up_warnings()
				return {1000,{},}
			end
			ticks_so_far = ticks_so_far + old_event[2]
			if old_event[1] == 'set_tempo' then
				ticks2tempo[ticks_so_far] = old_event[3]
			end
		end
		itrack = itrack + 1
	end
	--  then get the sorted-array of their keys
	local tempo_ticks = sorted_keys(ticks2tempo)
	--  then go through converting to millisec, testing if the next
	--  set_tempo lies before the next track-event, and using it if so.
	local itrack = 2
	while itrack <= #old_opus do
		local ms_per_old_tick = 500.0 / old_tpq -- will be rounded later 6.3
		local i_tempo_ticks = 1
		local ticks_so_far = 0
		local ms_so_far = 0.0
		local previous_ms_so_far = 0.0
		local new_track = {{'set_tempo',0,1000000},}  -- new "crochet" is 1 sec
		local k; for k,old_event in ipairs(old_opus[itrack]) do
			-- detect if ticks2tempo has something before this event
			-- If ticks2tempo is at the same time, don't handle it yet.
			local event_delta_ticks = old_event[2]
			if i_tempo_ticks <= #tempo_ticks and
			  tempo_ticks[i_tempo_ticks] < (ticks_so_far + old_event[2]) then
				local delta_ticks = tempo_ticks[i_tempo_ticks] - ticks_so_far
				ms_so_far = ms_so_far + (ms_per_old_tick * delta_ticks)
				ticks_so_far = tempo_ticks[i_tempo_ticks]
				ms_per_old_tick = ticks2tempo[ticks_so_far] / (1000.0*old_tpq)
				i_tempo_ticks = i_tempo_ticks + 1
				event_delta_ticks = event_delta_ticks - delta_ticks
			end  -- now handle the new event
			local new_event = copy(old_event) -- 4.7
			ms_so_far = ms_so_far + (ms_per_old_tick * old_event[2])  -- NO!
			new_event[2] = math.floor(0.5 + ms_so_far - previous_ms_so_far)
			if old_event[1] ~= 'set_tempo' then -- set_tempos are already known
				previous_ms_so_far = ms_so_far
				new_track[#new_track+1] = new_event
			end
			ticks_so_far = ticks_so_far + event_delta_ticks
		end
		new_opus[#new_opus+1] = new_track
		itrack = itrack + 1
	end
	clean_up_warnings()
	return new_opus
end

return M

-- http://lua-users.org/wiki/ModuleDefinition
-- http://lua-users.org/wiki/LuaModuleFunctionCritiqued
--[=[

=pod

=head1 NAME

MIDI.lua - Reading, writing and manipulating MIDI data

=head1 SYNOPSIS

 local MIDI = require 'MIDI'

 local my_score = {
    96,  -- ticks per beat
    {    -- first track
        {'patch_change', 0, 1, 8},
        {'note', 5, 96, 1, 25, 96},
        {'note', 101, 96, 1, 29, 96},
    },  -- end of first track
 }

 -- Going through a score within a Lua program...
 channels = {[2]=true, [3]=true, [5]=true, [8]=true, [13]=true}
 for itrack = 2,#my_score do  -- skip 1st element, which is ticks
    for k,event in ipairs(my_score[itrack]) do
       if event[1] == 'note' then
          -- for example, do something to all notes
       end
       -- to work on events in only particular channels...
       channelindex = MIDI.Event2channelindex[event[1]]
       if channelindex and channels[event[channelindex]] then
          -- do something to channels 2,3,5,8 and 13
       end
    end
 end

 local midifile = assert(io.open('f.mid','w'))
 midifile:write(MIDI.score2midi(my_score))
 midifile:close()

=head1 DESCRIPTION

This module offers functions:  concatenate_scores(), grep(),
merge_scores(), mix_scores(), midi2opus(), midi2score(), opus2midi(),
opus2score(), play_score(), score2midi(), score2opus(), score2stats(),
score_type(), segment(), timeshift() and to_millisecs(),
where "midi" means the MIDI-file bytes (as can be put in a .mid file,
or piped into aplaymidi), and "opus" and "score" are list-structures
as inspired by Sean Burke's MIDI-Perl CPAN module.

The "opus" is a direct translation of the midi-file-events, where
the times are delta-times, in ticks, since the previous event:

 {'note_on',  dtime, channel, note, velocity}       -- in an "opus"
 {'note_off', dtime, channel, note, velocity}       -- in an "opus"

The "score" is more human-centric; it uses absolute times, and
combines the separate note_on and note_off events into one "note"
event, with a duration:

 {'note', start_time, duration, channel, note, velocity} -- in a "score"

MIDI.lua is a call-compatible translation into Lua of the Python module
http://www.pjb.com.au/midi/free/MIDI.py ;
see http://www.pjb.com.au/midi/MIDI.html

=head1 FUNCTIONS

=over 3

=item I<concatenate_scores> (array_of_scores)

Concatenates an array of scores into one score.
If the scores differ in their "ticks" parameter,
they will all get converted to millisecond-tick format.

=item I<grep> (score, channels)

Returns a "score" containing only the channels specified.
(It also works on an "opus", but because of the
incremental times the result will usually be useless.)
The second parameter is an array of the wanted channel numbers,
for example:

 channels = {0, 4,}

=item I<merge_scores> (array_of_scores)

Merges an array of scores into one score.  A merged score comprises
all of the tracks from all of the input scores; un-merging is possible
by selecting just some of the tracks.
If the scores differ in their "ticks" parameter,
they will all get converted to millisecond-tick format.
merge_scores attempts to resolve channel-conflicts,
but there are of course only 15 available channels...

=item I<mix_opus_tracks> (tracks)

Mixes an array of opus tracks into one track.
A mixed track cannot be un-mixed.
It is assumed that the tracks share the same I<ticks> parameter
and the same tempo.
Mixing score-tracks is trivial (just insert all the events into one array).
Mixing opus-tracks is only slightly harder,
but it's common enough that a dedicated function is useful.

=item I<mix_scores> (array_of_scores)

Mixes an array of scores into one one-track score.
A mixed score cannot be un-mixed.
Hopefully the scores have no undesirable channel conflicts between them...
If the scores differ in their "ticks" parameter,
they will all get converted to millisecond-tick format.


=item I<midi2ms_score> (midi_in_string_form)

Translates MIDI into a "score" with one beat per second and one
tick per millisecond, using midi2opus() then to_millisecs()
then opus2score()

=item I<midi2opus> (midi_in_string_form)

Translates MIDI into an "opus".  For a description of the
"opus" format, see opus2midi()

=item I<midi2score> (midi_in_string_form)

Translates MIDI into a "score", using midi2opus() then opus2score()


=item I<opus2midi> (an_opus)

The argument is an array: the first item in the list is the "ticks"
parameter, the others are the tracks. Each track is an array of
midi-events, and each event is itself an array; see EVENTS below.
opus2midi() returns a string of the MIDI, which can then be
written to a .mid file, or to stdout.

 local MIDI = require 'MIDI'
 my_opus = {
    96, -- MIDI-ticks per beat
    {   -- first track:
        {'patch_change', 0, 1, 8},   -- and these are the events...
        {'set_tempo', 0, 750000},    -- microseconds per beat
        {'note_on', 5, 1, 25, 96},
        {'note_off', 96, 1, 25, 0},
        {'note_on', 0, 1, 29, 96},
        {'note_off', 96, 1, 29, 0},
    },  -- end of first track
 }
 local my_midi = MIDI.opus2midi(my_opus)
 io.write(my_midi)  -- can be saved in o.mid or piped into "aplaymidi -"

=item I<opus2score> (an_opus)

For a description of the "opus" and "score" formats,
see opus2midi() and score2opus().

The score track is returned sorted by the end-times of the notes,
so if you need it sorted by their start-times you have to do that yourself:

  table.sort(score[itrack], function (e1,e2) return e1[2]<e2[2] end)

=item I<play_score> (opus_or_score)

Converts the "score" to midi, and feeds it into 'aplaymidi -'.
If Lua's I<posix> module is installed, the aplaymidi process will
be run in the background.

=item I<score_type> (opus_or_score)

Returns a string, either 'opus' or 'score' or ''

=item I<score2midi> (a_score)

Translates a "score" into MIDI, using score2opus() then opus2midi()

=item I<score2opus> (a_score)

The argument is an array: the first item in the list is the "ticks"
parameter, the others are the tracks. Each track is an array
of score-events, and each event is itself an array.
score2opus() returns an array specifying the equivalent "opus".
A score-event is similar to an opus-event (see above),
except that in a score:

1) all times are expressed as an absolute number of ticks
    from the track's start time

2) the pairs of 'note_on' and 'note_off' events in an "opus"
    are abstracted into a single 'note' event in a "score"

 {'note', start_time, duration, channel, pitch, velocity}

 my_score = {
    96,
    {   -- first track
        {'patch_change', 0, 1, 8},
        {'note', 5, 96, 1, 25, 96},
        {'note', 101, 96, 1, 29, 96},
    },  -- end of first track
 }
 my_opus = score2opus(my_score)

=item I<score2stats> (opus_or_score)

Returns a table of some basic stats about the score, like:

 bank_select (array of 2-element arrays {msb,lsb}),
 channels_by_track (table, by track, of arrays),
 channels_total (array),
 general_midi_mode (array),
 ntracks,
 nticks,
 num_notes_by_channel (table of numbers)
 patch_changes_by_track (table of arrays),
 patch_changes_total (array),
 percussion (a dictionary histogram of channel-9 events),
 pitches (dict histogram of pitches on channels other than 9),
 pitch_range_by_track (table, by track, of two-member-arrays),
 pitch_range_sum (sum over tracks of the pitch_ranges)

=item I<segment> (score, start_time, end_time, tracks)

=item I<segment> {score, start_time=100, end_time=2000, tracks={3,4,5}}

Returns a "score" which is a segment of the one supplied
as the argument, beginning at "start_time" ticks and ending
at "end_time" ticks (or at the end if "end_time" is not supplied).
If the array "tracks" is specified, only those tracks will be returned.

=item I<timeshift> (score, shift, start_time, from_time, tracks)

=item I<timeshift> {score, shift=50, start_time=nil, from_time=2000, tracks={2,3}}

Returns a "score" shifted in time by "shift" ticks, or shifted
so that the first event starts at "start_time" ticks.

If "from_time" is specified, only those events in the score
that begin after it are shifted. If "start_time" is less than
"from_time" (or "shift" is negative), then the intermediate
notes are deleted, though patch-change events are preserved.

If "tracks" are specified, then only those tracks (0 to 15) get shifted.
"tracks" should be an array.

It is deprecated to specify both "shift" and "start_time".
If this does happen, timeshift() will print a warning to
stderr and ignore the "shift" argument.

If "shift" is negative and sufficiently large that it would
leave some event with a negative tick-value, then the score
is shifted so that the first event occurs at time 0. This
also occurs if "start_time" is negative, and is also the
default if neither "shift" nor "start_time" are specified.

=item I<to_millisecs> (an_opus)

Recallibrates all the times in an "opus" to use one beat
per second and one tick per millisecond.  This makes it
hard to retrieve any information about beats or barlines,
but it does make it easy to mix different scores together.

=back

=head1 EVENTS

The "opus" is a direct translation of the midi-file-events, where
the times are delta-times, in ticks, since the previous event.

 {'note_on',  dtime, channel, note, velocity}       -- in an "opus"
 {'note_off', dtime, channel, note, velocity}       -- in an "opus"

The "score" is more human-centric; it uses absolute times, and
combines the separate note_on and note_off events into one "note"
event, with a duration:

 {'note', start_time, duration, channel, note, velocity} -- in a "score"

Events (in an "opus" structure):

 {'note_off', dtime, channel, note, velocity}       -- in an "opus"
 {'note_on',  dtime, channel, note, velocity}       -- in an "opus"
 {'key_after_touch', dtime, channel, note, velocity}
 {'control_change', dtime, channel, controller(0-127), value(0-127)}
 {'patch_change', dtime, channel, patch}
 {'channel_after_touch', dtime, channel, velocity}
 {'pitch_wheel_change', dtime, channel, pitch_wheel}
 {'text_event', dtime, text}
 {'copyright_text_event', dtime, text}
 {'track_name', dtime, text}
 {'instrument_name', dtime, text}
 {'lyric', dtime, text}
 {'marker', dtime, text}
 {'cue_point', dtime, text}
 {'text_event_08', dtime, text}
 {'text_event_09', dtime, text}
 {'text_event_0a', dtime, text}
 {'text_event_0b', dtime, text}
 {'text_event_0c', dtime, text}
 {'text_event_0d', dtime, text}
 {'text_event_0e', dtime, text}
 {'text_event_0f', dtime, text}
 {'end_track', dtime}
 {'set_tempo', dtime, tempo}
 {'smpte_offset', dtime, hr, mn, se, fr, ff}
 {'time_signature', dtime, nn, dd, cc, bb}
 {'key_signature', dtime, sf, mi}
 {'sequencer_specific', dtime, raw}
 {'raw_meta_event', dtime, command(0-255), raw}
 {'sysex_f0', dtime, raw}
 {'sysex_f7', dtime, raw}
 {'song_position', dtime, song_pos}
 {'song_select', dtime, song_number}
 {'tune_request', dtime}

=head1 DATA TYPES

 channel = a value 0 to 15
 controller = 0 to 127 (see http://www.pjb.com.au/muscript/gm.html#cc)
 dtime = time measured in "ticks", 0 to 268435455
 velocity = a value 0 (soft) to 127 (loud)
 note = a value 0 to 127  (middle-C is 60)
 patch = 0 to 127 (see http://www.pjb.com.au/muscript/gm.html )
 pitch_wheel = a value -8192 to 8191 (0x1FFF)
 raw = 0 or more bytes of binary data
 sequence_number = a value 0 to 65,535 (0xFFFF)
 song_pos = a value 0 to 16,383 (0x3FFF)
 song_number = a value 0 to 127
 tempo = microseconds per crochet (quarter-note), 0 to 16777215
 text = a string of 0 or more bytes of of ASCII text
 ticks = the number of ticks per crochet (quarter-note)

In I<sysex_f0> events, the I<raw> data must not start with a \xF0
byte, since this gets added automatically;
but it must end with an explicit \xF7 byte!
In the very unlikely case that you ever need to split I<sysex> data
into one I<sysex_f0> followed by one or more I<sysex_f7>s, then
only the last of those I<sysex_f7> events must end with the explicit \xF7
byte (again, the I<raw> data of individual I<sysex_f7> events
must not start with any \xF7 byte, since this gets added automatically).

=head1 PUBLIC-ACCESS TABLES

=over 3

=item I<Number2patch>

In this table the index is the patch-number (0 to 127),
and the value is its corresponding General-MIDI Patch
(on Channels other than 9).
See: http://www.pjb.com.au/muscript/gm.html#patch

=item I<Notenum2percussion>

In this table the index is the note-number (35 to 81),
and the value is its corresponding General-MIDI Percussion instrument
(on Channel 9).  See: http://www.pjb.com.au/muscript/gm.html#perc

=item I<Event2channelindex>

In this table the index is the event-name (see EVENTS),
and the value is the position within the event-array
at which the I<Channel-number> occurs.
It is very useful for manipulating particular channels
within a score (see SYNOPSIS)

=back

=head1 DOWNLOAD

This module is available as a LuaRock in
http://luarocks.org/modules/peterbillam
so you should be able to install it with the command:
B<sudo luarocks install midi>

The source is in
http://www.pjb.com.au/comp/lua/MIDI.lua
for you to install by hand in your LUA_PATH

The test script used during development is
http://www.pjb.com.au/comp/lua/test_mi.lua
which requires the DataDumper module.

You should be able to install the luaposix module with:
B<sudo luarocks install luaposix>

=head1 AUTHOR

Peter J Billam, http://www.pjb.com.au/comp/contact.html

=head1 SEE ALSO

 http://www.pjb.com.au/
 http://www.pjb.com.au/comp/index.html#lua
 http://www.pjb.com.au/comp/lua/MIDI.html
 http://www.pjb.com.au/midi/MIDI.html
 http://www.pjb.com.au/muscript/gm.html

=cut

]=]