def prepare_print_instruments(self, druminst=None):
"""build complete timeline for (drum & regular) instrument events
"""
if not druminst:
druminst = []
self.druminst = druminst
self.notes_data_dict = collections.defaultdict(dict)
self.all_notes = collections.defaultdict(set)
self.total_length = 0
for trackname in self.tracknames:
is_drumtrack = trackname in self.druminst
# bepaal max. lengte
start, _, lng = self.patterndata[trackname][-1]
for pattern in self.patterndata[trackname]:
self.all_notes[trackname].update([x[0] for x in pattern[1]])
## total_length = int((start + len) / shared.timing_unit)
current_length = (start + lng) // shared.timing_unit
self.total_length = max((current_length, self.total_length))
empty = shared.empty[is_drumtrack]
for note in self.all_notes[trackname]:
self.notes_data_dict[trackname][note] = [empty
] * self.total_length
for start, pattern, lng in self.patterndata[trackname]:
for note, timing in pattern:
## idx = int((start + timing) / shared.timing_unit)
idx = (start + timing) // shared.timing_unit
if is_drumtrack:
notename = shared.get_inst_name(note +
shared.octave_length +
shared.note2drums)
else:
notename = shared.get_note_name(note +
shared.octave_length)
self.notes_data_dict[trackname][note][idx] = notename
def print_instrument(self, trackname, _out=sys.stdout):
"""print the events for an instrument as a piano roll
trackname is the name of the track / sample to print data for
stream is a file-like object to write the output to
"""
for ix, pattdata in enumerate(self.patterndata_split[trackname]):
pattern, pattlen = pattdata
print(shared.patt_start.format(ix + 1), file=_out)
events = collections.defaultdict(list)
notes = set()
for pitch, ev in pattern:
events[pitch].append(ev)
notes.add(pitch)
for pitch in reversed(sorted(notes)):
printable = [shared.line_start[:-1]]
out = False
for i in range(pattlen):
if i in events[pitch]:
corr = pitch + shared.octave_length # for comparability
printable.append(shared.get_note_name(corr))
out = True
else:
printable.append(shared.empty_note)
if out:
print(' '.join(printable), file=_out)
print('', file=_out)
def prepare_print_instruments(self, instlist):
"""build complete timeline for all regular instrument events
"""
self.all_note_tracks = collections.defaultdict(
lambda: collections.defaultdict(list))
self.all_notes = collections.defaultdict(set)
for sampnum, sample in instlist:
for pattnum, pattern in enumerate(self.pattern_data[sampnum]):
self.all_notes[sample].update(pattern.keys())
self.all_notes[sample].discard('len')
self.all_notes[sample] = [
x for x in reversed(sorted(self.all_notes[sample]))]
for pattseq, pattnum in enumerate(self.playseqs[sampnum]):
if pattnum == -1:
pattlen = self.all_pattern_lengths[pattseq]
for note in self.all_notes[sample]:
self.all_note_tracks[sample][note].extend(
[shared.empty_note] * pattlen)
continue
pattern = self.pattern_data[sampnum][pattnum - 1]
for note in self.all_notes[sample]:
events = pattern[note]
for i in range(pattern['len']):
if i in events:
to_append = shared.get_note_name(
note + 3 * shared.octave_length - 1)
else:
to_append = shared.empty_note
self.all_note_tracks[sample][note].append(to_append)
def get_note_name(inp):
"""translate note number to note name
adapted octave to be comparable to other types
"""
if inp == 0:
return shared.empty_note
return shared.get_note_name(inp + 3 * shared.octave_length)
def print_instrument(self, trackno, stream=sys.stdout):
"""print the events for an instrument as a piano roll
trackno is the number of the midi track / sample to print data for
stream is a file-like object to write the output to
"""
is_drumtrack = self.instruments[trackno][1] == shared.drum_channel
for number, pattern in self.patterns[trackno]:
print(shared.patt_start.format(number + 1), file=stream)
unlettered = set()
printables = []
for pitch in pattern:
if not pattern[pitch]:
continue
if is_drumtrack:
notestr = shared.get_inst_name(pitch + shared.note2drums)
if notestr == '?':
unlettered.add('no letter yet for `{}`'.format(
shared.gm_drums[pitch - 35][1]))
else:
try:
key = shared.standard_printseq.index(notestr)
except ValueError:
unlettered.add('{} not in standard printseq {}'.format(
notestr, shared.standard_printseq))
else:
notestr = shared.get_note_name(pitch)
key = pitch
printstr = [shared.line_start]
index = 0
for event in pattern[pitch]:
while index < event:
printstr.append(shared.empty[is_drumtrack])
index += 1
printstr.append(notestr)
index += 1
while index < shared.per_line:
printstr.append(shared.empty[is_drumtrack])
index += 1
if not is_drumtrack:
printstr[0] = printstr[0][:-1]
printables.append((key, shared.sep[is_drumtrack].join(printstr)))
printables.sort()
if not is_drumtrack:
printables.reverse()
for key, line in printables:
print(line, file=stream)
print('', file=stream)
for x in unlettered:
print(x, file=stream)
return unlettered
def prepare_print_instruments(self):
"""build complete timeline for (drum & regular) instrument events
"""
self.all_track_notes = collections.defaultdict(
lambda: collections.defaultdict(list))
self.all_notevals = collections.defaultdict(set)
self.total_length = 0
for trackno, trackdata in self.instruments.items():
is_drumtrack = trackdata[1] == shared.drum_channel
patterns = dict(self.patterns[trackno])
for _, pattdict in self.patterns[trackno]:
self.all_notevals[trackno].update([x for x in pattdict.keys()])
pattlist = []
seq = 0
for pattseq, pattnum in sorted(self.pattern_lists[trackno]):
while pattseq > seq:
pattlist.append((seq, -1))
seq += 1
pattlist.append((pattseq, pattnum))
seq += 1
for pattseq, pattnum in pattlist:
if pattnum == -1:
for note in self.all_notevals[trackno]:
self.all_track_notes[trackno][note].extend(
[shared.empty[is_drumtrack]] * shared.per_line)
continue
for note in self.all_notevals[trackno]:
if note in patterns[pattnum]:
events = patterns[pattnum][note]
for tick in range(shared.per_line):
if tick in events:
if is_drumtrack:
to_append = shared.get_inst_name(note +
shared.note2drums)
else:
to_append = shared.get_note_name(note)
else:
to_append = shared.empty[is_drumtrack]
self.all_track_notes[trackno][note].append(to_append)
else:
self.all_track_notes[trackno][note].extend(
[shared.empty[is_drumtrack]] * shared.per_line)
test = len(self.all_track_notes[trackno][note])
## print(test)
if test > self.total_length:
self.total_length = test
def print_instrument(self, trackno, stream=sys.stdout):
"""print the events for an instrument as a piano roll
trackno is the number of the track / sample to print data for
stream is a file-like object to write the output to
"""
data = []
unlettered = set()
for patt_no, props, patt_data in self.patterns[trackno]:
data.append(shared.patt_start.format(patt_no))
is_drumtrack = props['drumtrack']
printables = collections.defaultdict(list)
for key, note_events in patt_data.items():
seqnum = 0
events = []
if is_drumtrack:
notestr = shared.get_inst_name(key + shared.note2drums)
if notestr == '?':
unlettered.add('no letter yet for `{}`'.format(
shared.gm_drums[key + shared.note2drums][1]))
else:
key = shared.standard_printseq.index(notestr)
else:
notestr = shared.get_note_name(key) # (was - 12)
factor = shared.tick_factor
for i in range(factor * (note_events[-1] // factor + 1)):
if i in note_events:
events.append(notestr)
else:
events.append(shared.empty[is_drumtrack])
if (i + 1) % factor == 0:
seqnum += 1
if events != factor * [shared.empty[is_drumtrack]]:
delim = shared.sep[is_drumtrack]
printables[seqnum].append(
(key, delim.join(events)))
events = []
for key, pattern_lines in sorted(printables.items()):
printlines = sorted(pattern_lines)
if not is_drumtrack:
printlines = reversed(printlines)
data.extend([shared.line_start + y for x, y in printlines])
data.append('')
for line in data:
print(line, file=stream)
return unlettered
def print_instrument(self, sample, _out=sys.stdout):
"""print the events for an instrument as a piano roll
sample is the number of the sample to print data for
stream is a file-like object to write the output to
"""
for pattnum, pattern in enumerate(self.pattern_data[sample]):
print(shared.patt_start.format(pattnum + 1), file=_out)
pattlen = pattern['len']
for note in reversed(sorted([x for x in pattern if x != 'len'])):
events = pattern[note]
if events:
print(shared.line_start, end='', file=_out)
printable = []
for tick in range(pattlen):
if tick in events:
corr = note + 3 * shared.octave_length - 1 # comparability
next_note = shared.get_note_name(corr)
else:
next_note = shared.empty_note
printable.append(next_note)
print(' '.join(printable), file=_out)
print('', file=_out)
def prepare_print_instruments(self):
"""build complete timeline for (drum and regular) instrument events
"""
self.all_note_tracks = collections.defaultdict(
lambda: collections.defaultdict(list))
self.unlettered = set()
self.all_notes = collections.defaultdict(set)
# volgens mij moet ik hier weer uitgaan van de oldpatterns om daaruit een volledig track
# op te bouwen
# pattern lengtes zijn inmiddels toegevoegd in oldpatternlist, die kan ik gebruiken voor de
# totale lengte
self.total_length = 0
for trackno in self.instruments:
pattno, pattstart, pattlen = self.old_pattern_list[trackno][-1]
log('{}'.format(trackno, pattno, pattstart, pattlen))
if pattstart + pattlen > self.total_length:
self.total_length = pattstart + pattlen
log('self.total_length wordt {}'.format(self.total_length))
# determine highest event on track
for events in self.old_patterns[trackno][-1][2].values():
last_event = events[-1]
if pattstart + last_event == self.total_length:
self.total_length += 1
log('self.total_length wordt {}'.format(self.total_length))
test = self.total_length // 32
if test * 32 != self.total_length:
self.total_length = (test + 1) * 32
log('{} {}'.format(test, self.total_length))
for trackno in self.instruments:
is_drumtrack = self.old_patterns[trackno][0][1]['drumtrack']
pattdict = {}
# determine all notes used on this track and "buffer" the pattern data
for pattnum, _, pattdata in self.old_patterns[trackno]:
self.all_notes[trackno].update(pattdata.keys())
pattdict[pattnum] = pattdata
# fill al the gaps between patterns beforehand
for note in self.all_notes[trackno]:
if is_drumtrack:
notestr = shared.get_inst_name(note + shared.note2drums)
self.all_note_tracks[trackno][
notestr] = self.total_length * [
shared.empty[is_drumtrack]
]
else:
self.all_note_tracks[trackno][note] = self.total_length * [
shared.empty[is_drumtrack]
]
# fill in the separate events
for item in self.old_pattern_list[trackno]:
if len(item) == 2: # < 3
continue # no events found, so no length recorded
pattnum, pattstart = item[:2]
for note in self.all_notes[trackno]:
if is_drumtrack:
notestr = shared.get_inst_name(note +
shared.note2drums)
if notestr == '?':
self.unlettered.add(
'no letter yet for `{}`'.format(
shared.gm_drums[note +
shared.note2drums][1]))
else:
notestr = shared.get_note_name(note)
if note not in pattdict[pattnum]:
continue
for event in pattdict[pattnum][note]:
## log('track {} patt {} start {} note {} event {}'.format(
## trackno, pattnum, pattstart, note, event))
ix = notestr if is_drumtrack else note
event += pattstart
## log('{} {} {}'.format(
## ix, len(self.all_note_tracks[trackno][ix]), event))
## if evt == len(self.all_note_tracks[trackno][ix]):
## for ix2 in self.all_note_tracks[trackno]
self.all_note_tracks[trackno][ix][event] = notestr
