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:
# this loop will gather data for all notes,
# set up keys and time signatures for all bars
# and set the tempo and instrument for the track.
metronome = 1 # Tick once every quarter note
thirtyseconds = 8 # 8 thirtyseconds in a quarter note
step = 256.0 # WARNING: Assumes our smallest desired quantization step is a 256th note.
meter = (4, 4)
key = 'C'
bar = 0
beat = 0
now = (bar, beat)
b = None
started_notes = {}
finished_notes = {}
b = Bar(key=key, meter=meter)
bars = [b]
bpm = None
instrument = None
track_name = None
for deltatime, event in track:
if deltatime != 0:
duration = (ticks_per_beat * 4.0) / float(deltatime)
dur_q = int(round(step/duration))
length_q = int(b.length * step)
o_bar = bar
c_beat = beat + dur_q
bar += int(c_beat / length_q)
beat = c_beat % length_q
while o_bar < bar:
o_bar += 1
o_key = b.key
b = Bar(key=key, meter=meter)
b.key = o_key
bars.append(b)
now = (bar, beat)
if event['event'] == 8:
# note off
channel = event['channel']
note_int = event['param1']
velocity = event['param2']
note_name = notes.int_to_note(note_int % 12)
octave = note_int / 12 - 1
note = Note(note_name, octave)
note.channel = channel
note.velocity = velocity
x = (channel, note_int)
start_time = started_notes[x]
del started_notes[x]
end_time = now
y = (start_time, end_time)
if y not in finished_notes:
finished_notes[y] = []
finished_notes[y].append(note)
elif event['event'] == 9:
# note on
channel = event['channel']
note_int = event['param1']
velocity = event['param2']
x = (channel, note_int)
# add the note to the current NoteContainer
started_notes[x] = now
elif event['event'] == 10:
# note aftertouch
pass
elif event['event'] == 11:
# controller select
pass
elif event['event'] == 12:
# program change
# WARNING: only the last change in instrument will get saved.
i = MidiInstrument()
i.instrument_nr = event['param1']
instrument = i
elif event['event'] == 0x0f:
# meta event Text
if event['meta_event'] == 1:
pass
elif event['meta_event'] == 3:
# Track name
track_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
mpqn = self.bytes_to_int(event['data'])
bpm_o = bpm
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 = Track(instrument)
t.name = track_name
sorted_notes = {}
# sort the notes (so they are added to the bars in order)
# this loop will also split up notes that span more than one bar.
for x in finished_notes:
(start_bar, start_beat), (end_bar, end_beat) = x
if end_beat == 0:
end_bar -= 1
end_beat = int(bars[end_bar].length * step)
while start_bar <= end_bar:
nc = NoteContainer(finished_notes[x])
b = bars[start_bar]
if start_bar < end_bar:
# only executes when note spans more than one bar.
length_q = int(b.length * step)
dur = int(step/(length_q - start_beat))
else:
# always executes - add the final section of this note.
dur = int(step/(end_beat-start_beat))
if start_beat != 0:
at = float(start_beat)/step
else:
at = 0.0
if start_bar not in sorted_notes:
sorted_notes[start_bar] = {}
if at not in sorted_notes[start_bar]:
sorted_notes[start_bar][at] = (dur, nc)
# set our offsets for the next loop
start_beat = 0
start_bar += 1
# add all notes to all bars in order.
for start_bar in sorted(sorted_notes.keys()):
for at in sorted(sorted_notes[start_bar].keys()):
dur, nc = sorted_notes[start_bar][at]
bars[start_bar].place_notes_at(nc, dur, at)
# add the bars to the track, in order
for b in bars:
b.fill_with_rests()
t + b
# add the track to the composition
c.tracks.append(t)
return (c, bpm)
