def midi_decode(grid):
pattern = midi.Pattern()
track = midi.Track()
tempoEvent = midi.SetTempoEvent()
tempoEvent.set_bpm(30)
track.append(tempoEvent)
pattern.append(track)
previous_vector = grid[0] # first vector
for note_index in range(len(previous_vector)):
if previous_vector[note_index] != 0: #velocity is not 0
track.append(midi.NoteOnEvent(tick=0, velocity=previous_vector[note_index], pitch=note_index))
tickoffset = 0
for vector in grid:
if previous_vector == vector: #if vectors are same, no new events
tickoffset += 1
else:
for note_index in range(len(previous_vector)):
if previous_vector[note_index] == vector[note_index]: #if same velocity, hold the note rather than rearticulate (no new event)
continue
if previous_vector[note_index] != 0 and vector[note_index] == 0:
if note_index > 127:
print "BROKEN ASSUMPTION"
track.append(midi.NoteOffEvent(tick=tickoffset, pitch=note_index))
else:
track.append(midi.NoteOnEvent(tick=0, velocity=vector[note_index], pitch=note_index))
tickoffset = 0
tickoffset += 1
previous_vector = vector
track.append(midi.EndOfTrackEvent(tick=1))
return pattern
def generate_random_midi():
pattern = midi.Pattern(resolution=220)
track = midi.Track()
pattern.append(track)
ticks = 0
tick_buffer = 0
pitches = [-1] * NEURAL_NET_DELAY #use -1 to indicate a rest
set_tempo = midi.SetTempoEvent()
set_tempo.set_bpm(TEMPO)
track.append(set_tempo)
while ticks < NUM_TICKS:
duration = random.randint(*DURATION_RANGE)
volume = random.randint(*VOLUME_RANGE)
pitch = random.randint(*PITCH_RANGE)
if duration + ticks > NUM_TICKS:
duration = NUM_TICKS - ticks
ticks += duration
tick_buffer += duration
while tick_buffer > 0:
tick_buffer -= TICKS_PER_WINDOW
pitches.append(pitch - PITCH_RANGE[0])
on = midi.NoteOnEvent(tick=0, velocity=volume, pitch=pitch)
off = midi.NoteOffEvent(tick=duration, pitch=pitch)
track.extend([on, off])
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
return (pattern, pitches)
def finalize_midi_sequence(ptrn,
name="Track 1",
inst=0,
channel=0,
tsig=(4, 4),
bpm=120):
"""
Makes a geenrated midi sequnce valid for most players
by adding TimeSignature, SetTempo and EndOfTrack events.
"""
has_tsig = False
has_tempo = False
has_end = False
for evnt in utils.evnt_gen(ptrn):
if isinstance(evnt, midi.SetTempoEvent):
has_tsig = True
if isinstance(evnt, midi.TimeSignatureEvent):
has_tempo = True
if isinstance(evnt, midi.EndOfTrackEvent):
has_end = True
if not has_tsig:
ptrn[0].insert(0, midi.TimeSignatureEvent(tick=0))
ptrn[0][0].data[:2] = tsig
ptrn[0][0].data[2:] = 24, 8
if not has_tempo:
ptrn[0].insert(0, midi.SetTempoEvent(tick=0))
ptrn[0][0].set_bpm(bpm)
if not has_end:
ptrn[0].append(midi.EndOfTrackEvent(tick=0))
ptrn[0].insert(0, midi.TrackNameEvent(tick=0, text=name, data=[]))
ptrn[0].insert(
0, midi.ProgramChangeEvent(tick=0, channel=channel, data=[inst]))
return ptrn
def _set_tempo(track, value):
"""
设置一个自己写的Track的Tempo
"""
SetTempoEvent = midi.SetTempoEvent(bpm=value)
track.insert(0, SetTempoEvent)
return track
def list_to_midi(chunk_str_list, generated_dir, filename):
pattern = midi.Pattern(resolution=480)
track = midi.Track()
pattern.append(track)
for chunk in chunk_str_list:
chunk_info = chunk.split("_")
event_type = chunk_info[1]
if event_type == "no":
tick = int(chunk_info[0])
pitch = int(chunk_info[2])
velocity = int(chunk_info[3])
e = midi.NoteOnEvent(tick=tick, channel=0, velocity=velocity, pitch=pitch)
track.append(e)
elif event_type == "st":
tick = int(chunk_info[0])
bpm = int(chunk_info[2])
mpqn = int(chunk_info[3])
ev = midi.SetTempoEvent(tick=tick, bpm=bpm, mpqn=mpqn)
track.append(ev)
elif event_type == "cc":
control = int(chunk_info[3])
value = int(chunk_info[4])
e = midi.ControlChangeEvent(channel=0, control=control, value=value)
track.append(e)
end_event = midi.EndOfTrackEvent(tick=1)
track.append(end_event)
midi.write_midifile(generated_dir + filename + '.mid', pattern)
def test_1():
print("[%s:%d] test_1()" % \
(os.path.basename(libs.thisfile()), libs.linenum()
), file=sys.stderr)
file = "test.mid"
pattern = midi.Pattern(resolution=960) #このパターンがmidiファイルに対応しています。
track = midi.Track() #トラックを作ります
pattern.append(track) #パターンに作ったトラックを追加します。
ev = midi.SetTempoEvent(tick=0, bpm=120) #テンポを設定するイベントを作ります
track.append(ev) #イベントをトラックに追加します。
e = midi.NoteOnEvent(tick=0, velocity=100,
pitch=midi.G_4) #ソの音を鳴らし始めるイベントを作ります。
track.append(e)
e = midi.NoteOffEvent(tick=960, velocity=100,
pitch=midi.G_4) #ソの音を鳴らし終えるイベントを作ります。
track.append(e)
eot = midi.EndOfTrackEvent(tick=1) #トラックを終えるイベントを作ります
track.append(eot)
midi.write_midifile(file, pattern) #パターンをファイルに書き込みます。
def main():
composerName = "mozart"
createNewTransition = False
inputFiles = glob.glob('midis/midiworld/classic/' + composerName + '*.mid')
if createNewTransition:
getTransitionMatrix(inputFiles, composerName)
lengthM = loadMatrixFromFile("matrices/" + composerName + "LengthM.dat")
pitchM = loadMatrixFromFile("matrices/" + composerName + "PitchM.dat")
velocityM = loadMatrixFromFile("matrices/" + composerName +
"VelocityM.dat")
notesList = highestPlausibility(lengthM, pitchM, velocityM)
outFileName = "midis/" + composerName + "New.mid"
# Instantiate a MIDI Pattern (contains a list of tracks)
resolution = 384
pattern = midi.Pattern(resolution=resolution)
# Instantiate a MIDI Track (contains a list of MIDI events)
track = midi.Track()
# Append the track to the pattern
pattern.append(track)
# Set Instrument to piano
pEvent = midi.ProgramChangeEvent(tick=0, channel=0)
pEvent.set_value(1)
track.append(pEvent)
# Set tempo to 150 bpm
tEvent = midi.SetTempoEvent(tick=0)
tEvent.set_bpm(150)
track.append(tEvent)
for note in notesList:
tick = Note.lengthToTick(note.length, resolution)
pitch = note.pitch
velocity = note.volume
# Append the new note
track.append(
midi.NoteOnEvent(channel=0, tick=0, pitch=pitch,
velocity=velocity))
# Stop the previous note to avoid unpleasant mixing
track.append(
midi.NoteOnEvent(channel=0, tick=tick, pitch=pitch, velocity=0))
# Add the end of track event, append it to the track
eot = midi.EndOfTrackEvent(tick=0)
track.append(eot)
print pattern
# Save the pattern to disk
midi.write_midifile(outFileName, pattern)
print "\nMusic written to " + outFileName + "\n"
def numpy2midi(X, midifile, bpm=155):
# pad to fill last bar (we fill to 16th)
padded_dim = -16 * (
-X.shape[0] // 16
) # remainder of negative numbers equals to ceil() instead of floor()
X_padded = np.zeros((padded_dim, X.shape[1]), dtype=int)
X_padded[:X.shape[0], :X.shape[1]] = X
X = X_padded
# find for each timestep the set of on-notes
X = [set(np.nonzero(x)[0]) for x in X]
# prepend and append an empty step to the song
X.insert(0, set())
X.append(set())
conductor = midi.Track()
time_sig = midi.TimeSignatureEvent(tick=0,
numerator=4,
denominator=4,
metronome=24,
thirtyseconds=8)
conductor.append(time_sig)
tempo = midi.SetTempoEvent(tick=0, bpm=bpm)
conductor.append(tempo)
track = midi.Track()
tick = 0
for previous, current in zip(X[:-1], X[1:]):
notes_to_off = previous - current # notes in the previous but not in the current (ending notes)
for pitch in map(_index2pitch, notes_to_off):
off = midi.NoteOffEvent(
tick=tick, pitch=pitch,
velocity=0) # velocity is ignored in NoteOffEvents
track.append(off)
tick = 0
notes_to_on = current - previous # notes in the current but not in the previous (beginning notes)
for pitch in map(_index2pitch, notes_to_on):
on = midi.NoteOnEvent(tick=tick, pitch=pitch, velocity=100)
track.append(on)
tick = 0
tick += 1
# end of track event
eot = midi.EndOfTrackEvent(tick=0)
conductor.append(eot)
track.append(eot)
# instantiate a MIDI Pattern (contains a list of tracks)
pattern = midi.Pattern(resolution=4)
# append the track to the pattern
pattern.append(conductor)
pattern.append(track)
# save the pattern to disk
midi.write_midifile(midifile, pattern)
def _initialize_or_reset_state(self):
self.track_uuid = str(uuid.uuid4())[0:7]
self.pattern = midi.Pattern(resolution=self.pc.resolution)
self.track = midi.Track()
self.pattern.append(self.track)
self.track.append(midi.SetTempoEvent(bpm=self.bpm))
self.track.append(
midi.TimeSignatureEvent(
numerator=self.time_signature_numerator,
denominator=self.time_signature_denominator))
def generate_tempo_track(data, length, mpqn=20):
track = midi.Track()
track.append(midi.TrackNameEvent())
track.append(midi.TextMetaEvent())
te = midi.SetTempoEvent()
te.tick = length
te.set_mpqn(mpqn)
track.append(te)
track.append(midi.EndOfTrackEvent())
return track
def split_on_timesignature_change(x, typ, include_end=True):
"""
Partitions a midi.Track into different midi.Tracks depending on the occurance of
typ (a particular midi.events type).
For example, one may split a single track into smaller tracks that have different
time signatures.
"""
if isinstance(x, midi.Pattern):
trck = x[0]
mode = "ptrn"
elif isinstance(x, utils.MidiObj):
assert len(x.ptrn) == 1
trck = x.ptrn[0]
mode = "midi_obj"
else:
trck = x
mode = "trck"
trck.make_ticks_abs()
new_trck = midi.Track(tick_relative=False)
tempo = midi.SetTempoEvent()
tmp_flag = False
typ_flag = False
output = [new_trck]
cache = []
tick = trck[0].tick
args = [output, new_trck, cache, tempo, tmp_flag, typ_flag]
for evnt in trck:
if evnt.tick != tick:
tick = evnt.tick
args = aux_split_timestep(*args, include_end)
args[2].append(copy.copy(evnt))
# encountered type on which to split?
if isinstance(evnt, typ):
args[5] = typ_flag = True
# does the tempo change and therefore need updating?
if isinstance(evnt, midi.SetTempoEvent):
args[4] = tmp_flag = True
args[3] = tempo = evnt
output = aux_split_timestep(*args, include_end)[0]
ret = []
for trck in output:
trck.make_ticks_rel()
trck[0].tick = 0
if mode == "ptrn":
ptrn = copy_ptrn(x)
ptrn.append(trck)
ret.append(ptrn)
elif mode == "midi_obj":
ptrn = copy_ptrn(x.ptrn)
ptrn.append(trck)
midi_obj = utils.MidiObj(ptrn)
ret.append(midi_obj)
else:
ret = output
return ret
def init_midi(speed):
# init an midi
global pattern
global track
pattern = midi.Pattern(
format=1, resolution=96) # FL Studio's midi's resolution is 96.
track = midi.Track()
pattern.append(track)
track.append(midi.SetTempoEvent(tick=0, data=[
speed, 0, 0
])) # TODO：Discover what it is, and give a tempo option.
def _events_to_midi_multitrack(starts, durs, pitches, velocities=90,
tracks=0, channels=0, tempo=60,
resolution=1920, outfile="events.mid"):
import midi
N = len(starts)
as_seq = lambda obj: [obj] * N if isinstance(obj, Number) else obj
time2tick = lambda time: int(time * resolution)
pitches, durs, velocities, tracks, channels = map(as_seq,
[pitches, durs, velocities, tracks, channels])
numtracks = max(tracks) + 1
miditracks = []
pitches = list(map(asmidi, pitches))
for tracknum in range(numtracks):
t = midi.Track()
t.make_ticks_abs()
t.append(midi.SetTempoEvent(tick=0, bpm=tempo))
miditracks.append(t)
notespertrack = [[] for _ in miditracks]
for i in range(len(starts)):
track = tracks[i]
ev = _Event(starts[i], durs[i], pitches[i], velocities[i], channels[i])
notespertrack[track].append(ev)
for notes in notespertrack:
notes.sort()
for j in range(len(notes) - 1):
note0, note1 = notes[j], notes[j + 1]
if note0.start + note0.dur > note1.start:
notes[j] = note0._replace(dur=note1.start - note0.start)
for tracknum, notes in enumerate(notespertrack):
if not notes:
continue
t = miditracks[tracknum]
for note in notes:
t.append(midi.NoteOnEvent(tick=time2tick(note.start),
pitch=note.pitch,
velocity=note.vel))
t.append(midi.NoteOffEvent(tick=time2tick(note.start + note.dur),
pitch=note.pitch))
t.append(midi.EndOfTrackEvent(tick=time2tick(notes[-1].start + notes[-1].dur) + 1))
midipattern = midi.Pattern(miditracks, resolution=resolution)
midipattern.make_ticks_rel()
midi.write_midifile(outfile, midipattern)
return midipattern
def generate_midi(data, filename):
eigth_note = 96 // 2
instrument = 1
# 1 - grand piano
# 5 - electric piano
# 41 - violin
# 27 - electric guitar
pattern = midi.Pattern(resolution=eigth_note)
track = midi.Track()
track.append(midi.ProgramChangeEvent(tick=0, data=[instrument]))
pattern.append(track)
set_tempo_event = midi.SetTempoEvent(tick=0)
set_tempo_event.bpm = 200
track.append(set_tempo_event)
last = 0
for step in range(data.shape[0] + 1):
for note in range(128):
last_note_on = (step > 0 and data[step - 1, note] == 1)
note_on = (step < data.shape[0] and data[step, note] == 1)
if note_on and not last_note_on:
tick = 0
if last != step:
tick = (step - last) * eigth_note
last = step
track.append(
midi.NoteOnEvent(tick=tick, velocity=90, pitch=note))
if not note_on and last_note_on:
tick = 0
if last != step:
tick = (step - last) * eigth_note
last = step
track.append(midi.NoteOffEvent(tick=tick, pitch=note))
track.append(midi.EndOfTrackEvent(tick=eigth_note))
midi.write_midifile(f"{filename}.mid", pattern)
subprocess.call([
"fluidsynth", "-F", f"{filename}.wav",
"GeneralUser GS MuseScore v1.442.sf2", f"{filename}.mid"
])
# subprocess.call(["rm", f"{filename}.mid"])
subprocess.call(["open", f"{filename}.wav"])
def toMidi(self):
print("called toMidi")
print(self.noteName)
# create midi pattern and track
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
# append note events to the track
print("start appending note events")
tempo = midi.SetTempoEvent()
tempo.set_bpm(self.bpm)
track.append(tempo)
rest = 0
for i in range(len(self.noteName)):
if self.noteName[i] == []:
rest += 1
for j in range(len(self.noteName[i])):
on = midi.NoteOnEvent(tick=0 + (rest * self.resolution),
velocity=self.constVelocity,
pitch=self.noteName[i][j])
track.append(on)
rest = 0
for k in range(len(self.noteName[i])):
if k == 0:
off = midi.NoteOffEvent(tick=self.resolution,
pitch=self.noteName[i][k])
else:
off = midi.NoteOffEvent(tick=0, pitch=self.noteName[i][k])
track.append(off)
# create eot
print("creating eot...")
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
print("This is the pattern")
print(pattern)
# save the pattern to ./output.mid
print("Saving ...")
midi.write_midifile(self.export + '.mid', pattern)
print("Conversion finished")
def makeSongMidi(song, instruments, volume, name, bpm):
'''
song is a list of lists of pysynth tuples
instruments is a list of ints specifying midi instruments; -1 means to use
channel 9 to produce percussion sounds
volume is a list of ints specifying the volume of each track
name is the song's name
'''
# 220 is completely arbitrary. anything >= 4 should probably work
resolution = 220
pattern = midi.Pattern(resolution=resolution)
tempoEvent = midi.SetTempoEvent(tick=0)
tempoEvent.set_bpm(bpm)
tempoTrack = midi.Track()
tempoTrack.append(tempoEvent)
tempoTrack.append(midi.EndOfTrackEvent(tick=0))
pattern.append(tempoTrack)
for i in range(len(song)):
track = midi.Track()
if instruments[i] != -1:
track.append(
midi.ProgramChangeEvent(tick=0,
channel=i,
data=[instruments[i]]))
for note in song[i]:
noteLetter = note[0][:-1]
noteNum = chromNotesNum[noteLetter] - 1
octave = int(note[0][-1])
pitch = noteNum + (octave - 1) * 12
ticks = int(durationToBeats(note[1]) * resolution)
if instruments[i] != -1:
track.append(
midi.NoteOnEvent(tick=0,
channel=i,
data=[pitch, volume[i]]))
track.append(
midi.NoteOffEvent(tick=ticks, channel=i, data=[pitch, 0]))
else:
track.append(
midi.NoteOnEvent(tick=0,
channel=9,
data=[pitch, volume[i]]))
track.append(
midi.NoteOffEvent(tick=ticks, channel=9, data=[pitch, 0]))
track.append(midi.EndOfTrackEvent(tick=0))
pattern.append(track)
midi.write_midifile('midi/' + name + '.mid', pattern)
def __init__(self): print "BPM: %d" % args.bpm self.pattern = midi.Pattern() self.track = midi.Track() self.flam = False self.accent = False self.rest_beats = 1 self.outputFile = args.output self.pattern.append(self.track) self.note_tightness = args.note_tightness self.rest = self.one_beat_value/self.beat_values_new["1/4"][1] tempo = midi.SetTempoEvent() tempo.set_bpm(args.bpm) self.track.append(tempo)
def midiFromLabels(labels, interval=DEFAULT_INTERVAL):
"""Method to take output of our system and create a MIDI file we can put
through a synthesizer. |labels| is a list of 1x88 matricies of one hot
encodings of possible notes. Intervals is the number of microseconds
between each encoding.
returns Midi track. For now tempo is 60 bpm in all cases.
"""
# Default resolution 220.
pattern = midi.Pattern(tick_relative=False)
tempo_track = midi.Track(tick_relative=False)
tempo_event = midi.SetTempoEvent(tick=0, bpm=60)
tempo_track.append(tempo_event)
pattern.append(tempo_track)
note_track = midi.Track(tick_relative=False)
pattern.append(note_track)
# Hash set
currently_on_notes = {}
def recordChangeAtIndex(index, tick):
midi_index = index + MIDI_OFFSET
if currently_on_notes.get(index, False):
event = midi.NoteOffEvent
else:
event = midi.NoteOnEvent
note_track.append(event(tick=tick, pitch=midi_index, velocity=64))
currently_on_notes[index] = not currently_on_notes.get(index, False)
def tickFromTime(time):
# |time| in microseconds.
ticks_per_sec = 220.0
ticks_per_microsecs = ticks_per_sec / 1000000
return int(ticks_per_microsecs * time)
current_time = 0
for label in labels:
current_time += interval
for index, value in enumerate(label):
if currently_on_notes.get(index, False) != value:
recordChangeAtIndex(index, tickFromTime(current_time))
final_tick = note_track[-1].tick
note_track.append(midi.EndOfTrackEvent(tick=final_tick))
tempo_track.append(midi.EndOfTrackEvent(tick=final_tick))
pattern.make_ticks_rel()
return pattern
def generate_tempo_track(tempos,length):
tick = generate_tick_seq(tempos['tick']['mat'],tempos['tick']['inds'],length)
length = len(tick)
mpqn = generate_markov_seq(tempos['mpqn']['mat'],tempos['mpqn']['inds'],length)
track = midi.Track()
track.append(midi.TrackNameEvent())
track.append(midi.TextMetaEvent())
for i in xrange(0,length):
if mpqn[i]!=0:
te = midi.SetTempoEvent()
te.tick = tick[i]
te.set_mpqn(mpqn[i])
track.append(te)
track.append(midi.EndOfTrackEvent())
return track
def create_file_from_scalable(self, scalable_fname, tempo, num):
scalable_pattern = midi.read_midifile(scalable_fname)
new_pattern = midi.Pattern(format=0, resolution=96)
new_track = midi.Track()
new_pattern.append(new_track)
new_track.append(
midi.SetTempoEvent(tick=0, data=self.generate_array(tempo)))
for event in scalable_pattern[0]:
new_track.append(event)
new_file_name = 'genre_' + self.genre_name + '_tempo_' + str(
tempo) + "_file_" + str(self.remake_num) + '_' + str(num) + '.mid'
midi.write_midifile(new_file_name, new_pattern)
return new_file_name
def writeMid(note_time_list, bpm):
'''
Usage: write the infomation got from wav transfer to a .mid file
Args:
note_time_list: the info from the note tranfer
bpm: the bpm of the wav
Returns:
the pathName of the out midi file
'''
# create a new midi.pattern, and add a track to it
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
# change the bpm of midi file
tempo = midi.SetTempoEvent(bpm=bpm)
track.append(tempo)
# transfer the note name in note_time_list to int value in midi format
note_num_list = note_name2note_num(note_time_list)
# transfer the note start_time and end_time to tick number in midi format
start_end_tick_list = time2tick(note_time_list, bpm)
#change the absolute tick to delta tick
event_list = order_ticks(note_num_list, start_end_tick_list)
# write the transformed list to noteOnEvents,add to the track
for event in event_list:
if event[2] == 1:
on = midi.NoteOnEvent(tick=event[1], velocity=50, pitch=event[0])
track.append(on)
else:
off = midi.NoteOffEvent(tick=event[1], pitch=event[0])
track.append(off)
# add endTrackEvent on the track
eot = midi.EndOfTrackEvent(tick=1)
track.append(eot)
# Save the pattern to mid file
with open('wav2mid.config', 'r') as configFile:
outputPath = configFile.read()
outMidPath = outputPath + str(uuid.uuid1()) + '.mid'
midi.write_midifile(outMidPath, pattern)
return outMidPath
def set_tempo_events(filename_in, filename_out, tempoevents):
"""
set midi tempo events
"""
midifile = midipy.read_midifile(filename_in)
midifile.make_ticks_abs()
max_tick = 0
for track in midifile:
for event in track:
if not isinstance(event, midipy.EndOfTrackEvent):
max_tick = max(event.tick, max_tick)
if isinstance(event, midipy.SetTempoEvent):
track.remove(event)
for track in midifile:
for event in track:
if isinstance(event, midipy.EndOfTrackEvent):
event.tick = max_tick + 1
# TODO: adapt tempo for changing signatures
# time_signatures = get_time_signature_events(filename_in)
#
# adaptions = []
#
# for ts in time_signatures:
# add = [ts.tick, 0, 4.0 / ts.denom]
# adaptions.append(add)
#
# adaptions[-1][1] = tempoevents[-1].tick + 1
#
# for row in adaptions:
# for e in tempoevents:
# if e.tick >= row[0] and e.tick < row[1]:
# e.bpm = int(e.bpm * row[2])
for e in tempoevents:
te = midipy.SetTempoEvent(tick=e.tick, bpm=e.bpm)
midifile[0].append(te)
for track in midifile:
track.sort()
midifile.make_ticks_rel()
midipy.write_midifile(filename_out, midifile)
def generate_composition(number_of_tracks):
head_of_file = []
pattern = midi.Pattern()
t = midi.Track()
note_choices = [2, 4, 8, 16]
note_durations = []
for i in range(0, 54):
note_durations.append(random.choice(note_choices))
for i in range(0, number_of_tracks):
counter = 0
s = midi.read_midifile("theme_and_variations-{0}.midi".format(i))
for note in s[1][1:-1]:
note.tick = note_durations[counter]
counter += 1
midi.write_midifile("theme_and_variations-{0}.midi".format(i), s)
for i in range(0, number_of_tracks):
s = midi.read_midifile("theme_and_variations-{0}.midi".format(i))
if i == 0:
head_of_file = s[0]
del head_of_file[-1]
head_of_file[2] = midi.SetTempoEvent(tick=0, data=[11, 113, 176])
head_of_file[0] = midi.TimeSignatureEvent(tick=0,
data=[4, 2, 96, 8])
del s[1][-1]
t.extend(s[1])
elif i == number_of_tracks - 1:
del s[1][0]
t.extend(s[1])
else:
del s[1][-1]
del s[1][0]
t.extend(s[1])
os.remove("theme_and_variations-{0}.midi".format(i))
pattern.resolution = 32
pattern.format = 1
pattern.append(head_of_file)
pattern.append(t)
print pattern
# Make file and move it to download directory to present to user
midi.write_midifile("Theme-And-Variations.midi", pattern)
print " DONE! "
def addtempoevent( self, tempo=120, absoluteticks=0 ):
t = MIDI.SetTempoEvent( bpm = tempo )
t.absoluteticks = absoluteticks
if len(self.tempos):
if absoluteticks > self.tempos[-1].absoluteticks:
self.tempos.append( t )
else:
i = 0
while i < len(self.tempos):
if absoluteticks < self.tempos[i].absoluteticks:
self.tempos.insert(i, t)
break
elif absoluteticks == self.tempos[i].absoluteticks:
self.tempos[i] = t
break
else:
i += 1
else:
self.tempos.append( t )
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 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 statematrixToPattern(statematrix, bpm=120):
pattern = midi.Pattern()
track = midi.Track()
pattern.append(track)
tempo = midi.SetTempoEvent(tick=0)
tempo.set_bpm(bpm)
track.append(tempo)
tickscale = 55
lastcmdtime = 0
prevstate = [0 for i in range(span * 2)]
for time, state in enumerate(statematrix):
offNotes = []
onNotes = []
for i in range(span):
if prevstate[i] == 1:
if state[i] == 0:
offNotes.append(i)
elif state[i + span] == 1:
offNotes.append(i)
onNotes.append(i)
elif state[i] == 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)
return pattern
def test_3():
print("[%s:%d] test_3()" % \
(os.path.basename(libs.thisfile()), libs.linenum()
), file=sys.stderr)
# fname = "test.%s.mid" % (libs.get_TimeLabel_Now())
pitch_1 = midi.A_4
pitch_2 = midi.G_4
pitch_3 = midi.F_4
pitch_4 = midi.E_4
pitch_5 = midi.D_4
pitch_6 = midi.C_4
pitch_7 = midi.B_4
ps = [
midi.A_4,
midi.G_4,
midi.F_4,
midi.E_4,
midi.D_4,
midi.C_4,
midi.B_4,
]
# ps = [pitch_1, pitch_2, pitch_3, pitch_4]
lenOf_PS = len(ps)
numOf_Notes = 32
# file name
fname = "test.%s.ps-%02d.notes-%02d.mid" %\
(libs.get_TimeLabel_Now(), len(ps), numOf_Notes)
pattern = midi.Pattern(resolution=960) #このパターンがmidiファイルに対応しています。
track = midi.Track() #トラックを作ります
pattern.append(track) #パターンに作ったトラックを追加します。
ev = midi.SetTempoEvent(tick=0, bpm=120) #テンポを設定するイベントを作ります
track.append(ev) #イベントをトラックに追加します。
'''###################
set : notes
###################'''
for i in range(numOf_Notes):
# for i in range(8):
num = rnd.randint(0, lenOf_PS - 1)
# print("[%s:%d] num => %d" % \
# (os.path.basename(libs.thisfile()), libs.linenum()
# , num
# ), file=sys.stderr)
# num = rnd.randint(1, lenOf_PS)
e = midi.NoteOnEvent(tick=0, velocity=100,
pitch=ps[num]) #ソの音を鳴らし始めるイベントを作ります。
track.append(e)
e = midi.NoteOffEvent(tick=960, velocity=100,
pitch=ps[num]) #ソの音を鳴らし終えるイベントを作ります。
track.append(e)
# e = midi.NoteOnEvent(tick=0, velocity=100, pitch= pitch_1) #ソの音を鳴らし始めるイベントを作ります。
# track.append(e)
#
# e = midi.NoteOffEvent(tick=960, velocity=100, pitch= pitch_1) #ソの音を鳴らし終えるイベントを作ります。
# track.append(e)
#/for i in range(8):
'''###################
track : end
###################'''
eot = midi.EndOfTrackEvent(tick=1) #トラックを終えるイベントを作ります
track.append(eot)
midi.write_midifile(fname, pattern) #パターンをファイルに書き込みます。
'''###################
def change_music_to_pattern(music):
music.parse_track_msg()
# music._init_main_trank()
pattern = midi.Pattern()
pattern.resolution = music.get_resolution()
pattern.format = music.get_play_format()
for track in reversed(music.track):
t = midi.Track()
for event in track:
event_tick = int(event[0])
event_event = event[1]
state_code = event_event["state_code"]
if state_code == 255:
if event_event["name"] == 'Set Tempo':
eve = midi.SetTempoEvent(tick=event_tick,
bpm=event_event["bpm"])
elif event_event["name"] == 'Trank Name':
eve = midi.TrackNameEvent(tick=event_tick,
text=event_event["text"])
elif event_event["name"] == 'Copyright Notice':
eve = midi.CopyrightMetaEvent(tick=event_tick,
text=event_event["text"])
elif event_event["name"] == 'SMPTE Offset':
eve = midi.SmpteOffsetEvent(tick=event_tick,
text=event_event["text"])
elif event_event["name"] == 'Time Signature':
eve = midi.TimeSignatureEvent(
tick=event_tick,
numerator=event_event["numerator"],
denominator=event_event["denominator"],
metronome=event_event["metronome"],
thirtyseconds=event_event["thirtyseconds"])
elif event_event["name"] == "End of Track":
eve = midi.EndOfTrackEvent(tick=event_tick)
else:
continue
elif 240 <= state_code <= 254:
# 系统码
eve = midi.SysexEvent()
elif 224 <= state_code <= 239:
# 滑音
eve = midi.PitchWheelEvent(tick=event_tick,
channel=event_event["channel"],
pitch=event_event["pitch"])
elif 208 <= state_code <= 223:
# After Touch
eve = midi.AfterTouchEvent()
elif 192 <= state_code <= 207:
# 乐器转换
eve = midi.ProgramChangeEvent(tick=event_tick,
channel=event_event["channel"],
data=[event_event["program"]])
elif 176 <= state_code <= 191:
# midi控制器
eve = midi.ControlChangeEvent(
tick=event_tick,
channel=event_event["channel"],
data=[event_event["control"], event_event["value"]])
elif 160 <= state_code <= 175:
continue
elif 144 <= state_code <= 159:
# note on
eve = midi.NoteOnEvent(tick=event_tick,
channel=event_event["channel"],
velocity=event_event["velocity"],
pitch=event_event["pitch"])
elif 128 <= state_code <= 143:
# note off
eve = midi.NoteOffEvent(tick=event_tick,
channel=event_event["channel"],
velocity=event_event["velocity"],
pitch=event_event["pitch"])
elif state_code <= 127:
continue
t.append(eve)
pattern.append(t)
return pattern
def numpy2midi(n):
"""Convert a numpy array n to a midi pattern in python-midi
format, quantised etc."""
# print(n)
# print(n.shape)
resolution = 4
p = midi.Pattern(resolution=resolution) #, tick_relative=False)
track = midi.Track()
#track = midi.Track(tick_relative=False)
p.append(track)
set_tempo = midi.SetTempoEvent()
set_tempo.set_bpm(120)
set_tempo.set_mpqn(120)
track_name = midi.TrackNameEvent(trackname="Track name")
time_sig = midi.TimeSignatureEvent()
time_sig.set_numerator(4)
time_sig.set_denominator(4)
time_sig.set_metronome(180)
# time_sig.set_thirtyseconds(32)
end = midi.EndOfTrackEvent()
end.tick = nsteps * resolution
#track.append(set_tempo)
#track.append(track_name)
#track.append(time_sig)
for step in range(nsteps):
tick = 0
for drum in range(len(names)):
# print(n[drum, step])
if n[drum, step] > 0:
on = midi.NoteOnEvent()
on.channel = 9
on.pitch = dm2[drum]
on.velocity = int(n[drum, step])
on.tick = tick
track.append(on)
# print(on)
tick = 0
tick = resolution
for drum in range(len(names)):
if True:
#elif step > 0 and n[drum, step-1] > 0:
off = midi.NoteOffEvent()
off.channel = 9
off.pitch = dm2[drum]
off.velocity = 100
off.tick = tick
track.append(off)
# print(off)
tick = 0
track.append(end)
#p.make_ticks_rel()
return p
