def noteStateMatrixToMidi(statematrix, name="example"):
statematrix = numpy.asarray(statematrix)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
span = upperBound - lowerBound
#tickscale = 55
tickscale = 110
lastcmdtime = 0
prevstate = [[0, 0] for x in range(span)]
for time, state in enumerate(statematrix + [prevstate[:]]):
offNotes = []
onNotes = []
for i in range(span):
n = state[i]
p = prevstate[i]
if p[0] == 1:
if n[0] == 0:
offNotes.append(i)
elif n[1] == 1:
offNotes.append(i)
onNotes.append(i)
elif n[0] == 1:
onNotes.append(i)
for note in offNotes:
track.append(
midi.NoteOffEvent(tick=(time - lastcmdtime) * tickscale,
pitch=note + lowerBound))
lastcmdtime = time
for note in onNotes:
track.append(
midi.NoteOnEvent(tick=(time - lastcmdtime) * tickscale,
velocity=40,
pitch=note + lowerBound))
lastcmdtime = time
prevstate = state
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile("{}.mid".format(name), pattern)
def save_piece(piece, file_path):
piece = np.asarray(piece)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
span = UPPER_BOUND - LOWER_BOUND
tickscale = 55
lastcmdtime = 0
prevstate = [[0, 0] for x in range(span)]
for time, state in enumerate(piece + [prevstate[:]]):
offNotes = []
onNotes = []
for i in range(span):
n = state[i]
p = prevstate[i]
if p[0] == 1:
if n[0] == 0:
offNotes.append(i)
elif n[1] == 1:
offNotes.append(i)
onNotes.append(i)
elif n[0] == 1:
onNotes.append(i)
for note in offNotes:
track.append(
midi.NoteOffEvent(tick=(time - lastcmdtime) * tickscale,
pitch=note + LOWER_BOUND))
lastcmdtime = time
for note in onNotes:
track.append(
midi.NoteOnEvent(tick=(time - lastcmdtime) * tickscale,
velocity=40,
pitch=note + LOWER_BOUND))
lastcmdtime = time
prevstate = state
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile(file_path, pattern)
def hide(self, midi_file_name, message):
result = None
pattern = self.get_pattern(midi_file_name)
number_of_tracks = len(pattern)
# in case the midi file has no tracks (that means, no music)
# we add one so we can add the hidden data there
# this track will not have any Note events, so it will not add sound
# If it does have one, we work with that track
if number_of_tracks == 0:
# Instantiate a MIDI Track (contains a list of MIDI events)
track = midi.Track()
# Append the track to the pattern
pattern.append(track)
# Now we need to add a termination line, so we know we need to stop reading
# Instantiate a MIDI note off event, append it to the track
off = midi.NoteOffEvent(tick=73, pitch=midi.G_3)
pattern[0].insert(0, off)
# Insert the hidden messages as Program change events at the start of the list.
# (you could also add them at the end as the user will not detect them since
# no sound would be comming out .... but it has one problem
# If you want to verify the insertion
# You have to scroll to the end of the file and check. If the midi file
# is really big, this could be really time consuming)
#
# We cannot add them in the middle, since the change of instruments could be
# noticeable
channelToAlter = 16 # This channel might not even be used by any other event
for char in message:
number = ord(char)
change_program = midi.ProgramChangeEvent(tick=0,
channel=channelToAlter,
data=[number])
pattern[0].insert(0, change_program)
on = midi.NoteOnEvent(tick=0, velocity=0, pitch=midi.G_3)
pattern[0].insert(0, on)
new_midi_file_name = "secret_in_" + midi_file_name
self.save_midi_file(pattern, new_midi_file_name)
def noteStateMatrixToMidi(statematrix, name="example", span=span):
statematrix = np.array(statematrix)
print statematrix, len(statematrix.shape), statematrix.shape, span
if not len(statematrix.shape) == 3:
statematrix = np.dstack((statematrix[:, :span], statematrix[:, span:2*span], statematrix[:, 2*span:]))
statematrix = np.asarray(statematrix)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
span = upperBound-lowerBound
tickscale = 55
lastcmdtime = 0
prevstate = [[0,0,0] for x in range(span)]
for time, state in enumerate(statematrix + [prevstate[:]]):
offNotes = []
onNotes = []
for i in range(span):
n = state[i]
p = prevstate[i]
if (p[0])== 1:
if (n[0]) == 0:
offNotes.append((i, n[2]))
elif (n[1]) == 1:
offNotes.append((i, p[2]))
onNotes.append((i, n[2]))
elif (n[0]) == 1:
onNotes.append((i, n[2]))
print onNotes
for note in offNotes:
track.append(midi.NoteOffEvent(tick=(time-lastcmdtime)*tickscale, velocity = (int(note[1]*50)+45)%128, pitch=note[0]+lowerBound))
lastcmdtime = time
for note in onNotes:
track.append(midi.NoteOnEvent(tick=(time-lastcmdtime)*tickscale, velocity=(int(note[1]*50)+45)%128, pitch=note[0]+lowerBound))
lastcmdtime = time
prevstate = state
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile("{}.mid".format(name), pattern)
def notetomidi(notearray, i, style_code, reward):
mini_len = 64
note_len = mini_len
#print (notearray)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
#style_code = #notearray[0]
notearray = notearray[1:]
if style_code == 2: #hymn
h, f = 3, 8
elif style_code == 0: #classical
h, f = 0, 2
elif style_code == 1: #jazz
h, f = 1, 6
elif style_code == 3: #vgm
h, f = 0, 8
else:
h, f = 0, 5
last_note = 0
for n in notearray:
if n == 1:
note_len = note_len + mini_len
elif int(n) > 1:
if note_len == mini_len:
note_len += mini_len * (random.randint(h, f))
track.append(
midi.NoteOnEvent(tick=note_len, channel=0, data=[last_note,
0]))
track.append(
midi.NoteOnEvent(tick=0, channel=0, data=[n + 34, 110]))
last_note = n + 34
note_len = mini_len
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
style = ["classical", "jazz", "hymn", "vgm"]
#print (style_code)
midi.write_midifile(
"example" + str(i) + style[style_code] + str(reward) + ".mid", pattern)
def text2midi(text,
timing=[],
scale=[0, 2, 4, 5, 7, 9, 11],
name="example.mid",
baselet="a",
key=60,
transformation=letter2note,
space_func=skip_space,
base_duration=100,
delay=0,
note_velocity=20,
file_func=create_midi,
**kwargs):
text_length = len(text)
timing_length = len(timing)
if timing_length < text_length:
dif = text_length - timing_length
timing += dif * [1]
elif timing_length > text_length:
timing = timing[:text_length]
pattern = midi.Pattern(resolution=320)
track = midi.Track()
pattern.append(track)
for i in range(text_length):
letter = text[i]
if letter == ' ':
on, off = space_func(timing[i], base_duration, delay,
note_velocity)
else:
note = transformation(letter, scale, key, baselet, space_func)
on, off = note_sound(note, timing[i], base_duration, delay,
note_velocity)
track.append(on)
track.append(off)
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
file_func(name, pattern, **kwargs)
def sing(seq):
'''
It turns a sequence of pitches into a midi.
You can alternate the resolution to change its speed.
'''
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
#resolution
pattern.resolution = 200
for note in seq:
on = midi.NoteOnEvent(tick=0, velocity=50, pitch=note)
track.append(on)
off = midi.NoteOffEvent(tick=100, pitch=note)
track.append(off)
track.append(midi.EndOfTrackEvent(tick=1))
midi.write_midifile("song.mid", pattern)
def noteStateMatrixToMidi(statematrix, name="example", span=span):
statematrix = np.array(statematrix)
if not len(statematrix.shape) == 3:
statematrix = np.dstack((statematrix[:, :span], statematrix[:, span:]))
statematrix = np.asarray(statematrix)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
span = upperBound-lowerBound
tickscale = 55
lastcmdtime = 0
prevstate = [[0,0] for x in range(span)]
for time, state in enumerate(statematrix + [prevstate[:]]):
offNotes = []
onNotes = []
for i in range(span):
n = state[i]
p = prevstate[i]
if p[0] == 1:
if n[0] == 0:
offNotes.append(i)
elif n[1] == 1:
offNotes.append(i)
onNotes.append(i)
elif n[0] == 1:
onNotes.append(i)
for note in offNotes:
track.append(midi.NoteOffEvent(tick=(time-lastcmdtime)*tickscale, pitch=note+lowerBound))
lastcmdtime = time
for note in onNotes:
track.append(midi.NoteOnEvent(tick=(time-lastcmdtime)*tickscale, velocity=40, pitch=note+lowerBound))
lastcmdtime = time
prevstate = state
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
path = os.getcwd()
path = path+'\\gen'
midi.write_midifile("{}\\{}.mid".format(path, name), pattern)
def main():
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
pitchs = [1, 3, 5, 1, 5, 6, 8, 8, 10, 8, 6, 5, 1, 3, -4, 1]
pitchs = [p + 60 for p in pitchs]
tempos = [2, 2, 2, 2, 2, 2, 4, 1, 1, 1, 1, 2, 2, 2, 2, 4]
repeats = [4, 3, 6, 3]
print('resolution = ', pattern.resolution)
idx = 0
tmp_pitchs = pitchs
tmp_tempos = tempos
pitchs, tempos = (list() for _ in range(2))
for r in repeats:
pitchs += tmp_pitchs[idx:idx + r] * 2
tempos += tmp_tempos[idx:idx + r] * 2
idx += r
hmn = [0]
pitchs = [tuple(p + i for i in hmn) for p in pitchs]
for ps, t in zip(pitchs, tempos):
for p in ps:
track_append(track, ON, 0, p)
for idx, p in enumerate(ps):
track_append(track, OFF, 50 * t if idx == 0 else 0, p)
# tempos = [2, 2, 2]
# for p in pitchs:
# track_append(track, ON, 0, p)
# track_append(track, OFF, 500, 61)
# for p, t in zip(pitchs, [0]+tempos):
# track_append(track, ON, 50*t, p)
# track_append(track, OFF, 50*t, p)
# for ps, t in zip(zip(pitchs, pitchs_2), tempos):
# track_append(track, ON, 0, ps[0])
# track_append(track, ON, 0, ps[1])
# track_append(track, OFF, 50*t, ps[0])
# track_append(track, OFF, 0, ps[1])
track_append(track, EOF, tick=1)
midi.write_midifile("tiger.mid", pattern)
def sequence_to_midi(state_matrix, filepath, meta_info=None):
resolution, tempo_event = meta_info if meta_info else None
pattern = midi.Pattern(resolution=resolution)
track = midi.Track()
pattern.append(track)
if tempo_event:
track.append(tempo_event)
notes_on, _ = state_diff([0] * 128, state_matrix[0])
for note in notes_on:
track.append(midi.NoteOnEvent(tick=0, channel=0, data=note))
current_state_index = 0
while current_state_index < len(state_matrix):
next_state_index = get_next_different_state(state_matrix,
current_state_index)
ticks_elapsed = next_state_index - current_state_index
current_state = state_matrix[current_state_index]
next_state = state_matrix[next_state_index] if next_state_index < len(
state_matrix) else [0] * 128
notes_on, notes_off = state_diff(current_state, next_state)
for note in notes_on:
track.append(
midi.NoteOnEvent(tick=ticks_elapsed, channel=0, data=note))
ticks_elapsed = 0
for note in notes_off:
track.append(
midi.NoteOffEvent(tick=ticks_elapsed, channel=0, data=note))
ticks_elapsed = 0
current_state_index = next_state_index
track.append(midi.EndOfTrackEvent(tick=1))
midi.write_midifile(filepath, pattern)
return pattern
def flatten(pattern):
# Takes a MIDI pattern (defined in the midi package) with multiple tracks
# and returns a single track containing every event in the original pattern,
# with absolute tick values instead of relative.
# Copy the original pattern
a = copy.copy(pattern)
# Make the tick values absolute
a.make_ticks_abs()
# Make a new track, and append every event in every track of a.
b = midi.Track()
for track in a:
for event in track:
b.append(event)
# Sort and output the result
b.sort()
return b
def mergeTrack(s):
"""
Merge all tracks in s in a single one.
"""
singletrack = midi.Track()
events = []
for i, track in enumerate(s):
t = 0
for event in track:
t += event.tick
if event.name in ['Note On', 'Note Off']:
candidate = {'t': t, 'event': event}
events.append(candidate)
events = sorted(events, key=lambda k: k['t'])
tick = 0
for e in events:
e['event'].tick = e['t'] - tick
tick = e['t']
singletrack.append(e['event'])
return singletrack
def compile_notes(notes_list):
"""
Takes in a list of Note objects and returns a playable midi track
example use of midi library defined here:
https://github.com/vishnubob/python-midi
Follow installation instructions from Github readme to use.
"""
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
for note in notes_list:
on = midi.NoteOnEvent(tick=0, velocity=70, pitch=note.getPitch())
track.append(on)
off = midi.NoteOffEvent(tick=100, pitch=note.getPitch())
track.append(off)
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile("example.mid", pattern)
def note_list_to_midi(notes, start_pitch, tickscale = 1):
"""
Converts a list of RelativeNotes to a MIDI track
"""
track = midi.Track(tick_relative=False)
pitch = start_pitch
time = 0
for note in notes:
pitch, time, duration = note.get_absolute(pitch, time)
#print "Writing midi, using time {}".format(time)
if pitch > 0 and pitch < 128:
track.append(midi.NoteOnEvent(tick=time * tickscale, pitch=pitch,
velocity=60))
track.append(midi.NoteOffEvent(tick=(time+duration) * tickscale,
pitch=pitch))
track.sort(key=lambda x: x.tick)
track.append(midi.EndOfTrackEvent(tick=track[-1].tick + 1
if len(track) else 0))
track.make_ticks_rel()
return track
def predictionToBasicMIDI(pred_mat, filename, slices_per_second=31.25):
'''
pred_mat: list of 88 np arrays, each of length num_slices
filename: prefix to save MIDI file
TEMPO: tempo for MIDI file to be created under
'''
TEMPO = 60
TICKS_PER_BEAT = slices_per_second * 12
NOTE_OFFSET = 9 # add to index to get MIDI pitch
VELOCITY = 40 # constant velocity for each note
pattern = midi.Pattern()
pattern.resolution = TICKS_PER_BEAT
track = midi.Track()
track.make_ticks_abs()
tempoEvent = midi.events.SetTempoEvent()
tempoEvent.set_bpm(TEMPO)
track.append(tempoEvent)
pattern.append(track)
noteOn = [0] * 88
num_pitches, num_slices = pred_mat.shape
print num_pitches, num_slices
for t in range(num_slices):
for pitch in range(num_pitches):
state = pred_mat[pitch][t]
midi_pitch = pitch + NOTE_OFFSET
if state == 1 and noteOn[pitch] == 0:
track.append(
midi.NoteOnEvent(tick=12 * t,
pitch=midi_pitch,
velocity=VELOCITY))
noteOn[pitch] = 1
elif state == 0 and noteOn[pitch] == 1:
track.append(
midi.NoteOnEvent(tick=12 * t, pitch=midi_pitch,
velocity=0))
noteOn[pitch] = 0
track.append(midi.EndOfTrackEvent(tick=12 * t))
track.make_ticks_rel()
print track[:10]
midi.write_midifile(filename, pattern)
def note_states_to_midi(self, statematrix, target_path):
statematrix = np.array(statematrix)
span = self.MAX_MIDI_NOTE - self.MIN_MIDI_NOTE
if not len(statematrix.shape) == 3:
statematrix = np.dstack((statematrix[:, :span], statematrix[:, span:]))
statematrix = np.asarray(statematrix)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
tickscale = 55
lastcmdtime = 0
prevstate = [[0, 0] for x in range(span)]
for time, state in enumerate(statematrix + [prevstate[:]]):
offNotes = []
onNotes = []
for i in range(span):
n = state[i]
p = prevstate[i]
if p[0] == 1:
if n[0] == 0:
offNotes.append(i)
elif n[1] == 1:
offNotes.append(i)
onNotes.append(i)
elif n[0] == 1:
onNotes.append(i)
for note in offNotes:
track.append(midi.NoteOffEvent(tick=(time - lastcmdtime) * tickscale, pitch=note + lowerBound))
lastcmdtime = time
for note in onNotes:
track.append(midi.NoteOnEvent(tick=(time - lastcmdtime) * tickscale, velocity=40, pitch=note + lowerBound))
lastcmdtime = time
prevstate = state
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile("{}.mid".format(target_path), pattern)
def unparse(self, sequence, sp, tickscale=24, velocity=80):
sequence = np.array(sequence)
pattern = midi.Pattern()
pattern.resolution = 480
track = midi.Track()
pattern.append(track)
tickscale = tickscale
lastcmdtime = 0
prevstate = [0 for x in range(self.__pitch_span)]
for time, state in enumerate(sequence):
offNotes = []
onNotes = []
for i in range(self.__pitch_span):
n = state[i]
p = prevstate[i]
if p == 1 and n == 0:
offNotes.append(i)
elif p == 0 and n == 1:
onNotes.append(i)
pass
for note in offNotes:
tick = (time - lastcmdtime) * tickscale
pitch = note + self.__lowest_pitch
event = midi.NoteOffEvent(tick=tick, pitch=pitch)
track.append(event)
lastcmdtime = time
for note in onNotes:
tick = (time - lastcmdtime) * tickscale
pitch = note + self.__lowest_pitch
event = midi.NoteOnEvent(tick=tick,
velocity=velocity,
pitch=pitch)
track.append(event)
lastcmdtime = time
pass
prevstate = state
pass
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile(sp, pattern)
pass
def create_track_from_notes(notes, res):
track = midi.Track()
prev_note = notes[0]
# append first note
on = midi.NoteOnEvent(tick=0, velocity=80, pitch=notes[0])
track.append(on)
delay = 0
for note in notes[1:]:
off = midi.NoteOffEvent(tick=res, pitch=prev_note)
# rest
if note == -1:
delay += 1
else:
on = midi.NoteOnEvent(tick=res * delay, velocity=80, pitch=note)
track.append(off)
track.append(on)
prev_note = note
delay = 0
return track
def main():
midifiles = glob.glob(params.lstm_output + '/*.csv')
# Define midi pattern parameters
pattern = midi.Pattern()
pattern.resolution = 70
for midifile in midifiles:
track = midi.Track()
track.append(midi.SetTempoEvent(bpm = np.random.randint(10,20)))
df = pd.read_csv(midifile, header=None)
df = postprocess(df)
# Decode output grid from LTSM into one full track of notes:
track = decoder(track, df.values[:,0:])
eot = midi.EndOfTrackEvent(tick = 1) #essential for the track to be turned into a readable midi file
track.append(eot)
# Translate track into midi file
pattern.append(track)
midi.write_midifile(params.midi_generated + params.artist + ".mid", pattern)
def noteStateMatrixToMidi(statematrix, name="example"):
lowerBound = 0
upperBound = 128
span = upperBound-lowerBound
statematrix = np.array(statematrix)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
#span = upperBound-lowerBound
tickscale = 55
lastcmdtime = 0
prevstate = [0 for x in range(span)]
for time, state in enumerate(np.vstack((statematrix ,prevstate))):
offNotes = []
onNotes = []
for i in range(span):
n = state[i]
p = prevstate[i]
if p == 1:
if n == 0:
offNotes.append(i)
elif n == 1:
pass
elif n == 1:
onNotes.append(i)
for note in offNotes:
track.append(midi.NoteOffEvent(tick=(time-lastcmdtime)*tickscale, pitch=note+lowerBound))
lastcmdtime = time
for note in onNotes:
track.append(midi.NoteOnEvent(tick=(time-lastcmdtime)*tickscale, velocity=120, pitch=note+lowerBound))
lastcmdtime = time
prevstate = state
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
return pattern
def compose(sourceFile, outputFileName, length):
markov = Markov(sourceFile)
sequenceLength = markov.sequenceLength()
# Build random beging of song
notes = []
for i in range(sequenceLength):
notes.append(random.randint(50, 60))
# Build list of notes
while (len(notes) < length):
newNote = markov.get(notes[-sequenceLength:])
if newNote is not None:
notes.append(int(newNote))
else:
print "INFO: No possible note found"
del notes[-1]
print "Song Composed:"
print notes
# Make patern into
pattern = midi.Pattern()
pattern.make_ticks_abs()
track = midi.Track()
pattern.append(track)
for note in notes:
on = midi.NoteOnEvent(tick=0, velocity=NOTE_VELOCITY, pitch=note)
off = midi.NoteOffEvent(tick=NOTE_DURATION[get_rand_duration()],
pitch=note)
track.append(on)
track.append(off)
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile(outputFileName, pattern)
print "Song written to file: %s" % outputFileName
def noteStateMatrixToMidi(statematrix, name="example", span=span):
statematrix = np.array(statematrix)
if not len(statematrix.shape) == 3:
statematrix = np.dstack((statematrix[:, :span], statematrix[:, span:]))
statematrix = np.asarray(statematrix)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
span = upperBound - lowerBound
tickscale = 55
lastcmdtime = 0
prevstate = [[0, 0] for x in range(span)]
for time, state in enumerate(statematrix):
offNotes = []
onNotes = []
print(time)
print(state)
for i in range(span):
n = state[0][i]
print(n)
if n == 1:
onNotes.append(i)
for note in offNotes:
track.append(
midi.NoteOffEvent(tick=(time - lastcmdtime) * tickscale,
pitch=note + lowerBound))
lastcmdtime = time
for note in onNotes:
track.append(
midi.NoteOnEvent(tick=(time - lastcmdtime) * tickscale,
velocity=40,
pitch=note + lowerBound))
lastcmdtime = time
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile("{}.midi".format(name), pattern)
def writeMIDI(dtseq, Tseq, pitchseq, path, label="1", tag="1", resolution=140):
# Instantiate a MIDI Pattern (contains a list of tracks)
pattern = midi.Pattern(format = 0, resolution = resolution)
# Instantiate a MIDI Track (contains a list of MIDI events)
track = midi.Track()
# Append the track to the pattern
pattern.append(track)
tick = 0
Events = []
#Timing
timeperbeat = 60. / 120#[s]
timepertick = timeperbeat/resolution
for dt, T, p in zip(dtseq, Tseq, pitchseq):
if dt == 'START/END' or T == 'START/END' or p == 'START/END':
break
tick = tick + int(dt*resolution)
Events.append({'t': tick, 'p': p, 'm': 'ON'})
Events.append({'t': tick+int(T*resolution), 'p': p, 'm': 'OFF'})
Events = sorted(Events, key=lambda k: k['t'])
tick = 0
for event in Events:
if event['m'] == 'ON':
e = midi.NoteOnEvent(tick=event['t']-tick, velocity=90, pitch=event['p'])
if event['m'] == 'OFF':
e = midi.NoteOffEvent(tick=event['t']-tick, velocity=90, pitch=event['p'])
track.append(e)
tick = event['t']
# Add the end of track event, append it to the track
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
# Save the pattern to disk
midi.write_midifile(path+label+"_"+tag+".mid", pattern)
return pattern
def writeToMIDIFile(tracks, filepath):
"""Writes the tracks to a standard MIDI file"""
pattern = midi.Pattern()
pattern.resolution = GB_NOTE_RESOLUTION
for t in tracks.values():
if t['type'] == 'instrument':
track = midi.Track()
pattern.append(track)
offs = []
currentTime = 0
# Go through each note in track interleaving into on/off events
for n in t['notes']:
# Insert note off events from queue
while len(offs) > 0 and offs[0][0] < n['time']:
off = heapq.heappop(offs)
dif = off[0] - currentTime
currentTime = off[0]
offEvent = midi.NoteOffEvent(tick=dif,
velocity=60,
pitch=off[1])
track.append(offEvent)
# Add note on
dif = n['time'] - currentTime
currentTime = n['time']
onEvent = midi.NoteOnEvent(tick=dif,
velocity=n['vel'],
pitch=n['pitch'])
track.append(onEvent)
# Add note off to queue
heapq.heappush(offs, (n['time'] + n['duration'], n['pitch']))
# Insert leftover note off events from queue
while offs:
off = heapq.heappop(offs)
dif = off[0] - currentTime
currentTime = off[0]
offEvent = midi.NoteOffEvent(tick=dif, pitch=off[1])
track.append(offEvent)
track.append(midi.EndOfTrackEvent(tick=1))
midi.write_midifile(filepath, pattern)
def compose(pitchs, song_name, save_dir):
start = 0
song_length = 30
# ticks = tracks[2][start:start+song_length]
pitchs = pitchs[start:start + song_length]
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
# start = ticks[0]
for i in range(len(pitchs)):
new_tick = 200
# print(ticks[i], start, new_tick)
# on = midi.NoteOnEvent(tick=new_tick, velocity=20, pitch=midi.C_6)
# on = midi.NoteOnEvent(tick=new_tick, velocity=20, pitch=eval('midi.'+str(pitchs[i])))
on = midi.NoteOnEvent(tick=new_tick, velocity=20, pitch=pitchs[i])
track.append(on)
# Add the end of track event, append it to the track
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile(song_name, pattern)
return song_name
def notetomidi(notearray,i):
note_len = 54
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
last_note = 0
for n in notearray:
if n == 1 :
note_len = note_len + 54
elif int(n) > 1 :
track.append(midi.NoteOnEvent(tick=note_len, channel=0, data=[last_note, 0]))
track.append(midi.NoteOnEvent(tick=0, channel=0, data=[n, 110]))
last_note = n
note_len = 54
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile("example"+str(i)+".mid",pattern)
def encode_ir_to_midi(ir, filename, tempo=94):
import midi
# Instantiate a MIDI Pattern (contains a list of tracks)
pattern = midi.Pattern()
# Instantiate a MIDI Track (contains a list of MIDI events)
track = midi.Track()
# Append the track to the pattern
pattern.append(track)
tick = 0
velocity = 70
# 5.55 divisor is pretty accurate for CHORUS LINE MEDLEY and RHAPSODY IN BLUE.
# Speed may vary during song -- perhaps Apple is slower when more
# notes are played? CALL ME IRRESPONSIBLE is not quite as accurate,
# nor is DO YOU THINK I'M SEXY (which is also corrupt).
delay = tempo / 5.55 # 5.5 too slow, 5.75 too fast, 5.6 *slightly* too fast
for inst in ir:
op, val = inst
if op == 'wait':
# Default tempo (^) = 94
# Other tempo (H) = 72
# Tempo is actually just delay time, so is probably a straight division
# Perhaps multiplier = tempo / 4 is a good start
tick = int(round(
val *
delay)) # delay is about 15 for my stuff, about 25 for theirs
elif op == 'on':
track.append(
midi.NoteOnEvent(tick=tick, velocity=velocity, pitch=val))
tick = 0
elif op == 'off':
track.append(midi.NoteOffEvent(tick=tick, pitch=val))
tick = 0
track.append(midi.EndOfTrackEvent(tick=tick))
# Save the pattern to disk
midi.write_midifile(filename, pattern)
def write_midi(self, midifile, resolution=1920, fillpitch=60):
"""
Discards any tempo transition, assumes the tempo at the beginning of the measure
stays the same for the entire measure
midifile: path of the midi file
resolution: the ticks per second
fillpitch: the pitch to be used to fill each measure
"""
import midi
t = midi.Track()
t.tick_relative = False
sec2tick = lambda sec: int(sec * resolution)
tempo = -1
now = 0
for i, measure in enumerate(self.measures):
beat = self.index.measure2beat(i)
assert (now - beat) < 0.0001, \
"now: {}, beat: {}, timesig: {}, prev: {}".format(
now, beat, measure.timesig, self.measures[i - 1])
temponow = int(self.tempocurve(beat))
durbeats = measure.numbeats
t.append(midi.TimeSignatureEvent(tick=sec2tick(now),
numerator=measure.num,
denominator=measure.den))
if temponow != tempo:
tempo = temponow
t.append(midi.SetTempoEvent(tick=sec2tick(now), bpm=tempo))
t.append(midi.NoteOnEvent(tick=sec2tick(now),
pitch=fillpitch, velocity=1))
t.append(midi.NoteOffEvent(tick=sec2tick(now + durbeats),
pitch=fillpitch, velocity=0))
now += durbeats
t.append(midi.EndOfTrackEvent(tick=sec2tick(now) + 1))
midipattern = midi.Pattern([t], resolution=resolution)
midipattern.tick_relative = False
midipattern.make_ticks_rel()
midi.write_midifile(midifile, midipattern)
return midipattern
def noteStateMatrixToMidi(statematrix, name="example", lowerbound=21, upperbound=109):
# code from: https://github.com/hexahedria/biaxial-rnn-music-composition/
statematrix = np.asarray(statematrix)
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
span = upperbound-lowerbound
tickscale = 90
lastcmdtime = 0
prevstate = [[0,0] for x in range(span)]
for time, state in enumerate(statematrix + [prevstate[:]]):
offNotes = []
onNotes = []
for i in range(span):
n = state[i]
p = prevstate[i]
if p[0] == 1:
if n[0] == 0:
offNotes.append(i)
elif n[1] == 1:
offNotes.append(i)
onNotes.append(i)
elif n[0] == 1:
onNotes.append(i)
for note in offNotes:
track.append(midi.NoteOffEvent(tick=(time-lastcmdtime)*tickscale, pitch=note+lowerbound))
lastcmdtime = time
for note in onNotes:
track.append(midi.NoteOnEvent(tick=(time-lastcmdtime)*tickscale, velocity=40, pitch=note+lowerbound))
lastcmdtime = time
prevstate = state
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
midi.write_midifile("{}.mid".format(name), pattern)
def filter_ptrn_of_evnt_typs(old_ptrn, typs_2_keep=tuple(), f=copy.deepcopy):
"""
Filter out unwanted event types from a midi.Pattern
Returns a new midi.Pattern (not in-place) exclusively containing events
types contained in typs_2_keep.
"""
# It's necessary to convert ticks to abs. when removing
# events otherwise timing issues occur
old_ptrn.make_ticks_abs()
new_ptrn = copy_ptrn(old_ptrn)
for old_trck in old_ptrn:
new_trck = midi.Track(tick_relative=False) # old_trck.tick_relative
for old_evnt in old_trck:
if isinstance(old_evnt, typs_2_keep):
new_evnt = f(old_evnt)
new_trck.append(new_evnt)
if len(new_trck):
new_ptrn.append(new_trck)
# We convert to rel. so that playback sounds correct
old_ptrn.make_ticks_rel()
new_ptrn.make_ticks_rel()
return new_ptrn
