class TrackBuilder(object):
def __init__(self):
self.track = Track()
self.previous = None
def add_symbol(self, name):
symbol = Symbol.get_symbol(name)
self.previous = symbol
self.accidental = 0
symbol.action(self)
def add_note(self, note):
mnote = mingusNote(note.n)
self.track.add_notes(mnote, note.duration)
def add_rest(self, rest):
self.track.add_notes(None, rest.duration)
def set_clef(self, clef):
self.clef = clef
def add_accidental(self, accidental):
if accidental.name == 'sharp':
self.accidental = 1
elif accidental.name == 'flat':
self.accidental = -1
else:
self.accidental = 0
def flush(self):
return self.track
def setUp(self):
self.commonbar = Bar()
self.ebar = Bar('E', (4, 4))
self.fbar = Bar('F', (6, 8))
self.tbar = Bar('C', (4, 4))
self.mbar = Bar('C', (4, 4))
self.a_minor_bar = Bar('a', (4, 4))
self.b_flat_minor_bar = Bar('bb', (4, 4))
self.f_sharp_minor_bar = Bar('f#', (4, 4))
for y in [self.commonbar, self.ebar, self.fbar]:
map(lambda x: y + x, ['C', 'E', 'G', 'B'])
map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [
'C',
'E',
'G',
'B',
'C',
'E',
])
map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ['C', 'E'])
map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ['G', 'B', 'C'
])
self.track1 = Track()
self.track1 + self.commonbar
self.track2 = Track()
self.track2 + self.commonbar
self.track2 + self.ebar
self.composition1 = Composition()
self.composition1.add_track(self.track1)
self.composition2 = Composition()
self.composition2.add_track(self.track1)
self.composition2.add_track(self.track2)
def setUp(self):
# LilyPond output files are created in current working directory
self.tempdir = tempfile.mkdtemp()
self.oldcwd = os.getcwd()
os.chdir(self.tempdir)
self.commonbar = Bar()
self.ebar = Bar("E", (4, 4))
self.fbar = Bar("F", (6, 8))
self.tbar = Bar("C", (4, 4))
self.mbar = Bar("C", (4, 4))
self.a_minor_bar = Bar("a", (4, 4))
self.b_flat_minor_bar = Bar("bb", (4, 4))
self.f_sharp_minor_bar = Bar("f#", (4, 4))
for y in [self.commonbar, self.ebar, self.fbar]:
list(map(lambda x: y + x, ["C", "E", "G", "B"]))
for x in ["C", "E", "G", "B", "C", "E"]:
self.tbar.place_notes(NoteContainer(x), 6)
for x in ["C", "E"]:
self.mbar.place_notes(NoteContainer(x), 4)
for x in ["G", "B", "C"]:
self.mbar.place_notes(NoteContainer(x), 6)
self.track1 = Track()
self.track1 + self.commonbar
self.track2 = Track()
self.track2 + self.commonbar
self.track2 + self.ebar
self.composition1 = Composition()
self.composition1.add_track(self.track1)
self.composition2 = Composition()
self.composition2.add_track(self.track1)
self.composition2.add_track(self.track2)
def test_transpose(self):
t = Track()
t + 'C'
t + 'E'
t.transpose('3')
s = Track()
s + 'E'
s + 'G#'
self.assertEqual(s, t)
def screen_to_track(user):
"""Returns a mingus NoteContainer generated from
the screenname of a person"""
user_id = user.idnumber
id_88 = base88_encode(user_id)
out_track = Track()
for i in id_88:
out_track.add_notes(Note().from_int(i))
return out_track
def words_to_track(words):
"""Converts a string to a track, based on the the unicode code point, as
given by ord()"""
words_88 = [base88_encode(ord(x)) for x in words]
notes = [Note().from_int(x) for letter in words_88 for x in letter]
out_track = Track()
for i in notes:
out_track.add_notes(i)
return out_track
def extend_track(track, length):
"""Repeats the bars of a track until it reaches the given length."""
new_track = Track()
while len(new_track) < length:
for i in track:
new_track.add_bar(i)
if len(new_track) == length:
return new_track
return new_track
def extend_track(track, length):
"""Repeats the bars of a track until it reaches the given length."""
new_track = Track()
while len(new_track) < length:
for i in track:
new_track.add_bar(i)
if len(new_track) == length:
return new_track
return new_track
def words_to_track(words):
"""Converts a string to a track, based on the the unicode code point, as
given by ord()"""
words_88 = [base88_encode(ord(x)) for x in words]
notes = [Note().from_int(x) for letter in words_88 for x in letter]
out_track = Track()
for i in notes:
out_track.add_notes(i)
return out_track
def screen_to_track(user):
"""Returns a mingus NoteContainer generated from
the screenname of a person"""
user_id = user.idnumber
id_88 = base88_encode(user_id)
out_track = Track()
for i in id_88:
out_track.add_notes(Note().from_int(i))
return out_track
def test_transpose(self):
t = Track()
t + 'C'
t + 'E'
t.transpose('3')
s = Track()
s + 'E'
s + 'G#'
self.assertEqual(s, t)
def test_transpose(self):
t = Track()
t + "C"
t + "E"
t.transpose("3")
s = Track()
s + "E"
s + "G#"
self.assertEqual(s, t)
def test_equality(self):
self.assertEqual(self.i, self.p)
self.assertEqual(self.i, self.g)
self.assertEqual(self.i, self.tr)
t = Track()
t + "C"
t + "E"
s = Track()
s + "E"
s + "G#"
self.assertNotEqual(t, s)
u = Track()
u + "E"
u + "G#"
self.assertEqual(s, u)
def generate_and_write_music(
output_file,
music_length,
lengths_distribution,
bpm,
):
import mingus.core.notes as notes
from mingus.containers.note import Note
from mingus.containers.track import Track
from mingus.midi import midi_file_out
track = Track()
for note, length in generate_music(music_length, lengths_distribution, note_base=36):
n = Note()
n.from_int(note)
track.add_notes(n, length)
midi_file_out.write_Track(output_file, track, bpm=bpm)
def setup_composition(nbars=64, ntracks=2, quant=16): comp = Composition() tks =[Track() for i in xrange(ntracks)] for i in xrange(ntracks): bars = [Bar() for j in xrange(nbars)] for j in xrange(nbars): init_bar(bars[j], quant) tks[i] + bars[j] comp + tks[i] return comp
def __init__(self, nsteps=16, nbars=16, tempo=120, duration=16):
# self.bd = Note('C', 2) # bass drum
self.bd = Note('B', 1) # bass drum
self.bd.channel = 9
self.lt = Note('F', 2) # lo tom
self.lt.channel = 9
self.ht = Note('B', 2) # hi tom
self.ht.channel = 9
self.lb = Note('C#', 4) # lo bongo
self.lb.channel = 9
self.hb = Note('C', 4) # hi bongo
self.hb.channel = 9
self.ch = Note('F#', 2) # closed hat
self.ch.channel = 9
self.oh = Note('A#', 2) # open hat
self.oh.channel = 9
self.sn = Note('D', 2) # snare
self.sn.channel = 9
self.DRMAP={"bd":self.bd, "sn":self.sn, "ch":self.ch, "oh":self.oh,
"lt":self.lt, "ht":self.ht, "hb":self.hb, "lb":self.lb}
for x in self.DRMAP.keys():
self.DRMAP[x].velocity = 100
self.DRMAP[x].duration = duration
self.tk = Track()
self.bds=""
self.sns=""
self.hts=""
self.lts=""
self.chs=""
self.ohs=""
self.lbs=""
self.hbs=""
self.bdv=[]
self.snv=[]
self.htv=[]
self.ltv=[]
self.chv=[]
self.ohv=[]
self.lbv=[]
self.hbv=[]
self.m = MidiInstrument()
# TR-808 kit = 25 (26 but zero-based!)
# self.m.instrument_nr = 25
self.m.instrument_nr = 0
self.m.channel = 9
self.tk.instrument = self.m
self.nsteps = nsteps
self.dur = duration
self.n_bars = nbars
self.tempo = tempo
self.STRMAP={"bd":self.bds, "sn":self.sns, "ch":self.chs, "oh":self.ohs,
"lt":self.lts, "ht":self.hts, "hb":self.hbs, "lb":self.lbs}
self.VARMAP={"bd":self.bdv, "sn":self.snv, "ch":self.chv, "oh":self.ohv,
"lt":self.ltv, "ht":self.htv, "hb":self.hbv, "lb":self.lbv}
self.vartype = self._OR_VAR_
def rebuild_composition(old, xylo, cutoff):
lowest = Note.__int__(Note('C', 8))
highest = Note.__int__(Note('C', 0))
new = Composition()
for i in old.selected_tracks:
t = Track()
t.instrument = xylo
for bar in old[i]:
b = Bar()
b.key.name = bar.key.name
b.set_meter(bar.meter)
# note value per beat == the denominator in time signature
dem = b.meter[1]
for lst in bar:
value = lst[1]
if (is_garbage(value, dem, cutoff[old.selected_tracks.index(i)])):
continue
# do not include lists without notes
if (not lst[2]):
continue
nc = NoteContainer()
for note in lst[2]:
if (Note.__int__(note) < lowest): lowest = Note.__int__(note)
if (Note.__int__(note) > highest): highest = Note.__int__(note)
nc + note
b.place_notes(nc, value)
t.add_bar(b)
new.add_track(t)
# can't do the transposing until all notes in all tracks have been
# compared against lowest and highest, which is why it is done here
n1 = Note()
n2 = Note()
low = n1.from_int(lowest)
high = n2.from_int(highest)
# print("lowest and highest notes:", low, high)
if (not xylo.notes_in_range([low, high])):
new = transposer(new, lowest, highest, xylo)
return new
for i in range(len(composition.tracks)):
m.tracks[i].play_Track(composition.tracks[i])
repeat -= 1
return m.write_file(file, verbose)
if __name__ == "__main__":
from mingus.containers.note_container import NoteContainer
from mingus.containers.bar import Bar
from mingus.containers.track import Track
from mingus.containers.instrument import MidiInstrument
b = Bar()
b2 = Bar("Ab", (3, 4))
n = NoteContainer(["A", "C", "E"])
t = Track()
b + n
b + []
b + n
b + n
b2 + n
b2 + n
b2 + []
t + b
t + b
m = MidiInstrument()
m.instrument_nr = 13
t.instrument = m
t.name = "Track Name Test"
write_NoteContainer("test.mid", n)
write_Bar("test2.mid", b)
def MIDI_to_Composition(self, file):
(header, track_data) = self.parse_midi_file(file)
c = Composition()
bpm = 120
if header[2]['fps']:
print "Don't know how to parse this yet"
return c
ticks_per_beat = header[2]['ticks_per_beat']
for track in track_data:
t = Track()
b = Bar()
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
meter = (4, 4)
key = 'C'
for e in track:
(deltatime, event) = e
duration = float(deltatime) / (ticks_per_beat * 4.0)
if duration != 0.0:
duration = 1.0 / duration
if len(b.bar) > 0:
current_length = b.bar[-1][1]
b.bar[-1][1] = duration
if current_length - duration != 0:
b.current_beat -= 1.0 / current_length
b.current_beat += 1.0 / duration
if not b.place_notes(NoteContainer(), duration):
t + b
b = Bar(key, meter)
b.place_notes(NoteContainer(), duration)
if event['event'] == 8:
if deltatime == 0:
pass
elif event['event'] == 9:
# note on
n = Note(notes.int_to_note(event['param1'] % 12),
event['param1'] / 12 - 1)
n.channel = event['channel']
n.velocity = event['param2']
if len(b.bar) > 0:
b.bar[-1][2] + n
else:
b + n
elif event['event'] == 10:
# note aftertouch
pass
elif event['event'] == 11:
# controller select
pass
elif event['event'] == 12:
# program change
i = MidiInstrument()
i.instrument_nr = event['param1']
t.instrument = i
elif event['event'] == 0x0f:
# meta event Text
if event['meta_event'] == 1:
pass
elif event['meta_event'] == 3:
# Track name
t.name = event['data']
elif event['meta_event'] == 6:
# Marker
pass
elif event['meta_event'] == 7:
# Cue Point
pass
elif event['meta_event'] == 47:
# End of Track
pass
elif event['meta_event'] == 81:
# Set tempo warning Only the last change in bpm will get
# saved currently
mpqn = self.bytes_to_int(event['data'])
bpm = 60000000 / mpqn
elif event['meta_event'] == 88:
# Time Signature
d = event['data']
thirtyseconds = self.bytes_to_int(d[3])
metronome = self.bytes_to_int(d[2]) / 24.0
denom = 2**self.bytes_to_int(d[1])
numer = self.bytes_to_int(d[0])
meter = (numer, denom)
b.set_meter(meter)
elif event['meta_event'] == 89:
# Key Signature
d = event['data']
sharps = self.bytes_to_int(d[0])
minor = self.bytes_to_int(d[0])
if minor:
key = 'A'
else:
key = 'C'
for i in xrange(abs(sharps)):
if sharps < 0:
key = intervals.major_fourth(key)
else:
key = intervals.major_fifth(key)
b.key = Note(key)
else:
print 'Unsupported META event', event['meta_event']
else:
print 'Unsupported MIDI event', event
t + b
c.tracks.append(t)
return (c, bpm)
def __init__(self):
self.track = Track()
self.previous = None
def MIDI_to_Composition(self, file):
(header, track_data) = self.parse_midi_file(file)
# print('MIDI_to_Composition:', track_data[1])
# print('===')
# print(track_data[2])
# for j in track_data[2]:
# if j[1]['event'] == 9 or j[1]['event'] == 8:
# print('MIDI_to_Composition:', j[0], j[1]['event'], Note(notes.int_to_note(j[1]['param1'] % 12)))
c = Composition()
if header[2]['fps']:
print("Don't know how to parse this yet")
return c
ticks_per_beat = header[2]['ticks_per_beat']
for track_idx, track in enumerate(track_data):
t = Track()
b = Bar()
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
meter = (4, 4)
key = 'C'
NOTE_ON_counter = 0
for event_idx, e in enumerate(track):
(deltatime, event) = e
duration = float(deltatime) / (ticks_per_beat * 4.0)
if NOTE_ON_counter == 0 and duration != 0 and event['event'] == 9: # then we need to add a rest before playing
b.place_rest(1.0/duration)
NOTE_ON_counter += 1
# this logic is nice and clear...
if duration != 0.0:
duration = 1.0 / duration
if len(b.bar) > 0:
current_length = b.bar[-1][1]
b.bar[-1][1] = duration
if current_length - duration != 0:
b.current_beat -= 1.0 / current_length
b.current_beat += 1.0 / duration
if not b.place_notes(NoteContainer(), duration):
t + b
b = Bar(key, meter)
b.place_notes(NoteContainer(), duration)
if event['event'] == 8:
if deltatime == 0:
pass
elif event['event'] == 9:
# note on
n = Note(notes.int_to_note(event['param1'] % 12),
np.floor(event['param1'] / 12)) # this was event['param1']/12 - 1 but that gives skewed, incorrect octaves
n.channel = event['channel']
n.velocity = event['param2']
if len(b.bar) > 0:
b.bar[-1][2] + n
else:
b + n
elif event['event'] == 10:
# note aftertouch
pass
elif event['event'] == 11:
# controller select
pass
elif event['event'] == 12:
# program change
i = MidiInstrument()
i.instrument_nr = event['param1']
t.instrument = i
elif event['event'] == 0x0f:
# meta event Text
if event['meta_event'] == 1:
pass
elif event['meta_event'] == 3:
# Track name
t.name = event['data']
elif event['meta_event'] == 6:
# Marker
pass
elif event['meta_event'] == 7:
# Cue Point
pass
elif event['meta_event'] == 47:
# End of Track
pass
elif event['meta_event'] == 81:
# Set tempo warning Only the last change in bpm will get
# saved currently
mpqn = self.bytes_to_int(event['data'])
bpm = 60000000 / mpqn
elif event['meta_event'] == 88:
# Time Signature
d = event['data']
thirtyseconds = d[3] #self.bytes_to_int(d[3])
metronome = d[2]//24.0 #self.bytes_to_int(d[2]) / 24.0
denom = 2**d[1] #2 ** self.bytes_to_int(d[1])
numer = d[0]#self.bytes_to_int(d[0])
meter = (numer, denom)
b.set_meter(meter)
elif event['meta_event'] == 89:
# Key Signature
d = event['data']
sharps = d[0] #self.bytes_to_int(d[0])
minor = d[0] #self.bytes_to_int(d[0])
if minor:
key = 'A'
else:
key = 'C'
for i in range(abs(sharps)):
if sharps < 0:
key = intervals.major_fourth(key)
else:
key = intervals.major_fifth(key)
b.key = Note(key)
else:
print('Unsupported META event', event['meta_event'])
else:
print('Unsupported MIDI event', event)
t + b
c.tracks.append(t)
return (c, bpm)
def from_Bar(bar):
c = Composition()
t = Track()
t.add_bar(bar)
c.add_track(t)
return _composition2musicxml(c).toprettyxml()
def setUp(self):
self.i = Track(Instrument())
self.p = Track(Piano())
self.g = Track(Guitar())
self.tr = Track()
def MIDI_to_Composition(self, file):
(header, track_data) = self.parse_midi_file(file)
c = Composition()
if header[2]['fps']:
print "Don't know how to parse this yet"
return c
ticks_per_beat = header[2]['ticks_per_beat']
for track in track_data:
t = Track()
b = Bar()
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
meter = (4, 4)
key = 'C'
for e in track:
(deltatime, event) = e
duration = float(deltatime) / (ticks_per_beat * 4.0)
if duration != 0.0:
duration = 1.0 / duration
if deltatime != 0:
if not b.place_notes(NoteContainer(), duration):
t + b
b = Bar(key, meter)
b.place_notes(NoteContainer(), duration)
if event['event'] == 8:
if deltatime == 0:
pass
elif event['event'] == 9:
# note on
n = Note(notes.int_to_note(event['param1'] % 12),
event['param1'] / 12 - 1)
n.channel = event['channel']
n.velocity = event['param2']
if len(b.bar) > 0:
b.bar[-1][2] + n
else:
b + n
elif event['event'] == 10:
# note aftertouch
pass
elif event['event'] == 11:
# controller select
pass
elif event['event'] == 12:
# program change
i = MidiInstrument()
i.instrument_nr = event['param1']
t.instrument = i
elif event['event'] == 0x0f:
# meta event Text
if event['meta_event'] == 1:
pass
elif event['meta_event'] == 3:
# Track name
t.name = event['data']
elif event['meta_event'] == 6:
# Marker
pass
elif event['meta_event'] == 7:
# Cue Point
pass
elif event['meta_event'] == 47:
# End of Track
pass
elif event['meta_event'] == 81:
# Set tempo warning Only the last change in bpm will get
# saved currently
mpqn = self.bytes_to_int(event['data'])
bpm = 60000000 / mpqn
elif event['meta_event'] == 88:
# Time Signature
d = event['data']
thirtyseconds = self.bytes_to_int(d[3])
metronome = self.bytes_to_int(d[2]) / 24.0
denom = 2 ** self.bytes_to_int(d[1])
numer = self.bytes_to_int(d[0])
meter = (numer, denom)
b.set_meter(meter)
elif event['meta_event'] == 89:
# Key Signature
d = event['data']
sharps = self.bytes_to_int(d[0])
minor = self.bytes_to_int(d[0])
if minor:
key = 'A'
else:
key = 'C'
for i in xrange(abs(sharps)):
if sharps < 0:
key = intervals.major_fourth(key)
else:
key = intervals.major_fifth(key)
b.key = Note(key)
else:
print 'Unsupported META event', event['meta_event']
else:
print 'Unsupported MIDI event', event
t + b
c.tracks.append(t)
return (c, bpm)
def sum_tracks(tracks):
new_track = Track()
for track in tracks:
for bar in track:
new_track.add_bar(bar)
return new_track
def sum_tracks(tracks):
new_track = Track()
for track in tracks:
for bar in track:
new_track.add_bar(bar)
return new_track
def from_Bar(bar):
c = Composition()
t = Track()
t.add_bar(bar)
c.add_track(t)
return _composition2musicxml(c).toprettyxml()
name = note_string[0:1].upper()
number = name_to_number.NOTES.index(name)
acc = accidentals(note_string)
return mod12(number + acc)
name_to_number.NOTES = "C . D . E F . G . A . B".split()
if __name__ == '__main__':
import argparse
import random
# from mingus.containers.bar import Bar
from mingus.containers.track import Track
notes = [0]
for t in range(30):
note = notes[-1]
notes.append(note + random.randint(0, 12))
t = Track()
notes = map(note_name, notes)
for n in notes:
t.add_notes(n)
parser = argparse.ArgumentParser()
parser.add_argument('--output', type=str, default='out.mid')
args = parser.parse_args()
from mingus.midi import midi_file_out
midi_file_out.write_Track(args.output, t)
