mirror of
https://github.com/microtherion/VocalEasel.git
synced 2024-12-22 19:23:59 +00:00
591 lines
18 KiB
Python
591 lines
18 KiB
Python
# midi.py
|
|
|
|
"""
|
|
This module is an integeral part of the program
|
|
MMA - Musical Midi Accompaniment.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
Bob van der Poel <bob@mellowood.ca>
|
|
"""
|
|
|
|
|
|
from MMA.midiM import intToWord, intTo3Byte, intToLong, intToVarNumber
|
|
import MMA.midiC
|
|
|
|
import gbl
|
|
from MMA.common import *
|
|
|
|
splitChannels = []
|
|
|
|
|
|
def setSplitChannels(ln):
|
|
""" Parser routine, sets up list of track to split. Overwrites existing. """
|
|
|
|
global splitChannels
|
|
|
|
splitChannels = []
|
|
|
|
for a in ln:
|
|
a = stoi(a)
|
|
if a < 1 or a >16:
|
|
error("SplitChannels: Expecting value 1 to 16, not %s" % a)
|
|
splitChannels.append(a)
|
|
|
|
if gbl.debug:
|
|
print "SplitChannels: ",
|
|
printList(splitChannels)
|
|
|
|
|
|
####################
|
|
|
|
def writeTracks(out):
|
|
""" Write the accumulated MIDI tracks to file. """
|
|
|
|
keys=gbl.mtrks.keys()
|
|
keys.sort()
|
|
|
|
""" For type 0 MIDI files all data is contained in 1 track.
|
|
We take all our tracks and copy them to track 0, then
|
|
set up keys[] so that only track 0 remains.
|
|
"""
|
|
|
|
if gbl.midiFileType == 0:
|
|
trk0=gbl.mtrks[0].miditrk
|
|
for n in keys[1:]:
|
|
trk=gbl.mtrks[n].miditrk
|
|
for k,v in trk.items():
|
|
if k in trk0:
|
|
trk0[k].extend(v)
|
|
else:
|
|
trk0[k]=v
|
|
keys=[0]
|
|
|
|
# Write header
|
|
|
|
tcount = len(keys)
|
|
out.write( mkHeader(tcount, gbl.BperQ, gbl.midiFileType) )
|
|
|
|
# Write data chunks for each track
|
|
|
|
for n in keys:
|
|
|
|
if len(gbl.mtrks[n].miditrk):
|
|
|
|
if gbl.debug:
|
|
print "Writing <%s> ch=%s;" % \
|
|
(gbl.mtrks[n].trackname, n),
|
|
|
|
if n in splitChannels and gbl.midiFileType:
|
|
tcount += writeSplitTrack(n, out)
|
|
else:
|
|
gbl.mtrks[n].writeMidiTrack(out)
|
|
|
|
""" We have increased the track count! So, we need to
|
|
fix the file header. This is offset 10/11 which contains
|
|
the number of tracks. The counter tcount has been
|
|
tracking this, so just seek, replace and seek back.
|
|
"""
|
|
|
|
if tcount != len(keys):
|
|
out.seek(0)
|
|
out.write( mkHeader(tcount, gbl.BperQ, gbl.midiFileType) )
|
|
out.seek(0, 2) # return to eof
|
|
|
|
|
|
def writeSplitTrack(channel, out):
|
|
""" Split a track. In drum tracks this puts different instruments
|
|
into individual tracks (useful!); for instrument tracks it puts
|
|
each pitch into a track (probably not useful).
|
|
"""
|
|
|
|
tr = gbl.mtrks[channel].miditrk # track to split
|
|
|
|
""" A dict to store the split midi tracks. We'll end out with
|
|
a track for each pitch which appears in the track and
|
|
a track (labeled -1) to store every other-than-note-on data.
|
|
"""
|
|
|
|
notes={}
|
|
|
|
onEvent = 0x90 + (channel-1)
|
|
offEvent = 0x80 + (channel-1)
|
|
|
|
for offset in tr.keys():
|
|
for x in range(len(tr[offset])-1, -1, -1):
|
|
ev = tr[offset][x]
|
|
if len(ev) == 3 and ( ord(ev[0]) in (onEvent, offEvent)):
|
|
n = ord(ev[1])
|
|
else:
|
|
n = -1 # special value for non-note on events
|
|
|
|
if not n in notes: # create a new mtrk if needed
|
|
notes[n]=Mtrk(10)
|
|
|
|
if offset in notes[n].miditrk: # copy event to new track
|
|
notes[n].miditrk[offset].append(ev)
|
|
else:
|
|
notes[n].miditrk[offset]=[ev]
|
|
|
|
if gbl.debug:
|
|
print " Data has been split into %s tracks." % len(notes)
|
|
|
|
# Insert a channel name in all the new tracks.
|
|
|
|
for a in notes.keys():
|
|
if a == -1:
|
|
continue
|
|
if channel == 10:
|
|
m = "%s" % MMA.midiC.valueToDrum(a)
|
|
else:
|
|
m = "%s-%s" % (gbl.mtrks[channel].trackname, a)
|
|
|
|
notes[a].addTrkName(0, m)
|
|
|
|
for a in sorted(notes.keys()):
|
|
notes[a].writeMidiTrack(out)
|
|
|
|
""" The split tracks have been written. Return the number of additional tracks
|
|
so that the caller can properly update the midi file header. Note that
|
|
len(notes)-1 IS CORRECT ... we've already figured on writing 1 track.
|
|
"""
|
|
|
|
return len(notes)-1
|
|
|
|
|
|
def mkHeader(count, tempo, Mtype):
|
|
|
|
return "MThd" + intToLong(6) + intToWord(Mtype) + intToWord(count) + intToWord(tempo)
|
|
|
|
|
|
""" Midi track class. All the midi creation is done here.
|
|
We create a class instance for each track. mtrks{}.
|
|
"""
|
|
|
|
class Mtrk:
|
|
|
|
def __init__(self, channel):
|
|
self.miditrk={}
|
|
self.channel = channel-1
|
|
self.trackname = ''
|
|
self.lastEvent = [None] * 129
|
|
|
|
|
|
def delDup(self, offset, cmd):
|
|
"""Delete a duplicate event. Used by timesig, etc. """
|
|
|
|
tr=self.miditrk
|
|
lg=len(cmd)
|
|
if offset in tr:
|
|
for i,a in enumerate(tr[offset]):
|
|
if a[0:lg] == cmd:
|
|
del tr[offset][i]
|
|
|
|
|
|
def addTimeSig(self, offset, nn, dd, cc, bb):
|
|
""" Create a midi time signature.
|
|
|
|
delta - midi delta offset
|
|
nn = sig numerator, beats per measure
|
|
dd - sig denominator, 2=quarter note, 3=eighth,
|
|
cc - midi clocks/tick
|
|
bb - # of 32nd notes in quarter (normally 8)
|
|
|
|
This is only called by timeSig.set(). Don't
|
|
call this directly since the timeSig.set() checks for
|
|
duplicate settings.
|
|
"""
|
|
|
|
cmd = chr(0xff) + chr(0x58)
|
|
self.delDup(offset, cmd) # NEEDED???
|
|
self.addToTrack(offset, cmd + chr(0x04) + \
|
|
chr(nn) + chr(dd) + chr(cc) + chr(bb) )
|
|
|
|
|
|
def addKeySig(self, offset, n, mi):
|
|
""" Set the midi key signature. """
|
|
|
|
cmd = chr(0xff) + chr(0x59)
|
|
self.delDup(offset, cmd)
|
|
self.addToTrack(offset, cmd + chr(0x02) + chr(n) + chr(mi) )
|
|
|
|
|
|
def addMarker(self, offset, msg):
|
|
""" Create a midi MARKER event."""
|
|
|
|
self.addToTrack(offset, chr(0xff) + chr(0x06) + intToVarNumber(len(msg)) + msg )
|
|
|
|
|
|
def addText(self, offset, msg):
|
|
""" Create a midi TextEvent."""
|
|
|
|
self.addToTrack( offset, chr(0xff) + chr(0x01) + intToVarNumber(len(msg)) + msg )
|
|
|
|
|
|
def addLyric(self, offset, msg):
|
|
""" Create a midi lyric event. """
|
|
|
|
self.addToTrack( offset,
|
|
chr(0xff) + chr(0x05) + intToVarNumber(len(msg)) + msg )
|
|
|
|
|
|
def addTrkName(self, offset, msg):
|
|
""" Creates a midi track name event. """
|
|
|
|
offset = 0 # ignore user offset, always put this at 0
|
|
|
|
self.trackname = msg
|
|
|
|
cmd = chr(0xff) + chr(0x03)
|
|
self.delDup(offset, cmd)
|
|
self.addToTrack(offset, cmd + intToVarNumber(len(msg)) + msg )
|
|
|
|
|
|
def addProgChange( self, offset, program, oldprg):
|
|
""" Create a midi program change (handles extended voicing).
|
|
|
|
program - The MIDI program (voice) value
|
|
oldprg - existing MIDI program
|
|
"""
|
|
|
|
v1, lsb1, msb1 = MMA.midiC.voice2tup(oldprg)
|
|
v2, lsb2, msb2 = MMA.midiC.voice2tup(program)
|
|
|
|
if msb1 != msb2: # only if CTRL32 has changed
|
|
self.addToTrack(offset, chr(0xb0 | self.channel) + chr(0x20) + chr(msb2) )
|
|
|
|
if lsb1 != lsb2: # only if CTRL0 has changed
|
|
self.addToTrack(offset, chr(0xb0 | self.channel) + chr(0x00) + chr(lsb2) )
|
|
|
|
# Always do voice change. Maybe not necessary, but let's be safe.
|
|
|
|
self.addToTrack(offset, chr(0xc0 | self.channel) + chr(v2) )
|
|
|
|
|
|
def addGlis(self, offset, v):
|
|
""" Set the portamento. LowLevel MIDI.
|
|
|
|
This does 2 things:
|
|
1. turns portamento on/off,
|
|
2. sets the LSN rate.
|
|
"""
|
|
|
|
if v == 0:
|
|
self.addToTrack(offset, chr(0xb0 | self.channel) + chr(0x41) + chr(0x00) )
|
|
|
|
else:
|
|
self.addToTrack(offset, chr(0xb0 | self.channel) + chr(0x41) + chr(0x7f) )
|
|
self.addToTrack(offset, chr(0xb0 | self.channel) + chr(0x05) + chr(v) )
|
|
|
|
|
|
def addPan(self, offset, v):
|
|
""" Set the lsb of the pan setting."""
|
|
|
|
self.addToTrack(offset, chr(0xb0 | self.channel) + chr(0x0a) + chr(v) )
|
|
|
|
|
|
def addCtl(self, offset, l):
|
|
""" Add arbitary control sequence to track."""
|
|
|
|
self.addToTrack(offset, chr(0xb0 | self.channel) + l)
|
|
|
|
|
|
def addNoteOff(self, offset):
|
|
""" Insert a "All Note Off" into the midi stream.
|
|
|
|
Called from the cutTrack() function.
|
|
"""
|
|
|
|
self.addToTrack(offset,
|
|
chr(0xb0 | self.channel) + chr(0x7b) + chr(0) )
|
|
|
|
|
|
def addChannelVol(self, offset, v):
|
|
""" Set the midi channel volume."""
|
|
|
|
self.addToTrack(offset,
|
|
chr(0xb0 | self.channel) + chr(0x07) + chr(v) )
|
|
|
|
|
|
def addTempo(self, offset, beats):
|
|
""" Create a midi tempo meta event.
|
|
|
|
beats - beats per second
|
|
|
|
Return - packed midi string
|
|
"""
|
|
|
|
cmd = chr(0xff) + chr(0x51)
|
|
self.delDup(offset, cmd)
|
|
self.addToTrack( offset, cmd + chr(0x03) + intTo3Byte(60000000/beats) )
|
|
|
|
|
|
def writeMidiTrack(self, out):
|
|
""" Create/write the MIDI track.
|
|
|
|
We convert timing offsets to midi-deltas.
|
|
"""
|
|
|
|
tr=self.miditrk
|
|
|
|
""" If the -1 flag is set we need to add a terminate
|
|
to the end of each track. This is done to make looping
|
|
software like seq24 happy. We do this by truncating all
|
|
data in the file past the current tick pointer and inserting
|
|
an all-notes-off at that position.
|
|
"""
|
|
|
|
if gbl.endsync and self.channel>=0:
|
|
eof = gbl.tickOffset
|
|
for offset in tr.keys():
|
|
if offset > eof:
|
|
del tr[offset]
|
|
self.addToTrack(eof, chr(0xb0 | self.channel) + chr(0x7b) + chr(0))
|
|
|
|
|
|
""" To every MIDI track we generate we add (if the -0 flag
|
|
was set) an on/off beep at offset 0. This makes for
|
|
easier sync in multi-tracks.
|
|
"""
|
|
|
|
if gbl.synctick and self.channel >= 0:
|
|
self.addToTrack(0, chr(0x90 | self.channel) + chr(80) + chr(90) )
|
|
self.addToTrack(1, chr(0x90 | self.channel) + chr(80) + chr(0) )
|
|
|
|
|
|
if gbl.debug:
|
|
ttl = 0
|
|
lg=1
|
|
for t in tr:
|
|
a=len(tr[t])
|
|
if a > lg:
|
|
lg = a
|
|
ttl += a
|
|
print "Unique ts: %s; Ttl events %s; Average ev/ts %.2f" % \
|
|
(len(tr), ttl, float(ttl)/len(tr) )
|
|
|
|
last = 0
|
|
|
|
# Convert all events to MIDI deltas and store in
|
|
# the track array/list
|
|
|
|
tdata = [] # empty track container
|
|
lastSts = None # Running status tracker
|
|
|
|
for a in sorted(tr.keys()):
|
|
delta = a-last
|
|
for d in tr[a]:
|
|
|
|
""" Running status check. For each packet compare
|
|
the first byte with the first byte of the previous
|
|
packet. If it is can be converted to running status
|
|
we strip out byte 0. Note that valid running status
|
|
byte are 0x80..0xef. 0xfx are system messages
|
|
and are note suitable for running status.
|
|
"""
|
|
|
|
if len(d) > 1:
|
|
if d[0] == lastSts:
|
|
d=d[1:]
|
|
else:
|
|
lastSts = d[0]
|
|
s=ord(lastSts)
|
|
if s < 0x80 or s > 0xef or not gbl.runningStatus:
|
|
lastSts = None
|
|
|
|
tdata.extend( [ intToVarNumber(delta) , d ] )
|
|
delta = 0
|
|
last = a
|
|
|
|
# Add an EOF to the track (included in total track size)
|
|
|
|
tdata.append( intToVarNumber(0))
|
|
tdata.append( chr(0xff) + chr(0x2f) + chr(0x00) )
|
|
|
|
tdata = ''.join(tdata)
|
|
totsize = len(tdata)
|
|
|
|
out.write("MTrk")
|
|
out.write(intToLong(totsize))
|
|
out.write( tdata )
|
|
|
|
|
|
def addPairToTrack(self, boffset, startRnd, duration, note, v, unify):
|
|
""" Add a note on/off pair to a track.
|
|
|
|
boffset - offset into current bar
|
|
startRnd - rand val start adjustment
|
|
duration - note len
|
|
note - midi value of note
|
|
v - midi velocity
|
|
unify - if set attempt to unify/compress on/offs
|
|
|
|
This function tries its best to handle overlapping events.
|
|
Easy to show effect with a table of note ON/OFF pairs. Both
|
|
events are for the same note pitch.
|
|
|
|
Offsets | 200 | 300 | 320 | 420
|
|
---------|--------|--------|-------|--------
|
|
Pair1 | on | | off |
|
|
Pair2 | | on | | off
|
|
|
|
The logic here will delete the OFF event at 320 and
|
|
insert a new OFF at 300. Result is that when playing
|
|
Pair1 will turn off at 300 followed by the same note
|
|
in Pair2 beginning sounded right after. Why the on/off?
|
|
Remember: Velocities may be different!
|
|
|
|
However, if the unify flag is set we should end up with:
|
|
|
|
Offsets | 200 | 300 | 320 | 420
|
|
---------|--------|--------|-------|--------
|
|
Pair1 | on | | |
|
|
Pair2 | | | | off
|
|
|
|
"""
|
|
|
|
# Start/end offsets
|
|
|
|
onOffset = getOffset( boffset, startRnd)
|
|
offOffset = onOffset + duration
|
|
|
|
# ON/OFF events
|
|
|
|
onEvent = chr(0x90 | self.channel) + chr(note) + chr(v)
|
|
offEvent = onEvent[:-1] + chr(0)
|
|
|
|
""" Check for overlap on last event set for this track and
|
|
do some ugly trickry.
|
|
|
|
- The noOnFlag is set if we don't want to have the main
|
|
routine add in the ON event. This is set when UNIFY is
|
|
set and we have an overlap.
|
|
|
|
- We set F to the stored event time for this note and,
|
|
if it's in the same event range as the current event
|
|
we loop though the saved events for this track. We are
|
|
looking for a NOTE OFF event.
|
|
|
|
- If we get a matching event we then delete it from the
|
|
track. This requires 2 statements: one for an event
|
|
list with only 1 event, a 2nd for multiple events.
|
|
|
|
- If UNIFY is NOT set we insert a NOTE OFF at the current
|
|
on time. This replaces the OFF we just deleted.
|
|
|
|
- If UNIFY is SET we skip the above step, and we set the
|
|
noOnFlag so that the ON event isn't set.
|
|
|
|
"""
|
|
|
|
noOnFlag = None
|
|
|
|
f=self.lastEvent[note]
|
|
if f >= onOffset and f <= offOffset:
|
|
tr=self.miditrk
|
|
for i in range(len(tr[f])):
|
|
if tr[f][i] == offEvent:
|
|
if len(tr[f]) == 1:
|
|
del(tr[f])
|
|
else:
|
|
del(tr[f][i])
|
|
if not unify:
|
|
self.addToTrack(onOffset, offEvent)
|
|
else:
|
|
noOnFlag=1
|
|
break
|
|
|
|
if not noOnFlag:
|
|
self.addToTrack(onOffset, onEvent )
|
|
self.addToTrack(offOffset, offEvent )
|
|
|
|
# Save the NOTE OFF time for the next loop.
|
|
|
|
self.lastEvent[note] = offOffset
|
|
|
|
|
|
def zapRangeTrack(self, start, end):
|
|
""" Clear NoteOn events from track in range: start ... end.
|
|
|
|
This is called from the fermata function.
|
|
|
|
We delete the entire event list (3 bytes) from the buffer. This
|
|
can result in empty directory enteries, but that isn't a problem.
|
|
"""
|
|
|
|
trk=self.miditrk
|
|
for a in trk:
|
|
if a>=start and a<=end:
|
|
for i in range(len(trk[a])-1, -1, -1):
|
|
e = trk[a][i]
|
|
if len(e)==3 and ord(e[0]) & 0xF0 == 0x90 and ord(e[2]):
|
|
del trk[a][i]
|
|
|
|
|
|
def addToTrack(self, offset, event):
|
|
""" Add an event to a track.
|
|
|
|
MIDI data is saved as created in track structures.
|
|
Each track has a miditrk dictionary entry which used
|
|
the time offsets and keys and has the various events
|
|
as data. Each event is a packed string of bytes and
|
|
the events are stored as a list in the order they are
|
|
created. Our storage looks like:
|
|
|
|
miditrk[OFFSET_VALUE] = [event1, event2, ...]
|
|
"""
|
|
|
|
if offset<0:
|
|
offset=0
|
|
|
|
tr=self.miditrk
|
|
|
|
if offset in tr:
|
|
tr[offset].append(event)
|
|
else:
|
|
tr[offset]=[event]
|
|
|
|
|
|
class TimeSig:
|
|
""" Track and set the current time signature.
|
|
|
|
Timesigs are completely optional and are inserted into
|
|
the MIDI file by addTimeSig(). MMA routines ignore timesig
|
|
settings.
|
|
"""
|
|
|
|
def __init__(self):
|
|
""" Initialze to null value, user will never set to this."""
|
|
|
|
self.lastsig = (None,None)
|
|
|
|
def set(self, nn, dd):
|
|
""" Set timesig. If no change from last value, ignore. """
|
|
|
|
if self.lastsig != (nn, dd):
|
|
gbl.mtrks[0].addTimeSig(gbl.tickOffset, nn, dd, 48, 8)
|
|
self.lastsig = (nn, dd)
|
|
|
|
def get(self):
|
|
""" Return existing timesig. """
|
|
|
|
return self.lastsig
|
|
|
|
|
|
timeSig = TimeSig()
|
|
|
|
|
|
|