def composificate(tracks1, tracks2):
"""Extends tracks1 (presumed to be some sort of percussion) to the length of
track2. Returns a Composition."""
compo = Composition()
#Extend each track1 to the length of the corresponding track2
ntracks = []
if len(tracks1) < len(tracks2):
for track in tracks1:
idx = tracks1.index(track)
track = extend_track(track, len(tracks2[idx]))
ntracks.append(track)
else:
ntracks = tracks1
percus = sum_tracks(ntracks)
melody = sum_tracks(tracks2)
piano = MidiInstrument()
piano.name = 'Acoustic Grand Piano'
percussion = MidiInstrument()
percussion.name = 'Woodblock'
percus.instrument = percussion
melody.instrument = piano
compo.add_track(percus)
compo.add_track(melody)
return compo
def track_creator(instrument_name, channel):
instrument = MidiInstrument()
track = Track(instrument, channel=channel)
instrument.name = instrument_name
track.instrument.instrument_nr = MidiInstrument.names.index(
instrument_name)
return track
def find_instrument(instrument, instrument_group):
if instrument:
try:
instrument_nr = MidiInstrument.names.index(instrument)
except ValueError:
instrument_nr = int(instrument)
elif instrument_group:
# Choose a random from the instrument_group
instrument = Waitstaff.choose_from_group(instrument_group)
instrument_nr = MidiInstrument.names.index(instrument)
else:
instrument_nr = random.randint(0, len(MidiInstrument.names))
midi_instrument = MidiInstrument()
midi_instrument.name = MidiInstrument.names[instrument_nr]
midi_instrument.instrument_nr = instrument_nr
return midi_instrument
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 composificate(tracks1, tracks2):
"""Extends tracks1 (presumed to be some sort of percussion) to the length of
track2. Returns a Composition."""
compo = Composition()
#Extend each track1 to the length of the corresponding track2
ntracks = []
if len(tracks1) < len(tracks2):
for track in tracks1:
idx = tracks1.index(track)
track = extend_track(track, len(tracks2[idx]))
ntracks.append(track)
else:
ntracks = tracks1
percus = sum_tracks(ntracks)
melody = sum_tracks(tracks2)
piano = MidiInstrument()
piano.name = 'Acoustic Grand Piano'
percussion = MidiInstrument()
percussion.name = 'Woodblock'
percus.instrument = percussion
melody.instrument = piano
compo.add_track(percus)
compo.add_track(melody)
return compo
def create_instrument(low, high):
xylo = MidiInstrument()
'''
9 = 'Glockenspiel',
11 = 'Vibraphone',
12 = 'Marimba',
13 = 'Xylophone'
'''
xylo.instrument_nr = 11
xylo.set_range((low, high))
xylo.name = 'ballophone'
return xylo
def generate_track(g, n, name):
root = np.random.randint(0, n)
edges = nx.bfs_edges(g.G, root)
nodes = [root] + [v for u, v in edges]
m = MidiInstrument(4)
t = Track()
track = []
t.instrument = m
nNotes = 0
print("##### Creating Tracks")
for x in nodes:
value = t.add_notes(NoteContainer(g.G.nodes[x]["note"]),
g.G.nodes[x]["duration"])
t.bars[-1].set_meter((n, 1))
track.append(g.G.nodes[x]["note"])
nNotes = nNotes + 1
print("##### Notes Generated:")
print(*t)
print("##### Number of notes:")
print(nNotes)
midi_file_out.write_Track(name + ".mid", t)
return t
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)
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)
write_Bar("test3.mid", b, 200)
write_Bar("test4.mid", b2, 200, 2)
write_Track("test5.mid", t, 120)
from pydub import AudioSegment import os import itertools from mingus.containers.instrument import MidiInstrument import finalpercussion from midi2audio import FluidSynth from mingus.containers.mt_exceptions import NoteFormatError snareplayer = FluidSynthSequencer() baseplayer = FluidSynthSequencer() highhatplayer = FluidSynthSequencer() cymbalplayer = FluidSynthSequencer() tomplayer = FluidSynthSequencer() lefthandplayer = FluidSynthSequencer() righthandplayer = FluidSynthSequencer() basse = MidiInstrument() basse.instrument_nr = 32 guitar = MidiInstrument() guitar.instrument_nr = 25 string = MidiInstrument() string.instrument_nr = 48 brass = MidiInstrument() brass.instrument_nr = 61 synth = MidiInstrument() synth.instrument_nr = 81 frhorn = MidiInstrument()
def set_track_instrument(track, instr, channel=0): m = MidiInstrument() m.channel = channel m.instrument_nr = instr track.instrument = m
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 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)
from mingus.midi import fluidsynth, midi_file_out
from mingus.midi.fluidsynth import FluidSynthSequencer
from mingus.containers import Bar, Track, Composition
from mingus.containers.instrument import MidiInstrument
from midi2audio import FluidSynth
ins = MidiInstrument()
ins.instrument_nr = 1
player = FluidSynthSequencer()
fluidsynth.init('Timbre.sf2', player)
t = Track()
t.add_notes("C-3", 4)
t.instrument = ins
midi_file_out.write_Track('instrumenttest1.mid', t, bpm=500)
FluidSynth("Timbre.sf2").midi_to_audio('instrumenttest1.mid',
'instrumenttest1.wav')
