class TrackBuilder(object): def __init__(self): self.track = Track() self.previous = None def add_symbol(self, name): symbol = Symbol.get_symbol(name) self.previous = symbol self.accidental = 0 symbol.action(self) def add_note(self, note): mnote = mingusNote(note.n) self.track.add_notes(mnote, note.duration) def add_rest(self, rest): self.track.add_notes(None, rest.duration) def set_clef(self, clef): self.clef = clef def add_accidental(self, accidental): if accidental.name == 'sharp': self.accidental = 1 elif accidental.name == 'flat': self.accidental = -1 else: self.accidental = 0 def flush(self): return self.track
def setUp(self): self.commonbar = Bar() self.ebar = Bar('E', (4, 4)) self.fbar = Bar('F', (6, 8)) self.tbar = Bar('C', (4, 4)) self.mbar = Bar('C', (4, 4)) self.a_minor_bar = Bar('a', (4, 4)) self.b_flat_minor_bar = Bar('bb', (4, 4)) self.f_sharp_minor_bar = Bar('f#', (4, 4)) for y in [self.commonbar, self.ebar, self.fbar]: map(lambda x: y + x, ['C', 'E', 'G', 'B']) map(lambda x: self.tbar.place_notes(NoteContainer(x), 6), [ 'C', 'E', 'G', 'B', 'C', 'E', ]) map(lambda x: self.mbar.place_notes(NoteContainer(x), 4), ['C', 'E']) map(lambda x: self.mbar.place_notes(NoteContainer(x), 6), ['G', 'B', 'C' ]) self.track1 = Track() self.track1 + self.commonbar self.track2 = Track() self.track2 + self.commonbar self.track2 + self.ebar self.composition1 = Composition() self.composition1.add_track(self.track1) self.composition2 = Composition() self.composition2.add_track(self.track1) self.composition2.add_track(self.track2)
def setUp(self): # LilyPond output files are created in current working directory self.tempdir = tempfile.mkdtemp() self.oldcwd = os.getcwd() os.chdir(self.tempdir) self.commonbar = Bar() self.ebar = Bar("E", (4, 4)) self.fbar = Bar("F", (6, 8)) self.tbar = Bar("C", (4, 4)) self.mbar = Bar("C", (4, 4)) self.a_minor_bar = Bar("a", (4, 4)) self.b_flat_minor_bar = Bar("bb", (4, 4)) self.f_sharp_minor_bar = Bar("f#", (4, 4)) for y in [self.commonbar, self.ebar, self.fbar]: list(map(lambda x: y + x, ["C", "E", "G", "B"])) for x in ["C", "E", "G", "B", "C", "E"]: self.tbar.place_notes(NoteContainer(x), 6) for x in ["C", "E"]: self.mbar.place_notes(NoteContainer(x), 4) for x in ["G", "B", "C"]: self.mbar.place_notes(NoteContainer(x), 6) self.track1 = Track() self.track1 + self.commonbar self.track2 = Track() self.track2 + self.commonbar self.track2 + self.ebar self.composition1 = Composition() self.composition1.add_track(self.track1) self.composition2 = Composition() self.composition2.add_track(self.track1) self.composition2.add_track(self.track2)
def test_transpose(self): t = Track() t + 'C' t + 'E' t.transpose('3') s = Track() s + 'E' s + 'G#' self.assertEqual(s, t)
def screen_to_track(user): """Returns a mingus NoteContainer generated from the screenname of a person""" user_id = user.idnumber id_88 = base88_encode(user_id) out_track = Track() for i in id_88: out_track.add_notes(Note().from_int(i)) return out_track
def words_to_track(words): """Converts a string to a track, based on the the unicode code point, as given by ord()""" words_88 = [base88_encode(ord(x)) for x in words] notes = [Note().from_int(x) for letter in words_88 for x in letter] out_track = Track() for i in notes: out_track.add_notes(i) return out_track
def extend_track(track, length): """Repeats the bars of a track until it reaches the given length.""" new_track = Track() while len(new_track) < length: for i in track: new_track.add_bar(i) if len(new_track) == length: return new_track return new_track
def test_transpose(self): t = Track() t + "C" t + "E" t.transpose("3") s = Track() s + "E" s + "G#" self.assertEqual(s, t)
def test_equality(self): self.assertEqual(self.i, self.p) self.assertEqual(self.i, self.g) self.assertEqual(self.i, self.tr) t = Track() t + "C" t + "E" s = Track() s + "E" s + "G#" self.assertNotEqual(t, s) u = Track() u + "E" u + "G#" self.assertEqual(s, u)
def generate_and_write_music( output_file, music_length, lengths_distribution, bpm, ): import mingus.core.notes as notes from mingus.containers.note import Note from mingus.containers.track import Track from mingus.midi import midi_file_out track = Track() for note, length in generate_music(music_length, lengths_distribution, note_base=36): n = Note() n.from_int(note) track.add_notes(n, length) midi_file_out.write_Track(output_file, track, bpm=bpm)
def setup_composition(nbars=64, ntracks=2, quant=16): comp = Composition() tks =[Track() for i in xrange(ntracks)] for i in xrange(ntracks): bars = [Bar() for j in xrange(nbars)] for j in xrange(nbars): init_bar(bars[j], quant) tks[i] + bars[j] comp + tks[i] return comp
def __init__(self, nsteps=16, nbars=16, tempo=120, duration=16): # self.bd = Note('C', 2) # bass drum self.bd = Note('B', 1) # bass drum self.bd.channel = 9 self.lt = Note('F', 2) # lo tom self.lt.channel = 9 self.ht = Note('B', 2) # hi tom self.ht.channel = 9 self.lb = Note('C#', 4) # lo bongo self.lb.channel = 9 self.hb = Note('C', 4) # hi bongo self.hb.channel = 9 self.ch = Note('F#', 2) # closed hat self.ch.channel = 9 self.oh = Note('A#', 2) # open hat self.oh.channel = 9 self.sn = Note('D', 2) # snare self.sn.channel = 9 self.DRMAP={"bd":self.bd, "sn":self.sn, "ch":self.ch, "oh":self.oh, "lt":self.lt, "ht":self.ht, "hb":self.hb, "lb":self.lb} for x in self.DRMAP.keys(): self.DRMAP[x].velocity = 100 self.DRMAP[x].duration = duration self.tk = Track() self.bds="" self.sns="" self.hts="" self.lts="" self.chs="" self.ohs="" self.lbs="" self.hbs="" self.bdv=[] self.snv=[] self.htv=[] self.ltv=[] self.chv=[] self.ohv=[] self.lbv=[] self.hbv=[] self.m = MidiInstrument() # TR-808 kit = 25 (26 but zero-based!) # self.m.instrument_nr = 25 self.m.instrument_nr = 0 self.m.channel = 9 self.tk.instrument = self.m self.nsteps = nsteps self.dur = duration self.n_bars = nbars self.tempo = tempo self.STRMAP={"bd":self.bds, "sn":self.sns, "ch":self.chs, "oh":self.ohs, "lt":self.lts, "ht":self.hts, "hb":self.hbs, "lb":self.lbs} self.VARMAP={"bd":self.bdv, "sn":self.snv, "ch":self.chv, "oh":self.ohv, "lt":self.ltv, "ht":self.htv, "hb":self.hbv, "lb":self.lbv} self.vartype = self._OR_VAR_
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
for i in range(len(composition.tracks)): m.tracks[i].play_Track(composition.tracks[i]) repeat -= 1 return m.write_file(file, verbose) if __name__ == "__main__": from mingus.containers.note_container import NoteContainer from mingus.containers.bar import Bar from mingus.containers.track import Track from mingus.containers.instrument import MidiInstrument b = Bar() b2 = Bar("Ab", (3, 4)) n = NoteContainer(["A", "C", "E"]) t = Track() b + n b + [] b + n b + n b2 + n b2 + n b2 + [] t + b t + b m = MidiInstrument() m.instrument_nr = 13 t.instrument = m t.name = "Track Name Test" write_NoteContainer("test.mid", n) write_Bar("test2.mid", b)
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 __init__(self): self.track = Track() self.previous = None
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)
def from_Bar(bar): c = Composition() t = Track() t.add_bar(bar) c.add_track(t) return _composition2musicxml(c).toprettyxml()
def setUp(self): self.i = Track(Instrument()) self.p = Track(Piano()) self.g = Track(Guitar()) self.tr = Track()
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)
def sum_tracks(tracks): new_track = Track() for track in tracks: for bar in track: new_track.add_bar(bar) return new_track
name = note_string[0:1].upper() number = name_to_number.NOTES.index(name) acc = accidentals(note_string) return mod12(number + acc) name_to_number.NOTES = "C . D . E F . G . A . B".split() if __name__ == '__main__': import argparse import random # from mingus.containers.bar import Bar from mingus.containers.track import Track notes = [0] for t in range(30): note = notes[-1] notes.append(note + random.randint(0, 12)) t = Track() notes = map(note_name, notes) for n in notes: t.add_notes(n) parser = argparse.ArgumentParser() parser.add_argument('--output', type=str, default='out.mid') args = parser.parse_args() from mingus.midi import midi_file_out midi_file_out.write_Track(args.output, t)