smallpond

smallpond.lua (31272B)

---

 -- parse
 local em = 8
 
 local Glyph = {
 	["noteheadWhole"] = 0xE0A2,
 	["noteheadHalf"] = 0xE0A3,
 	["noteheadBlack"] = 0xE0A4,
 	["flag8thDown"] = 0xE241,
 	["flag8thUp"] = 0xE240,
 	["accidentalFlat"] = 0xE260,
 	["accidentalNatural"] = 0xE261,
 	["accidentalSharp"] = 0xE262,
 	["gClef"] = 0xE050,
 	["fClef"] = 0xE062,
 }
 
 local Clef = {
 	["treble"] = {
 		glyph = Glyph.gClef,
 		yoff = 3*em,
 		defoctave = 4,
 		place = function(char, octave)
 			local defoctave = 4 -- TODO: how do we use the value above?
 			local NOTES = "abcdefg"
 			local s, _ = string.find(NOTES, char)
 			return (octave - defoctave) * 7 + 2 - s
 		end
 	},
 	["bass"] = {
 		glyph = Glyph.fClef,
 		yoff = em,
 		defoctave = 3,
 		place = function(char, octave)
 			local defoctave = 3 -- TODO: how do we use the value above?
 			local NOTES = "abcdefg"
 			local s, _ = string.find(NOTES, char)
 			return (octave - defoctave) * 7 + 4 - s
 		end
 	}
 }
 
 local numerals = {
 	['0'] = 0xE080,
 	['1'] = 0xE081,
 	['2'] = 0xE082,
 	['3'] = 0xE083,
 	['4'] = 0xE084,
 	['5'] = 0xE085,
 	['6'] = 0xE086,
 	['7'] = 0xE087,
 	['8'] = 0xE088,
 	['9'] = 0xE089
 }
 
 voice_commands = {
 	staff = {
 		parse = function(text, start)
 			-- move past "\staff "
 			start = start + 7
 			local text = string.match(text, "(%a+)", start)
 			return 7 + #text, {command="changestaff", name=text}
 		end
 	},
 	clef = {
 		parse = function(text, start)
 			-- move past "\clef "
 			start = start + 6
 			if string.match(text, "^treble", start) then
 				return #"\\clef treble", {command="changeclef", kind="treble"}
 			elseif string.match(text, "^bass", start) then
 				return #"\\clef bass", {command="changeclef", kind="bass"}
 			else
 				error(string.format("unknown clef %s", string.sub(text, start)))
 			end
 		end
 	},
 	time = {
 		parse = function(text, start)
 			-- move past "\time "
 			start = start + 6
 			local num, denom = string.match(text, "^(%d+)/(%d+)", start)
 			if num == nil or denom == nil then
 				error(string.format("bad time signature format"))
 			end
 			return #"\\time " + #num + #denom + 1, {command="changetime", num=num, denom=denom}
 		end
 	}
 }
 
 local voices = {}
 local stafforder = {}
 
 local commands = {
 	voice = function (text, start)
 		local parsenotecolumn = function(text, start)
 			local s, e, flags, count, dot, beam = string.find(text, "^([v^]?)(%d*)(%.?)([%[%]]?)", start)
 			local out = {}
 
 			if string.find(flags, "v", 1, true) then
 				out.stemdir = 1
 			elseif string.find(flags, "^", 1, true) then
 				out.stemdir = -1
 			end
 
 			if beam == '[' then
 				out.beam = 1
 			elseif beam == ']' then
 				out.beam = -1
 			end
 
 			-- make sure that count is a power of 2
 			if #count ~= 0 then
 				assert(math.ceil(math.log(count)/math.log(2)) == math.floor(math.log(count)/math.log(2)), "note count is not a power of 2")
 			end
 			out.count = tonumber(count)
 			out.dot = #dot == 1
 
 			return start + e - s + 1, out
 		end
 		local parsenote = function(text, start)
 			-- TODO: should we be more strict about accidentals and stem orientations on rests?
 			local s, e, time, note, acc, shift, tie = string.find(text, "^(%d*%.?%d*)([abcdefgs])([fns]?)([,']*)(~?)", start)
 			if note then
 				local out
 				if note == 's' then
 					out = {command='srest'}
 				else
 					out = {command="note", time=tonumber(time), note=note, acc=acc}
 				end
 
 				local _, down = string.gsub(shift, ',', '')
 				local _, up = string.gsub(shift, "'", '')
 				out.shift = up - down
 
 				if #tie > 0 then out.tie = true end
 				return start + e - s + 1, out
 			end
 
 			error("unknown token")
 		end
 		local i = start
 
 		voice = {}
 		while true do
 			::start::
 			i = i + #(string.match(text, "^%s*", i) or "")
 			if i >= #text then return i end
 			local cmd = string.match(text, "^\\(%a+)", i)
 			if cmd == "end" then
 				i = i + 4
 				break
 			end
 			if cmd then
 				local size, data = voice_commands[cmd].parse(text, i)
 				i = i + size
 				table.insert(voice, data)
 				goto start
 			end
 
 			-- barline
 			local s, e = string.find(text, "^|", i)
 			if s then
 				i = i + e - s + 1
 				table.insert(voice, {command="barline"})
 				goto start
 			end
 
 			-- grouping (grace or tuplet)
 			local s, e, f = string.find(text, "^(%g*)%b{}", i)
 			if s then
 				local notes = {}
 				local grace = false
 
 				if string.find(f, 'g', 1, true) then
 					grace = true
 				end
 
 				local tn, td = string.match(f, 't(%d+)/(%d+)', 1)
 				assert(not not tn == not not td)
 				if not tn then
 					tn = 1
 					td = 1
 				end
 
 				-- TODO: deal with notegroups
 				i = i + #f + 1
 				while i <= e - 2 do
 					i = i + #(string.match(text, "^%s*", i) or "")
 					if i >= #text then return i end
 					i, note = parsenote(text, i)
 					i, col = parsenotecolumn(text, i)
 					table.insert(voice, {command="newnotegroup", count=col.count, stemdir=col.stemdir, beam=col.beam, dot=col.dot, tuplet=Q.new(td)/tn, grace=grace, notes={[1] = note}})
 				end
 				i = e + 1
 				goto start
 			end
 
 			-- note column
 			local s, e = string.find(text, "^%b<>", i)
 			if s then
 				i = i + 1
 				local group = {command="newnotegroup", notes = {}}
 				while i <= e - 1 do
 					i = i + #(string.match(text, "^%s*", i) or "")
 					if i >= #text then return i end
 					i, out = parsenote(text, i)
 					table.insert(group.notes, out)
 				end
 				i = e + 1
 				i, out = parsenotecolumn(text, i)
 				group.count = out.count
 				group.stemdir = out.stemdir
 				group.beam = out.beam
 				group.dot = out.dot
 				table.insert(voice, group)
 				goto start
 			end
 
 			i, note = parsenote(text, i)
 			i, col = parsenotecolumn(text, i)
 
 			if note.command == 'srest' then
 				table.insert(voice, {command='srest', count=col.count})
 			else
 				table.insert(voice, {command="newnotegroup", count=col.count, stemdir=col.stemdir, beam=col.beam, dot=col.dot, notes={[1] = note}})
 			end
 		end
 
 		voices[#voices + 1] = voice
 		return i
 	end,
 	layout = function (text, start)
 		local i = start
 		while true do
 			::start::
 			i = i + #(string.match(text, "^%s*", i) or "")
 			if i >= #text then return i end
 			local cmd = string.match(text, "^\\(%a+)", i)
 			if cmd == 'end' then
 				i = i + 4
 				break
 			end
 
 			if cmd == 'staff' then
 				i = i + 7
 				local name = string.match(text, '^(%a+)', i)
 				table.insert(stafforder, name)
 				i = i + #name
 				goto start
 			end
 
 
 			error('unknown token')
 		end
 
 		return i
 	end
 }
 
 function parse(text)
 	local i = 1
 
 	while true do
 		i = i + #(string.match(text, "^%s*", i) or "")
 		if i >= #text then return nil end
 		local cmd = string.match(text, "^\\(%a+)", i)
 		if cmd then
 			i = i + #cmd + 1
 			i = commands[cmd](text, i)
 		end
 	end
 end
 
 f = assert(io.open("score.sp"))
 parse(f:read("*a"))
 
 local time = Q.new(0)
 local octave = 0
 local clef = Clef.treble
 local lastnote = nil
 local staff1 = {}
 local points = {}
 local pointindices = {}
 
 function point(t)
 	for k, v in pairs(pointindices) do
 		if t == k then
 			return v
 		end
 	end
 
 	table.insert(points, t)
 	pointindices[t] = #points
 	return pointindices[t]
 end
 
 local timings = {}
 local curname
 local inbeam = false
 local beam
 local beams = {}
 local beamednotes
 local unterminated_ties = {}
 local ties = {}
 local lastbarline
 -- first-order placement
 local dispatch1 = {
 	newnotegroup = function(data)
 		local heads = {}
 		local realbeamcount = math.log(data.count) / math.log(2) - 2
 		local beamcount
 		if inbeam then
 			beamcount = math.min(realbeamcount, beamednotes[#beamednotes].realcount)
 		else
 			beamcount = realbeamcount
 		end
 		local maxtime, mintime
 		local lasthead
 		local flipped = false
 		for _, note in ipairs(data.notes) do
 			octave = octave - note.shift
 			local head = {acc=note.acc, y=clef.place(note.note, octave), time=note.time, flip}
 
 			-- avoid overlapping heads by "flipping" head across stem
 			if lasthead and math.abs(head.y - lasthead.y) == 1 then
 				flipped = true
 				if head.y % 2 == 1 then
 					head.flip = true
 				else
 					lasthead.flip = true
 				end
 			end
 			lasthead = head
 			table.insert(heads, head)
 			if note.time and not maxtime then maxtime = note.time end
 			if maxtime and note.time and note.time > maxtime then maxtime = note.time end
 
 			if note.time and not mintime then mintime = note.time end
 			if maxtime and note.time and note.time < maxtime then maxtime = note.time end
 
 			if unterminated_ties[curname] and unterminated_ties[curname].y == head.y then
 				table.insert(ties, {staff=curname, start=unterminated_ties[curname], stop=head})
 				unterminated_ties[curname] = nil
 			end
 
 			if note.tie then
 				assert(unterminated_ties[curname] == nil)
 				unterminated_ties[curname] = head
 			end
 		end
 
 
 		local index = point(time)
 		if flipped and maxtime then timings[index].flipped = true end
 		if not timings[index].mintime then
 			timings[index].mintime = mintime
 		else
 			timings[index].mintime = math.min(mintime, timings[index].mintime)
 		end
 
 		local incr = Q.new(1) / Q.new(data.count)
 		if data.dot then
 			incr = 3*incr / 2
 		end
 		if data.tuplet then incr = incr * data.tuplet end
 
 		local stemlen
 		if data.grace then
 			stemlen = 2.5
 		else
 			stemlen = 3.5
 		end
 		local note = {kind="notecolumn", stemdir=data.stemdir, stemlen=stemlen, dot=data.dot, grace=data.grace, count=incr, length=data.count, time=maxtime, heads=heads, staff=curname}
 		if data.beam == 1 then
 			assert(not inbeam)
 			beamednotes = {}
 			table.insert(beams, beamednotes)
 			table.insert(beamednotes, {note=note, count=beamcount, realcount=realbeamcount})
 			if data.grace then beamednotes.grace = data.grace end
 			beamednotes.maxbeams = beamcount
 			note.beamgroup = beamednotes
 			inbeam = true
 		elseif data.beam == -1 then
 			assert(inbeam)
 			inbeam = false
 			table.insert(beamednotes, {note=note, count=beamcount, realcount=realbeamcount})
 			beamednotes.maxbeams = math.max(beamednotes.maxbeams, beamcount)
 			note.beamgroup = beamednotes
 		elseif inbeam then
 			beamednotes.maxbeams = math.max(beamednotes.maxbeams, beamcount)
 			table.insert(beamednotes, {note=note, count=beamcount, realcount=realbeamcount})
 			note.beamgroup = beamednotes
 		end
 
 		table.insert(staff1[curname], note)
 
 		local index = point(time)
 		if note.grace then
 			table.insert(timings[index].staffs[curname].pre, note)
 		else
 			table.insert(timings[index].staffs[curname].on, note)
 			time = time + incr
 		end
 		lastnote = note
 	end,
 	changeclef = function(data)
 		local class = assert(Clef[data.kind])
 		local clefitem = {kind="clef", class=class}
 		local index = point(time)
 		timings[index].staffs[curname].clef = clefitem
 		table.insert(staff1[curname], clefitem)
 
 		clef = class
 		octave = class.defoctave
 	end,
 	changestaff = function(data)
 		if staff1[data.name] == nil then
 			staff1[data.name] = {}
 		end
 		curname = data.name
 
 		-- mark cross staff beams for special treatment later
 		if inbeam then beamednotes.cross = true end
 	end,
 	changetime = function(data)
 		local timesig = {kind="time", num=data.num, denom=data.denom}
 		local index = point(time)
 		timings[index].staffs[curname].timesig = timesig
 		table.insert(staff1[curname], timesig)
 	end,
 	barline = function(data)
 		local index = point(time)
 		timings[index].barline = true
 		lastbarline = index
 		lastnote = nil
 	end,
 	srest = function(data)
 		table.insert(staff1[curname], {kind='srest', length=data.count, time=time})
 		time = time + 1 / Q.new(data.count)
 	end,
 }
 
 for _, voice in ipairs(voices) do
 	time = Q.new(0)
 	for _, item in ipairs(voice) do
 		local index = point(time)
 		if not timings[index] then timings[index] = {staffs={}} end
 		if curname and not timings[index].staffs[curname] then timings[index].staffs[curname] = {pre={}, on={}, post={}} end
 		assert(dispatch1[item.command])(item)
 	end
 end
 
 table.sort(points)
 
 for _, beam in pairs(beams) do
 	-- check which way the stem should point on all the notes in the beam
 	local ysum = 0
 	for _, entry in ipairs(beam) do
 		-- FIXME: note.heads[1].y is wrong
 		ysum = ysum + entry.note.heads[1].y
 	end
 
 	local stemdir
 	if ysum >= 0 then
 		stemdir = -1
 	else
 		stemdir = 1
 	end
 
 	-- check that stem direction hasn't been set manually
 	local unset = true
 	for _, entry in ipairs(beam) do
 		if entry.note.stemdir then
 			unset = false
 			break
 		end
 	end
 
 	-- update the stem direction
 	if unset then
 		for _, entry in ipairs(beam) do
 			entry.note.stemdir = stemdir
 		end
 	end
 end
 
 local staff3 = {}
 local extra3 = {}
 
 local x = 10
 local lasttime = 0
 
 for staff, _ in pairs(staff1) do
 	staff3[staff] = {}
 end
 
 local staff3ify = function(timing, el, staff)
 	local xdiff
 	local tindex = point(timing)
 	if el.kind == "notecolumn" then
 		local glyphsize
 		if el.grace then
 			glyphsize = 24
 		else
 			glyphsize = 32
 		end
 		local rx = x
 		xdiff = 10
 		rx = rx + xdiff
 
 		local glyph
 		if el.length == 1 then
 			glyph = Glyph["noteheadWhole"]
 		elseif el.length == 2 then
 			glyph = Glyph["noteheadHalf"]
 		elseif el.length >= 4 then
 			glyph = Glyph["noteheadBlack"]
 		end
 
 		local w, h = glyph_extents(glyph, glyphsize)
 
 		local preoffset = 0
 
 		-- TODO: increment on each accidental to reduce overlap
 		for _, head in ipairs(el.heads) do
 			if #head.acc then
 				preoffset = 10
 			end
 		end
 
 		-- offset of stem if a head is drawn on opposite side of stem
 		local altoffset = 0
 		if timings[tindex].flipped then
 			altoffset = w - 1.2
 		end
 
 		local heightsum = 0
 		local lowheight
 		local highheight
 		for _, head in ipairs(el.heads) do
 			heightsum = heightsum + head.y
 			local ry = (em*head.y) / 2 + 2*em
 			if not lowheight then lowheight = ry end
 			if not highheight then highheight = ry end
 			if head.flip then
 				head.glyph = {kind="glyph", width=w, size=glyphsize, glyph=glyph, x=preoffset + rx, y=ry, time={start=head.time}}
 			else
 				head.glyph = {kind="glyph", width=w, size=glyphsize, glyph=glyph, x=preoffset + altoffset + rx, y=ry, time={start=head.time}}
 			end
 			table.insert(staff3[staff], head.glyph)
 
 			if el.dot then
 				xdiff = xdiff + 5
 				table.insert(staff3[staff], {kind="circle", r=1.5, x=preoffset + altoffset + rx + w + 5, y=ry, time={start=head.time}})
 			end
 			if head.acc == "s" then
 				table.insert(staff3[staff], {kind="glyph", size=glyphsize, glyph=Glyph["accidentalSharp"], x=rx, y=ry, time={start=head.time}})
 			elseif head.acc == "f" then
 				table.insert(staff3[staff], {kind="glyph", size=glyphsize, glyph=Glyph["accidentalFlat"], x=rx, y=ry, time={start=head.time}})
 			elseif head.acc == "n" then
 				table.insert(staff3[staff], {kind="glyph", size=glyphsize, glyph=Glyph["accidentalNatural"], x=rx, y=ry, time={start=head.time}})
 			end
 
 			lowheight = math.min(lowheight, ry)
 			highheight = math.max(highheight, ry)
 
 			local stoptime
 			if el.time then stoptime = el.time + 1 else stoptime = nil end
 			-- TODO: only do this once per column
 			-- leger lines
 			if head.y <= -6 then
 				for j = -6, head.y, -2 do
 					table.insert(staff3[staff], {kind="line", t=1.2, x1=altoffset + preoffset + rx - .2*em, y1=(em * (j + 4)) / 2, x2=altoffset + preoffset + rx + w + .2*em, y2=(em * (j + 4)) / 2, time={start=el.time, stop=stoptime}})
 				end
 			end
 
 			if head.y >= 6 then
 				for j = 6, head.y, 2 do
 					table.insert(staff3[staff], {kind="line", t=1.2, x1=altoffset + preoffset + rx - .2*em, y1=(em * (j + 4)) / 2, x2=altoffset + preoffset + rx + w + .2*em, y2=(em * (j + 4)) / 2, time={start=el.time, stop=stoptime}})
 				end
 			end
 		end
 
 		if not el.stemdir and el.length > 1 then
 			if heightsum <= 0 then
 				el.stemdir = 1
 			else
 				el.stemdir = -1
 			end
 		end
 
 		-- stem
 		local stemstoptime
 		if el.stemdir then
 			if el.time then stemstoptime = el.time + .25 else stemstoptime = nil end
 			if el.stemdir == -1 then
 				-- stem up
 				-- advance width for bravura is 1.18 - .1 for stem width
 				el.stemx = w + rx - 1.08 + preoffset + altoffset
 				local stem = {kind="line", t=1, x1=el.stemx, y1=highheight - .168*em, x2=el.stemx, y2=lowheight -.168*em - el.stemlen*em, time={start=el.time, stop=stemstoptime}}
 				el.stem = stem
 				table.insert(staff3[staff], el.stem)
 			else
 				el.stemx = rx + .5 + preoffset + altoffset
 				local stem = {kind="line", t=1, x1=el.stemx, y1=lowheight + .168*em, x2=el.stemx, y2=highheight + el.stemlen*em, time={start=el.time, stop=stemstoptime}}
 				el.stem = stem
 				table.insert(staff3[staff], stem)
 			end
 		end
 
 		-- flag
 		if el.length == 8 and not el.beamgroup then
 			if el.stemdir == 1 then
 				local fx, fy = glyph_extents(Glyph["flag8thDown"], glyphsize)
 				table.insert(staff3[staff], {kind="glyph", glyph=Glyph["flag8thDown"], size=glyphsize, x=altoffset + preoffset + rx, y=highheight + 3.5*em, time={start=stemstoptime}})
 			else
 				-- TODO: move glyph extents to a precalculated table or something
 				local fx, fy = glyph_extents(Glyph["flag8thUp"], glyphsize)
 				table.insert(staff3[staff], {kind="glyph", glyph=Glyph["flag8thUp"], size=glyphsize, x=altoffset + el.stemx - .48, y=lowheight -.168*em - 3.5*em, time={start=stemstoptime}})
 				xdiff = xdiff + fx
 			end
 		end
 		xdiff = xdiff + 100 / el.length + 10
 		lasttime = el.time
 	elseif el.kind == "srest" then
 		xdiff = 0
 	elseif el.kind == "clef" then
 		table.insert(staff3[staff], {kind="glyph", glyph=el.class.glyph, size=32, x=x, y=el.class.yoff, time={start=timings[tindex].mintime, stop=timings[tindex].mintime + 1}})
 		xdiff =  30
 	elseif el.kind == "time" then
 		-- TODO: draw multidigit time signatures properly
 		table.insert(staff3[staff], {kind="glyph", glyph=numerals[el.num], size=32, x=x, y=em, time={start=timings[tindex].mintime, stop=timings[tindex].mintime + 1}})
 		table.insert(staff3[staff], {kind="glyph", glyph=numerals[el.denom], size=32, x=x, y=3*em, time={start=timings[tindex].mintime, stop=timings[tindex].mintime + 1}})
 		xdiff =  30
 	end
 
 	return xdiff
 end
 
 local rtimings = {}
 local snappoints = {}
 local curclef = {}
 for _, time in ipairs(points) do
 	local tindex = point(time)
 	local todraw = timings[tindex].staffs
 
 	-- clef
 	local xdiff = 0
 	for staff, vals in pairs(todraw) do
 		if vals.clef and (vals.clef.class ~= curclef[staff]) then
 			local diff = staff3ify(time, vals.clef, staff)
 			if diff > xdiff then xdiff = diff end
 			curclef[staff] = vals.clef.class
 		end
 	end
 
 	x = x + xdiff
 	xdiff = 0
 
 	-- time signature
 	local xdiff = 0
 	for staff, vals in pairs(todraw) do
 		if vals.timesig then
 			local diff = staff3ify(time, vals.timesig, staff)
 			if diff > xdiff then xdiff = diff end
 		end
 	end
 
 	x = x + xdiff
 	xdiff = 0
 
 	if timings[tindex].barline then
 		local time = timings[tindex].mintime or 0
 		if tindex == lastbarline then
 			table.insert(extra3, {kind='barline', x=x+25, last=true, time={start=time - 1, stop=time}})
 		else
 			table.insert(extra3, {kind='barline', x=x+25, time={start=time - 1, stop=time}})
 		end
 		x = x + 10
 	end
 
 	-- prebeat
 	for staff, vals in pairs(todraw) do
 		if #vals.pre == 0 then goto nextstaff end
 		for _, el in ipairs(vals.pre) do
 			local diff = staff3ify(time, el, staff)
 			if el.beamref then staff3ify(time, el.beamref, staff) end
 			x = x + diff
 		end
 		::nextstaff::
 	end
 	xdiff = 0
 
 	local maxtime = 0
 	-- on beat
 	for staff, vals in pairs(todraw) do
 		if #vals.on == 0 then goto nextstaff end
 		local diff
 		for _, el in ipairs(vals.on) do
 			-- HACK: don't hardcode staff name
 			if staff == "low" and el.time and el.time > maxtime then maxtime = el.time end
 			diff = staff3ify(time, el, staff)
 			if el.beamref then staff3ify(time, el.beamref, staff) end
 		end
 		if xdiff < diff then xdiff = diff end
 		::nextstaff::
 	end
 
 	x = x + xdiff
 	rtimings[maxtime] = x
 	if maxtime ~= 0 then
 		table.insert(snappoints, maxtime)
 	end
 end
 
 -- calculate extents
 local extents = {}
 
 for _, staff in pairs(stafforder) do
 	local items = staff3[staff]
 	extents[staff] = {xmin=0, ymin=0, xmax=0, ymax=0}
 	for i, d in ipairs(items) do
 		if d.kind == "glyph" then
 			local w, h = glyph_extents(d.glyph, 32)
 			if d.x - w < extents[staff].xmin then
 				extents[staff].xmin = d.x - w
 			elseif d.x + w > extents[staff].xmax then
 				extents[staff].xmax = d.x + w
 			end
 
 			if d.y - h < extents[staff].ymin then
 				extents[staff].ymin = d.y - h
 			elseif d.y + h > extents[staff].ymax then
 				extents[staff].ymax = d.y + h
 			end
 		elseif d.kind == "line" then
 			if d.x1 < extents[staff].xmin then
 				extents[staff].xmin = d.x1
 			elseif d.x1 > extents[staff].xmax then
 				extents[staff].xmax = d.x1
 			end
 
 			if d.x2 < extents[staff].xmin then
 				extents[staff].xmin = d.x2
 			elseif d.x2 > extents[staff].xmax then
 				extents[staff].xmax = d.x2
 			end
 
 			if d.y1 < extents[staff].ymin then
 				extents[staff].ymin = d.y1
 			elseif d.y1 > extents[staff].ymax then
 				extents[staff].ymax = d.y1
 			end
 
 			if d.y2 < extents[staff].ymin then
 				extents[staff].ymin = d.y2
 			elseif d.y2 > extents[staff].ymax then
 				extents[staff].ymax = d.y2
 			end
 		elseif d.kind == "quad" then
 			if d.x1 < extents[staff].xmin then
 				extents[staff].xmin = d.x1
 			elseif d.x1 > extents[staff].xmax then
 				extents[staff].xmax = d.x1
 			end
 
 			if d.x2 < extents[staff].xmin then
 				extents[staff].xmin = d.x2
 			elseif d.x2 > extents[staff].xmax then
 				extents[staff].xmax = d.x2
 			end
 
 			if d.y1 < extents[staff].ymin then
 				extents[staff].ymin = d.y1
 			elseif d.y1 > extents[staff].ymax then
 				extents[staff].ymax = d.y1
 			end
 
 			if d.y2 < extents[staff].ymin then
 				extents[staff].ymin = d.y2
 			elseif d.y2 > extents[staff].ymax then
 				extents[staff].ymax = d.y2
 			end
 
 			if d.x3 < extents[staff].xmin then
 				extents[staff].xmin = d.x3
 			elseif d.x3 > extents[staff].xmax then
 				extents[staff].xmax = d.x3
 			end
 
 			if d.x4 < extents[staff].xmin then
 				extents[staff].xmin = d.x4
 			elseif d.x4 > extents[staff].xmax then
 				extents[staff].xmax = d.x4
 			end
 
 			if d.y3 < extents[staff].ymin then
 				extents[staff].ymin = d.y3
 			elseif d.y3 > extents[staff].ymax then
 				extents[staff].ymax = d.y3
 			end
 
 			if d.y4 < extents[staff].ymin then
 				extents[staff].ymin = d.y4
 			elseif d.y4 > extents[staff].ymax then
 				extents[staff].ymax = d.y4
 			end
 		end
 	end
 end
 
 local xmax = 0
 local yoff = 0
 local firstymin, lastymin
 local xmin = 0
 for i, staff in pairs(stafforder) do
 	local extent = extents[staff]
 	if xmin > extent.xmin then
 		xmin = extent.xmin
 	end
 
 	if xmax < extent.xmax then
 		xmax = extent.xmax
 	end
 
 	if i == 1 then
 		firstymin = yoff + extent.ymin
 	end
 
 	if i == #stafforder then
 		lastymin = yoff - extent.ymin
 	end
 
 	extent.yoff = yoff
 	yoff = yoff + extent.ymax - extent.ymin
 end
 scale = frameheight / yoff
 
 for _, tie in pairs(ties) do
 	local yoff = extents[tie.staff].yoff - extents[tie.staff].ymin
 	table.insert(extra3, {kind="curve", x0=tie.start.glyph.x + tie.start.glyph.width + 10, y0=tie.start.glyph.y + yoff, x2=tie.stop.glyph.x + 10, y2=tie.stop.glyph.y + yoff, time={start=tie.start.glyph.time.start, stop=tie.stop.glyph.time.start}})
 end
 
 -- draw beam (and adjust stems) after all previous notes already have set values
 for _, notes in ipairs(beams) do
 	local beamheight, beamspace
 	if notes.grace then
 		beamheight = 3
 		beamspace = 5
 	else
 		beamheight = 5
 		beamspace = 7
 	end
 	local x0 = notes[1].note.stemx + .5
 	local y0 = notes[1].note.stem.y2 + extents[notes[1].note.staff].yoff - extents[notes[1].note.staff].ymin
 	local y0s = notes[1].note.stem.y2
 	local yn = notes[#notes].note.stem.y2 + extents[notes[#notes].note.staff].yoff - extents[notes[#notes].note.staff].ymin
 	local m = (yn - y0) / (notes[#notes].note.stemx + .5 - x0)
 
 	-- THIS IS A HACK: replace with more generic mechanism that detects overlap
 	-- this only accounts for stems pointing do
 	local stemextension = 0
 	if notes[1].count == 3 and notes[1].note.stemdir == -1 then
 		stemextension = -10
 	end
 
 	if notes.cross then
 		if notes[1].note.stemdir == -1 then
 			notes[1].note.stem.y2 = notes[1].note.stem.y2 - beamspace * (notes.maxbeams - 1) + beamheight
 		end
 		if notes[1].note.stemdir == 1 and notes[2] and notes[2].note.stemdir == -1 then
 			notes[1].note.stem.y2 = notes[1].note.stem.y2 + beamspace * notes.maxbeams
 		end
 	end
 
 	if notes[1].note.stemdir == 1 then
 		notes[1].note.stem.y2 = y0s + 7*(notes.maxbeams - 2) + beamheight + stemextension
 	end
 
 	for i, entry in ipairs(notes) do
 		if i == 1 then goto continue end
 		local note = notes[i].note
 		local n = entry.count
 		local x1 = notes[i-1].note.stemx + .5
 		local prevymin = extents[notes[i-1].note.staff].ymin
 		local x2 = note.stemx + .5
 		local extent = extents[note.staff]
 
 		-- change layout parameters depending on stem up or stem down
 		local first, last, inc
 		if entry.note.stemdir == 1 then
 			first = beamspace*(notes.maxbeams - 2)
 			last = beamspace*(notes.maxbeams - n - 1)
 			if extents[entry.note.staff].yoff < extents[notes[1].note.staff].yoff then
 				entry.note.stem.y2 = y0 + m*(x2 - x0) + 7*(notes.maxbeams - 2) + beamheight + extents[entry.note.staff].ymin - extents[entry.note.staff].yoff + stemextension
 			else
 				entry.note.stem.y2 = y0s + m*(x2 - x0) + 7*(notes.maxbeams - 2) + beamheight + stemextension
 			end
 			inc = -beamspace
 		else
 			if extents[entry.note.staff].yoff > extents[notes[1].note.staff].yoff then
 				entry.note.stem.y2 = y0 + m*(x2 - x0) + beamheight - extents[entry.note.staff].yoff + extents[entry.note.staff].ymin + stemextension
 			else
 				entry.note.stem.y2 = y0s + m*(x2 - x0) + stemextension
 			end
 			first = 0
 			last = beamspace*(n-1)
 			inc = beamspace
 		end
 
 		-- draw beams segment by segment
 		for yoff=first, last, inc do
 			local starttime, stoptime
 			if note.time then stoptime = note.time + .25 else stoptime = nil end
 			if note.time then starttime = notes[i-1].note.time + .25 else starttime = nil end
 			if entry.note.stemdir ~= 1 and notes.cross then
 				table.insert(extra3, {kind="beamseg", x1=x1 - 0.5 - extent.xmin, x2=x2 - extent.xmin, y1=y0 + m*(x1 - x0) + yoff + stemextension, y2=y0 + m*(x2 - x0) + yoff + stemextension, h=beamheight, time={start=starttime, stop=stoptime}})
 			else
 				table.insert(extra3, {kind="beamseg", x1=x1 - 0.5 - extent.xmin, x2=x2 - extent.xmin, y1=y0 + m*(x1 - x0) + yoff + stemextension, y2=y0 + m*(x2 - x0) + yoff + stemextension, h=beamheight, time={start=starttime, stop=stoptime}})
 			end
 		end
 		::continue::
 	end
 end
 
 for staff, item in ipairs(extra3) do
 	if item.kind == 'barline' then
 		if item.x < xmin then
 			xmin = item.x
 		elseif item.x > xmax then
 			if item.last then
 				xmax = item.x + 7
 			else
 				xmax = item.x
 			end
 		end
 	end
 end
 
 local lastpoint = 0
 for _, point in ipairs(snappoints) do
 	lastpoint = math.max(point, lastpoint)
 end
 
 -- TODO: is there a better way to do this?
 snappoints[0] = snappoints[1]
 local snapidx = 1
 local toff_base = 0
 function drawframe(time)
 	if snappoints[snapidx + 1] and snappoints[snapidx] < time then
 		snapidx = snapidx + 1
 		toff_base = -rtimings[snappoints[snapidx - 1]]
 	end
 	local xdiff = rtimings[snappoints[snapidx]] - rtimings[snappoints[snapidx - 1]]
 	local delta = xdiff * (time - snappoints[snapidx - 1]) / (snappoints[snapidx] - snappoints[snapidx - 1])
 	local toff = toff_base - delta + framewidth / (2*scale)
 
 	if time > lastpoint + 10 then
 		return true
 	end
 
 	for _, staff in ipairs(stafforder) do
 		local extent = extents[staff]
 		for i, d in ipairs(staff3[staff]) do
 			if not d.time.start then goto continue end
 			if d.time.start < time then
 				if d.kind == "glyph" then
 					draw_glyph(scale*d.size, d.glyph, scale*(toff + d.x - extent.xmin), scale*(d.y - extent.ymin + extent.yoff))
 				elseif d.kind == "line" then
 					local delta = (time - d.time.start) / (d.time.stop - d.time.start)
 					local endx, endy
 					if d.x1 < d.x2 then
 						endx = math.min(d.x1 + delta*(d.x2 - d.x1), d.x2)
 					else
 						endx = math.max(d.x1 + delta*(d.x2 - d.x1), d.x2)
 					end
 					if d.y1 < d.y2 then
 						endy = math.min(d.y1 + delta*(d.y2 - d.y1), d.y2)
 					else
 						endy = math.max(d.y1 + delta*(d.y2 - d.y1), d.y2)
 					end
 					draw_line(scale*d.t, scale*(toff + d.x1 - extent.xmin), scale*(d.y1 - extent.ymin + extent.yoff), scale*(toff + endx - extent.xmin), scale*(endy - extent.ymin + extent.yoff))
 				elseif d.kind == "circle" then
 					draw_circle(scale*d.r, scale*(toff + d.x - extent.xmin), scale*(d.y - extent.ymin + extent.yoff))
 				elseif d.kind == "vshear" then
 					local delta = (time - d.time.start) / (d.time.stop - d.time.start)
 					local endx, endy
 					if d.x1 < d.x2 then
 						endx = math.min(d.x1 + delta*(d.x2 - d.x1), d.x2)
 					else
 						endx = math.max(d.x1 + delta*(d.x2 - d.x1), d.x2)
 					end
 					if d.y1 < d.y2 then
 						endy = math.min(d.y1 + delta*(d.y2 - d.y1), d.y2)
 					else
 						endy = math.max(d.y1 + delta*(d.y2 - d.y1), d.y2)
 					end
 					draw_quad(scale*(toff + d.x1 - extent.xmin), scale(d.y1 - extent.ymin + extent.yoff), scale(toff + endx - extent.xmin), scale*(endy - extent.ymin + extent.yoff), scale*(toff + endx - extent.xmin), scale*(endy + d.h - extent.ymin + extent.yoff), scale*(toff + d.x1 - extent.xmin), scale*(d.y1 + d.h - extent.ymin + extent.yoff))
 				elseif d.kind == "quad" then
 					draw_quad(scale*(toff + d.x1 - extent.xmin), scale*(d.y1 - extent.ymin + extent.yoff), scale*(toff + d.x2 - extent.xmin), scale*(d.y2 - extent.ymin + extent.yoff), scale*(toff + d.x3 - extent.xmin), scale*(d.y3 - extent.ymin + extent.yoff), scale*(toff + d.x4 - extent.xmin), scale*(d.y4 - extent.ymin + extent.yoff))
 				end
 			end
 
 			::continue::
 		end
 
 		-- draw staff
 		for y=0,em*4,em do
 			draw_line(scale, scale*(toff + xmin), scale*(y + extent.yoff - extent.ymin), scale*(toff + xmax), scale*(y + extent.yoff - extent.ymin))
 		end
 	end
 
 	-- draw barlines
 	for staff, item in ipairs(extra3) do
 		if item.kind == 'barline' then
 			if item.time.start > time then goto continue end
 			local y1 = -firstymin
 			local y2 = lastymin + 4*em
 			local delta = (time - item.time.start) / (item.time.stop - item.time.start)
 			local endy = math.min(y1 + delta*(y2 - y1), y2)
 
 			draw_line(scale, scale*(toff + item.x), scale*(y1), scale*(toff + item.x), scale*(endy))
 			if item.last then
 			draw_line(scale*4, scale*(5 + toff + item.x), scale*(y1), scale*(5 + toff + item.x), scale*(endy))
 			end
 		elseif item.kind == "curve" then
 			if item.time.start > time then goto continue end
 			local delta
 			if item.time.stop < time then
 				delta = 1
 			else
 				delta = (time - item.time.start) / (item.time.stop - item.time.start)
 			end
 			local endx = item.x0 + delta*(item.x2 - item.x0)
 			draw_curve(delta, scale, scale*(toff + item.x0), scale*(item.y0), scale*(toff + (item.x0 + endx) / 2), scale*((item.y0 + item.y2) / 2 + 20), scale*(toff + endx), scale*(item.y2))
 		elseif item.kind == "beamseg" then
 			if item.time.start > time then goto continue end
 			local delta
 			if item.time.stop == item.time.start then
 				delta = 1
 			else
 				delta = (time - item.time.start) / (item.time.stop - item.time.start)
 			end
 			local endx, endy
 			if item.x1 < item.x2 then
 				endx = math.min(item.x1 + delta*(item.x2 - item.x1), item.x2)
 			else
 				endx = math.max(item.x1 + delta*(item.x2 - item.x1), item.x2)
 			end
 			if item.y1 < item.y2 then
 				endy = math.min(item.y1 + delta*(item.y2 - item.y1), item.y2)
 			else
 				endy = math.max(item.y1 + delta*(item.y2 - item.y1), item.y2)
 			end
 			draw_quad(scale*(toff + item.x1), scale*(item.y1), scale*(toff + endx), scale*(endy), scale*(toff + endx), scale*(endy + item.h), scale*(toff + item.x1), scale*(item.y1 + item.h))
 		end
 		::continue::
 	end
 
 	return false
 end