def __make_all_tracks_integer_bar_multiple__(pattern):
print ("Making all tracks integer bar length")
bar_duration = midiutil.calculate_bar_duration(pattern)
print " bar duration", bar_duration
orignally_ticks_relative = pattern.tick_relative
if pattern.tick_relative:
pattern.make_ticks_abs()
longest_tick = 0
eot_events = []
for track in pattern:
eot_events += midiutil.get_events_from_track(track, "End of Track")
eot_events.sort(key=lambda x:x.tick, reverse=True)
last_tick = eot_events[0].tick
bar_number = int(math.ceil(float(last_tick)/float(bar_duration)))
print " number of bars", bar_number
tick_length = bar_number * bar_duration
for event in eot_events:
event.tick = tick_length
if orignally_ticks_relative:
pattern.make_ticks_rel()
def create_record(filename):
print "## Creating record", filename
print "### Sanitizing"
record = {}
record["filename"] = filename
record["id"] = generate_id(open(filename, "rb"))
pattern = midi.read_midifile("midi/5RAP_04.MID")
pattern = midisanitize.sanitize(pattern)
record["data"] = midiutil.midi_to_data(pattern)
record["ticks_per_bar"] = midiutil.calculate_bar_duration(pattern)
pattern.make_ticks_abs()
record["max_tick"] = pattern[0][-1].tick
pattern.make_ticks_rel()
record["track_names"] = midiutil.get_track_names(pattern)
record["bars"] = []
print "### Splitting to Bars"
for bar in range(record["max_tick"]/record["ticks_per_bar"]):
bar_pattern = midiutil.get_bar_from_pattern(pattern, bar)
bar_id = generate_id_from_data(midiutil.midi_to_data(bar_pattern))
bar = {"name": str(bar), "id":bar_id, "data":midiutil.midi_to_data(bar_pattern)}
record["bars"].append(bar)
record["tracks"] = []
tracks = midiutil.split_tracks_to_patterns(pattern)
print "### Splitting to Tracks"
for index, name in enumerate(record["track_names"]):
track_pattern = tracks[index]
track_id = generate_id_from_data(midiutil.midi_to_data(track_pattern))
track = {"name": name, "data":midiutil.midi_to_data(track_pattern)}
record["tracks"].append(track)
record["bars_tracks"] = []
print "### Splitting to Tracks and Bars"
for bar in range(record["max_tick"]/record["ticks_per_bar"]):
bar_pattern = midiutil.get_bar_from_pattern(pattern, bar)
tracks = midiutil.split_tracks_to_patterns(bar_pattern)
for index, name in enumerate(record["track_names"]):
bar_track_pattern = tracks[index]
bars_tracks_id = generate_id_from_data(midiutil.midi_to_data(bar_track_pattern))
bar_track = {"name": "track:"+name+" bar:"+str(bar), "id":bars_tracks_id, "data":midiutil.midi_to_data(bar_track_pattern)}
record["bars_tracks"].append(bar_track)
return record
def generate_bar(self):
target_pattern = self.target.current_pattern
max_tick = midiutil.calculate_bar_duration(target_pattern)
pattern = midi.Pattern(resolution = target_pattern.resolution, tick_relative=False)
track = midi.Track(tick_relative=False)
was_rel = target_pattern.tick_relative
if was_rel:
target_pattern.make_ticks_abs()
for traget_track in target_pattern:
for event in traget_track:
if (event.tick%(max_tick/2) == 0 or event.tick%(max_tick/4)==0 or event.tick%(max_tick/8)==0) and event.name =="Note On":
#print "ADDING NOTE"
pitch = event.pitch
pitch = midiutil.map_note_to_range(event.pitch, self.instrument["range_min"], self.instrument["range_max"])
if random.random() > 0.5:
print ">>>>>>>>>>>>> up 5"
pitch += 5
if random.random() > 0.5:
print ">>>>>>>>>>>>> up 12"
pitch += 12
e_on = midi.NoteOnEvent(pitch=pitch, velocity=125, tick=event.tick, channel=self.instrument["output_channel"])
e_off = midi.NoteOffEvent(pitch=pitch, velocity=125, tick=event.tick+400, channel=self.instrument["output_channel"])
track.append(e_on)
track.append(e_off)
if was_rel:
target_pattern.make_ticks_rel()
#for i in range(70):
#track.append(midi.NoteOnEvent(tick = i*100, velocity=100, pitch=20+i, channel=2))
track.sort()
pattern.append(track)
pattern.make_ticks_rel()
#print pattern
return pattern
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)
