def __make_consistent_time_signature__(pattern):
print ("Making consitent time signature")
time_signatures = midiutil.get_events_from_pattern(pattern, "Time Signature")
if len(time_signatures) == 0:
raise IndexError("No time signatures in pattern")
to_remove = time_signatures[1:]
for track in pattern:
midiutil.remove_events_from_track(track, to_remove)
def __make_consistent_tempo__(pattern):
print ("Making consitent tempo")
tempos = midiutil.get_events_from_pattern(pattern, "Set Tempo")
if len(tempos) == 0:
raise IndexError("No tempos in pattern")
to_remove = tempos[1:]
for track in pattern:
midiutil.remove_events_from_track(track, to_remove)
def main():
markov = MarkovModel(ngram_size=10)
filenames = mididb.get_midi_filenames(".")
for index, filename in enumerate(filenames):
title = "(" + str(index) + "/" + str(len(filenames)) + ") " + filename
# print title
# print "="*len(title)
pattern = midi.read_midifile(filename)
time_sigs = midiutil.get_events_from_pattern(pattern, "Time Signature")
for time_sig in time_sigs:
if time_sig.denominator != 4 and time_sig.numerator != 4:
print time_sig.denominator, time_sig.numerator
if pattern.resolution != 240:
print pattern.resolution, filename
def __init__(self, drum_dir="mididrum-sample"):
self.filenames = mididb.get_midi_filenames(drum_dir)
self.patterns = [midi.read_midifile(filename) for filename in self.filenames if not "fill" in filename]
self.channel = json.load(open("b0rkestra_description.json"))["instruments"]["drums"]["output_channel"]
for p in self.patterns:
midiutil.pattern_to_resolution(p, 480)
midiutil.pattern_to_channel(p, self.channel)
p.make_ticks_abs()
#sanitize any wierd events
for track in p:
to_remove = []
for event in track:
if not (event.name == "Note On" or event.name == "Note Off"):
to_remove.append(event)
#if event.name == "Note On":
# eve.velocity = 127
for event in to_remove:
track.remove(event)
#Make all the drum loop samples roughly the same length
bar_duration = midiutil.calculate_bar_duration(p)
midiutil.trim_pattern_to_abs_tick(p, bar_duration)
multiplier = int(round(bar_duration / float(midiutil.get_events_from_pattern(p, "Note On")[-1].tick)))
if multiplier > 1.0:
midiutil.loop_pattern(p, bar_duration/multiplier, multiplier)
#print "duration", bar_duration
p.make_ticks_rel()
self.drum_change_probability = 0.1
self.fill_probability = 0.2
self.current_pattern = random.choice(self.patterns)
def extract_midi_states(pattern, bar_duration=7680, states_per_bar=32):
midiutil.pattern_to_resolution(pattern, 480)
pattern.make_ticks_abs()
#sanitize any wierd events
for track in pattern:
to_remove = []
for event in track:
if not (event.name == "Note On" or event.name == "Note Off"):
to_remove.append(event)
for event in to_remove:
track.remove(event)
#Make all the drum loop samples roughly the same length
#midiutil.trim_pattern_to_abs_tick(pattern, bar_duration)
multiplier = int(round(bar_duration / float(midiutil.get_events_from_pattern(pattern, "Note On")[-1].tick)))
if multiplier > 1.0:
midiutil.loop_pattern(pattern, bar_duration/multiplier, multiplier)
events = []
for track in pattern:
for event in track:
if event.name == "Note On":
events.append(event)
events.sort()
states = []
for i in xrange(states_per_bar):
states.append([])
for event in events:
if event.tick >= bar_duration:
continue
state_num = int(math.floor(event.tick/float(bar_duration/states_per_bar)))
states[state_num].append((event.tick - state_num*(bar_duration/states_per_bar), event.pitch))
states = [tuple(state) for state in states]
return states
def main():
client = 0
port = 0
if len(sys.argv) != 3:
s = sequencer.SequencerHardware()
print s
client = int(raw_input('client number --> '))
port = int(raw_input('port number --> '))
print client, port
else:
client = sys.argv[1]
port = sys.argv[2]
db = mididb.MidiDB();
print db.__key_index__.keys()
print db.__scale_index__.keys()
key = "E"
scale = "minor"
pattern = midi.Pattern(resolution=480)
bass_man = BassMan(db, key, scale)
bass = bass_man.generate_bar()
print "Got initial bass pattern"
print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>",len(midiutil.get_events_from_pattern(bass, "Note On"))
pattern.extend(bass)
#racketPatternMaker = PatternMaker2K(db, key, scale)
racketPatternMaker = SympathyPlayer(bass_man)
#racket = racketPatternMaker.generate_bar([2])
racket = racketPatternMaker.generate_bar()
print "Got initial racket pattern"
pattern.extend(racket)
tubulumPatternMaker = PatternMaker2K(db, key, scale)
tubulum = tubulumPatternMaker.generate_bar([3])
print "Got initial tubulum pattern"
#pattern.extend(tubulum)
drummer = Drummer()
drums = drummer.generate_bar()
print "Got initial drummer pattern"
pattern.extend(drums)
midi_player = MidiPlayer(client=client, port=port)
midiutil.turn_notes_off_in_pattern(pattern)
midi_player.append_bar(pattern)
midi_player.start()
while threading.active_count() > 0:
print midi_player.last_tick, midi_player.current_tick
if midi_player.current_tick > midi_player.last_tick - 5000:
pattern = midi.Pattern(resolution=480)
print "Getting bass"
bass = bass_man.generate_bar()
bass = midiutil.get_bar_from_pattern(bass, 0)
print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>",midiutil.get_events_from_pattern(bass, "Note On")
midiutil.turn_notes_off_in_pattern(bass)
pattern.extend(bass)
print "Getting racket"
#racket = racketPatternMaker.generate_bar([2])
racket = racketPatternMaker.generate_bar()
racket = midiutil.get_bar_from_pattern(racket, 0)
midiutil.turn_notes_off_in_pattern(racket)
pattern.extend(racket)
print "Getting drums"
drums = drummer.generate_bar()
drums = midiutil.get_bar_from_pattern(drums, 0)
midiutil.turn_notes_off_in_pattern(drums)
pattern.extend(drums)
print "Getting tubulum"
tubulum = tubulumPatternMaker.generate_bar([3])
tubulum = midiutil.get_bar_from_pattern(tubulum, 0)
midiutil.turn_notes_off_in_pattern(tubulum)
#pattern.extend(tubulum)
midiutil.turn_notes_off_in_pattern(pattern)
midi_player.append_bar(pattern)
#midi_player.append_bar(pattern)
time.sleep(0.1)
midi_player.join()
return
