def _parse_midi_event(self, f, delta_time, status):
if status & 0xF0 != 0xF0:
command = (status & 0xF0) >> 4
channel = status & 0x0F
data_1 = self._read_8(f) & 0x7F
data_2 = 0
if command in [8, 9, 10, 11, 14]:
data_2 = self._read_8(f) & 0x7F
if command == 8:
return events.NoteOffEvent(delta_time, channel, data_1, data_2)
elif command == 9:
if data_2 == 0:
return events.NoteOffEvent(delta_time, channel, data_1, data_2)
return events.NoteOnEvent(delta_time, channel, data_1, data_2)
elif command == 10:
return events.PolyphonicKeyPressureEvent(delta_time, channel, data_1, data_2)
elif command == 11:
return events.ControlChangeEvent(delta_time, channel, data_1, data_2)
elif command == 12:
return events.ProgramChangeEvent(delta_time, channel, data_1)
elif command == 13:
return events.ChannelPressureEvent(delta_time, channel, data_1)
elif command == 14:
return events.PitchWheelChangeEvent(delta_time, channel, (data_2 << 7) | data_1)
return None
message_id = status & 0x0F
if message_id == 0:
manufacturer_id = self._read_8(f)
data = []
d = self._read_8(f)
while d != 0xF7:
data.append(d)
d = self._read_8(f)
return events.SystemExclusiveEvent(delta_time, manufacturer_id, data)
elif message_id == 2:
lo7 = self._read_8(f)
hi7 = self._read_8(f)
return events.SongPositionPointerEvent(delta_time, (hi7 << 7) | lo7)
elif message_id == 3:
return events.SongSelectEvent(delta_time, self._read_8(f))
elif message_id == 6:
return events.TuneRequestEvent(delta_time)
elif message_id == 8:
return events.TimingClockEvent(delta_time)
elif message_id == 10:
return events.StartEvent(delta_time)
elif message_id == 11:
return events.ContinueEvent(delta_time)
elif message_id == 12:
return events.StopEvent(delta_time)
elif message_id == 14:
return events.ActiveSensingEvent(delta_time)
elif message_id == 15:
return events.ResetEvent(delta_time)
return None
def __iter__(self):
if self.velocity > 0:
key = VoiceStream.resolve_key(self.song.key)
tick = 0
tied_beats = 0
measure_num = 0
for measure in [
measure[self.voice] for measure in self.song.measures
]:
# some 'measures' are key changes...
if isinstance(measure, keys.Key) or inspect.isclass(measure):
key = VoiceStream.resolve_key(measure)
else:
total_measure_beats = 0
for note in measure:
note = self.map_note_using_key(key, note)
total_measure_beats += note.beats
if note.tie:
tied_beats += note.beats
else:
modified_beats = note.beats + tied_beats + note.fermata_beats
note_ticks = modified_beats * ticks_per_beat
tied_beats = 0
if type(note) != notes.R:
on = tick
off = tick + note_ticks - ticks_between_beats
yield events.NoteOnEvent(
self.voice, on, note.pitch, self.velocity)
yield events.NoteOffEvent(
self.voice, off, note.pitch, self.velocity)
tick += note_ticks
self.verify_beats_per_measure(measure_num,
total_measure_beats)
measure_num += 1
def pop_sound(ticktime):
cc = events.ProgramChangeEvent(tick=0, channel=0, value=pop_ins)
track.append(cc)
on = events.NoteOnEvent(channel=0,
tick=ticktime,
velocity=120,
pitch=pop_pitch)
track.append(on)
#ticktime+=Notelength+Tempo
off = events.NoteOffEvent(tick=ticktime + Notelength + Tempo,
pitch=pop_pitch,
channel=0)
track.append(off)
return ticktime
import constants
import containers
import events
import fileio
import sequencer
import util
# Instantiate a MIDI Pattern (contains a list of tracks)
pattern = containers.Pattern()
# Instantiate a MIDI Track (contains a list of MIDI events)
track = containers.Track()
# Append the track to the pattern
pattern.append(track)
# Instantiate a MIDI note on event, append it to the track
on = events.NoteOnEvent(tick=0, velocity=20, pitch=64)
track.append(on)
# Instantiate a MIDI note off event, append it to the track
off = events.NoteOffEvent(tick=100, pitch=32)
track.append(off)
# Add the end of track event, append it to the track
eot = events.EndOfTrackEvent(tick=1)
track.append(eot)
# Print out the pattern
print pattern
# Save the pattern to disk
fileio.write_midifile("example.mid", pattern)
