def playManyNotes(self, notes):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
tempBar.set_meter((len(notes) * 4, 4))
for n in notes:
tempBar.place_notes(n, 1)
fs.play_Bar(tempBar, 1, 200)
def playNextNoteLong(self):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
tempBar.set_meter((1, 1))
tempBar.key = self._key
tempBar.place_notes(self._notes[self._index], 1)
fs.play_Bar(tempBar, 120)
def playNextNote(self):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
beats = 1.0 / (1.0 / self._beat) / (1.0 / self._durs[self._index])
tempBar.set_meter((beats, self._beat))
tempBar.key = self._key
tempBar.place_notes(self._notes[self._index], self._durs[self._index])
print tempBar
fs.play_Bar(tempBar, self._bpm)
return self._index
def rebuild_composition(old, xylo, cutoff):
lowest = Note.__int__(Note('C', 8))
highest = Note.__int__(Note('C', 0))
new = Composition()
for i in old.selected_tracks:
t = Track()
t.instrument = xylo
for bar in old[i]:
b = Bar()
b.key.name = bar.key.name
b.set_meter(bar.meter)
# note value per beat == the denominator in time signature
dem = b.meter[1]
for lst in bar:
value = lst[1]
if (is_garbage(value, dem, cutoff[old.selected_tracks.index(i)])):
continue
# do not include lists without notes
if (not lst[2]):
continue
nc = NoteContainer()
for note in lst[2]:
if (Note.__int__(note) < lowest): lowest = Note.__int__(note)
if (Note.__int__(note) > highest): highest = Note.__int__(note)
nc + note
b.place_notes(nc, value)
t.add_bar(b)
new.add_track(t)
# can't do the transposing until all notes in all tracks have been
# compared against lowest and highest, which is why it is done here
n1 = Note()
n2 = Note()
low = n1.from_int(lowest)
high = n2.from_int(highest)
# print("lowest and highest notes:", low, high)
if (not xylo.notes_in_range([low, high])):
new = transposer(new, lowest, highest, xylo)
return new
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)
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)
class AudioManager(object):
def __init__(self):
self._notes = []
self._bar = None
self._durs = []
self._index = 0
self._key = ""
self._bpm = 120
self._dynamics = {}
self.paused = False
self._bar = Bar()
fs.init("sound.sf2", "oss")
mixer.init()
def getCurrentNote(self):
return self._notes[self._index]
def setInstrument(self, num):
fs.set_instrument(1, num)
def playNextNoteLong(self):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
tempBar.set_meter((1, 1))
tempBar.key = self._key
tempBar.place_notes(self._notes[self._index], 1)
fs.play_Bar(tempBar, 120)
def playNote(self, note):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
tempBar.place_notes(note, 1)
fs.play_Bar(tempBar, 1, 200)
def playChord(self, note1, note2):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
tempBar.place_notes([note1, note2], 1)
fs.play_Bar(tempBar, 1, 200)
def playManyNotes(self, notes):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
tempBar.set_meter((len(notes) * 4, 4))
for n in notes:
tempBar.place_notes(n, 1)
fs.play_Bar(tempBar, 1, 200)
def playNextNote(self):
"""Plays the next note in the song and advances the index"""
tempBar = Bar()
beats = 1.0 / (1.0 / self._beat) / (1.0 / self._durs[self._index])
tempBar.set_meter((beats, self._beat))
tempBar.key = self._key
tempBar.place_notes(self._notes[self._index], self._durs[self._index])
print tempBar
fs.play_Bar(tempBar, self._bpm)
return self._index
def loadMP3(self, filename):
mixer.music.load(filename)
def playMP3(self):
self.paused = False
mixer.music.play()
def pauseMP3(self):
if not self.paused:
mixer.music.pause()
self.paused = True
def unpauseMP3(self):
if self.paused:
mixer.music.unpause()
self.paused = False
def stopMP3(self):
mixer.music.stop()
def advance(self):
self._index += 1
def reset(self):
self._index = 0
def songComplete(self):
return self._index >= len(self._durs)
def changeNote(self, notes):
self._notes[self._index] = notes
return self._index
def loadSong(self, fn, isTwoHand):
"""Loads in a song from the specified file"""
header = dict()
length = 0.0
self._notes = []
self._bar = None
self._durs = []
with open(fn) as file:
i = 0
for line in file:
if line[0] == "#" or line[0].strip(
) == "": # Skips blank lines and comment lines
continue
if i < 3: # The first three lines are loaded into the header dictionary
vals = line.split('=')
header[vals[0]] = vals[1].strip()
i += 1
else:
vals = line.split(',')
if line[0] == 'r': # Indicates a rest value
self._notes.append(None)
dur = vals[1].strip()
else:
if isTwoHand: # If isTwoHand is true, then a two note chord is looked for
self._notes.append(
[vals[0].strip(), vals[1].strip()])
dur = vals[2].strip()
else:
self._notes.append(vals[0].strip())
dur = vals[1].strip()
if dur[len(dur) - 1] == '.': # Looks for dotted notes
dur = value.dots(int(dur[:-1]))
else:
dur = int(dur)
self._durs.append(dur)
length += 1.0 / dur
self._key = header["key"]
self._bpm = int(header["bpm"])
self._beat = int(header["beat"])
length *= self._bpm
self._bar = Bar()
self._bar.set_meter((length, int(header["beat"])))
def stop(self):
"""Stops all music"""
fs.stop_everything()
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)
