def load_from_song(self, song): ''' Fills a mingus-composition object with the data of a Song object ''' if 'bar_length' in song.info: try: self.bar_length = song.info['bar_length'] except: print ("You need to specify length of a Bar first before you can do this") for line in song.lines: track = Track() bar = Bar() for segment in line.segments: if segment.type == 'pause': int_val = None elif segment.type == 'note': int_val = segment.pitch n = Note().from_int(int_val + 48) note_length = float(self.bar_length) / segment.duration if not bar.place_notes(n, note_length): track.add_bar(bar) bar = Bar() bar.place_notes(n, note_length) track.add_bar(bar) self.composition.add_track(track) self.path = song.path self.song_name = song.reader.file_name[:-4]
def main(): fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2',"alsa") solution = [52,52,53,55,55,53,52,50,48,48,50,52,52,50,50] #testSol = [1,3,53,55,55,53,52,50,48,48,50,52,52,50,50] population = createInitialPopulation(250, len(solution)) #t = Track() #for note in findMostFit(population,solution): # t + note #fluidsynth.play_Track(t,1) generation = 1 highestFitness = calcFitness(findMostFit(population, solution), solution) print("Generation: 1") print("Initial Highest Fitness: " + str(highestFitness)) #print(calcFitness(testSol,solution)) while highestFitness < 1: population = createNewPopulation(population, solution, .01) generation = generation + 1 highestFitness = calcFitness(findMostFit(population, solution), solution) print("Generation: " + str(generation)) print("Highest Fitness level: " + str(highestFitness)) if generation % 10 == 0: print("hi") t = Track() for noteInt in findMostFit(population,solution): newNote = Note() newNote.from_int(noteInt) t + newNote fluidsynth.play_Track(t,1) #time.sleep(10) t = Track() for note in findMostFit(population,solution): t + note fluidsynth.play_Track(t,1)
def generate(self): nr_of_bars = random.randint(3,10) diatonic = self.get_major_scale("A") # example : ['C', 'Db', 'Eb', 'F', 'G', 'Ab', 'Bb'] arrangement = self.basic_song_structure() # arragement.structure and arragement.parts are used generated_parts = [] for i in range(0,len(arrangement["parts"])): proggresion = self.random_progression(diatonic,"-2") rhythm = self.gen_rhythm(proggresion) generated_bar_with_rhythm = self.gen_with_rhythm(proggresion,rhythm,diatonic) print "proggresiion ="+ str(proggresion) print "rhythm= " + str(rhythm) generated_bar = self.gen_simple(diatonic,4,proggresion) generated_parts.append(generated_bar_with_rhythm) song = Track() for i in arrangement["structure"]: song.add_bar(generated_parts[i]) self.gen_rhythm(proggresion) return song
def vector_to_midi(arr, filename="nice.midi"): track = Track() for note_arr in arr: note_num = int(np.argmax(note_arr)) note = Note() note.from_int(note_num - 3) track.add_notes(note) write_Track(filename, track) print("Done!")
async def on_start(self): self.agent.set("current_bar_no", 0) # inicializa "current_bar_no" en 0 # self.agent.set("tempo", 120) # self.agent.set("key", "C") self.agent.set("melody_track", Track()) self.agent.set("accompaniment_track", Track()) self.agent.set("current_melody_bar", Bar(CFG.SONG_KEY_SIGNATURE, CFG.SONG_TIME_SIGNATURE)) self.agent.set("current_accompaniment_bar", Bar(CFG.SONG_KEY_SIGNATURE, CFG.SONG_TIME_SIGNATURE))
def __init__(self): """ function to initialize PianoPlayer class """ self.track = Track(Piano()) self.notes = [] #initialize keys for i in range(21, 109): self.notes.append(i) self.matrix = {} for n in self.notes: i = int(n) self.matrix[i] = [0] * 10
def input_list(list_of_note_tuples): #track to return track = Track() #For every tuple in input for (name, duration) in list_of_note_tuples: #If we can't add note (duration is too long) if not (track.add_notes(name, duration)): #Calculate new duration to fit bar and add note space_left = track[-1].space_left() track.add_notes(name, int(1.0 / space_left)) return track
def fib_seq(offset=0): track = Track(instrument=Piano()) stop_at = 60 i = 1 f = 1 while f < stop_at: f = fib(i) + offset ni = f % 12 octave = (f / 12) + 1 note = notes.int_to_note(ni) track.add_notes('%s-%d'%(note, octave), 4) i += 1 return track
def NewTrack(beats, count, withChromatics, with16): """ NewTrack(liczba_uderzeń_w_takcie, liczba_taktów, czy_z_chromatyką, czy_z_16) zwraca krotkę z trackiem i liczbą nut """ track = Track(Instrument()) rhythms = [] noOfNotes = 0 melodyCount = 0 for ii in range(count): rhythms.append(newBarRhythm(beats, with16)) noOfNotes += len(rhythms[ii]) if withChromatics: melody = newMelody(noOfNotes) else: melody = newMelodyWithoutChromatics(noOfNotes) for rhythm in rhythms: b = Bar("C", (beats, 4)) for note in rhythm: k = random.random() if k > pOfRests: b.place_notes(melody[melodyCount], 4 / note) else: b.place_notes(None, 4 / note) melodyCount += 1 track + b return (track, melodyCount)
def play(self, melody, chords, bpm, scores, bars, key, mode, modeToPass, tra, file, out_dir): t2 = Track() sh = progressions.to_chords(chords, key) for i in range(0, len(sh)): b = Bar(None, (4, 4)) if len(chords[i][0]) > 5: b.place_notes(None, 1) else: b.place_notes(NoteContainer(sh[i]), 1) t2 + b fluidsynth.pan(1, 25) fluidsynth.pan(2, 120) fluidsynth.main_volume(2, 50) fluidsynth.play_Tracks([melody, t2], [1, 2], bpm) # sleep(500000) button = Button(text='Clique para rearmonizar!', command=lambda: self.checkReharmonize( chords, scores, bars, key, mode, modeToPass, tra, bpm, file, out_dir), bg='brown', fg='white', font=('helvetica', 9, 'bold')) self.canvas1.create_window(200, 250, window=button)
def get_track(self, dict): """ parse track from matrix representation :param dict: mapping of beats to notes that occurred on that particular beat :param length: :return: """ track = Track() for key in sorted(dict.iterkeys()): notes = dict[key] mingus = [] for chord in notes: mingus.append(chord[0]) track.add_notes(mingus) return track
def track_creator(instrument_name, channel): instrument = MidiInstrument() track = Track(instrument, channel=channel) instrument.name = instrument_name track.instrument.instrument_nr = MidiInstrument.names.index( instrument_name) return track
def init_random_track(key, is_subject=True): notes = keys.get_notes(key) bar = Bar(key=key) while bar.current_beat < 1: # Randomize pitch and duration of each note. duration = 2**random.randint(1, 3) pitch = notes[random.randint(0, 6)] # If it is intened to be a subject, set the first note to the root. if bar.current_beat == 0 and is_subject == True: pitch = notes[0] # If the randomized duration doesn't fit in the bar, make it fit if 1 / duration > 1 - bar.current_beat: duration = 1 / (1 - bar.current_beat) # Place the new note in the bar bar.place_notes(pitch, duration) # Create a track to contain the randomized bar track = Track() track + bar # Return the track return track
def __init__(self): self.instrument = "Electric Piano 1" self.tempo = 120.0 self.notes = Track() self.length = 16 self.key = "C" self.raw_song = [] self.weights = None
def play_smart_solo_over_chords(chord_list): fluidsynth.set_instrument(13, 45) fluidsynth.set_instrument(10, 108) fluidsynth.main_volume(13, 75) fluidsynth.main_volume(10, 100) solo = Track() bars = generate_solo(chord_list) for i in range(len(bars)): chord = NoteContainer(chords.from_shorthand(chord_list[i])) bar = bars[i] fluidsynth.play_NoteContainer(chord, 13) fluidsynth.play_Bar(bar, 10) fluidsynth.stop_NoteContainer(chord, 13) solo.add_bar(bar) return solo
def convert_pattern_to_mingus_track(ctx, patterns): result = Track() result.instrument = MidiPercussionInstrument() for pattern in patterns: resolution = pattern.attributes["resolution"] for tick in pattern.get_ticks(): placed = result.add_notes(tick.notes, resolution) if not placed: result.bars[-1].current_beat = result.bars[-1].length max_length = result.bars[-1].length - \ result.bars[-1].current_beat if max_length == 0.0: print "wut" continue else: print result.add_notes(tick.notes, 1.0 / max_length) print max_length, 1.0 / max_length, resolution, result.bars[-1].current_beat + max_length return result
def createMingusComposition(intermed, timesig, bIsTreble, bSharps): comp = Composition() comp.set_title('Trilled Results') comp.set_author('Author') if bIsTreble: ins = TrebleInstrument('') else: ins=BassInstrument('') track = Track(ins) track.name = 'Part 1' comp.add_track(track) assert len(timesig)==2 and isinstance(timesig[0],int) and isinstance(timesig[1],int) firstbar = Bar(meter=timesig) track.add_bar(firstbar) mapDurs={ int(intermed.baseDivisions*4): 1.0, #whole note, int(intermed.baseDivisions*2): 2.0, #half note int(intermed.baseDivisions*1): 4.0, #qtr note, and so on int(intermed.baseDivisions*0.5): 8.0, int(intermed.baseDivisions*0.25): 16.0, int(intermed.baseDivisions*0.125): 32.0, int(intermed.baseDivisions*0.0625): 64.0, } for note in intermed.noteList: if note.pitch==0 or note.pitch==(0,): # a rest thepitches = tuple() else: # a note thepitches = [] for pitch in note.pitch: pname, poctave = music_util.noteToName(pitch,bSharps) thepitches.append(pname+'-'+str(poctave)) dur = note.end - note.start if dur not in mapDurs: raise NotesinterpretException('Unknown duration:' + str(dur)) notecontainer = NoteContainer(thepitches) notecontainer.tied = note.isTied bFit = track.add_notes(notecontainer, mapDurs[dur]) assert bFit #note that, naturally, will enforce having correct measure lines, since going across barline throughs exception return comp
def notes_durations_to_track(_notes, durations=None): ''' params: - _notes: list of list of Notes [['G','B','D','F'], ['C','E','G','B']] - durations: Durations should be a list of integers e.g. [2,2,1] will give | chord 1 chord 2 | chord 3 | TO-DO: - mingus durations are limited to =< 1 bar; we want to be able to parse a duration of '0.5' (because in mingus '4'=crotchet i.e. num subdivs) to refer to 2 bars (just use 1/d) ''' if durations is None: durations = [1] * len(_notes) t = Track() for i, _note in enumerate(_notes): b = Bar() b.place_notes(_note, durations[i]) t.add_bar(b) return t
def playTrack(arr): fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2',"alsa") SF2 = '/usr/share/sounds/sf2/FluidR3_GM.sf2' if not fluidsynth.init(SF2): print "Couldn't load soundfont", SF2 sys.exit(1) t = Track() for note in arr: t + note fluidsynth.play_Track(t,1)
class TrackBuilder(object): def __init__(self): self.track = Track() def fill_bars(self, arpeggio, note_duration=16, bars=1): generator = arpeggio.get_generator() while bars > 0: b = Bar() b.key = 'C' while not b.is_full(): b.place_notes(generator.next(), note_duration) self.track.add_bar(b) bars -= 1 return self.track def from_dsl(self, string): plan, bpm, loop = dsl.parse_string(string) for x in range(loop): for arpeggio, duration in plan: self.fill_bars(arpeggio, duration[0], duration[1]) return self.track, bpm
class TrackBuilder(object): def __init__(self): self.track = Track() def fill_bars(self, arpeggio, note_duration = 16, bars = 1): generator = arpeggio.get_generator() while bars > 0: b = Bar() b.key = 'C' while not b.is_full(): b.place_notes(generator.next(), note_duration) self.track.add_bar(b) bars -= 1 return self.track def from_dsl(self, string): plan, bpm, loop = dsl.parse_string(string) for x in range(loop): for arpeggio, duration in plan: self.fill_bars(arpeggio, duration[0], duration[1]) return self.track, bpm
def shift(track, pause_duration): key = track[0].key shifted_track = Track() bar = Bar(key=key) bar.place_rest(pause_duration) input_note_containers = track.get_notes() for note in input_note_containers: placed = bar.place_notes(note[-1], note[1]) if not placed: beat_left = 1.0 - bar.current_beat beats_part_1 = beat_left beats_part_2 = 1 / note[1] - beats_part_1 if beats_part_1 != 0: duration_part_1 = 1 / beats_part_1 bar.place_notes(note[-1], duration_part_1) shifted_track.add_bar(copy.deepcopy(bar)) bar = Bar(key=key) duration_part_2 = 1 / beats_part_2 bar.place_notes(note[-1], duration_part_2) shifted_track.add_bar(copy.deepcopy(bar)) return shifted_track
def load_from_song(self, song): ''' Fills a mingus-composition object with the data of a Song object ''' if 'bar_length' in song.info: try: self.bar_length = song.info['bar_length'] except: print "You need to specify length of a Bar first before you can do this" for line in song.lines: track = Track() bar = Bar() for segment in line.segments: if segment.type == 'pause': int_val = None elif segment.type == 'note': int_val = segment.pitch n = Note().from_int(int_val + 48) note_length = float(self.bar_length) / segment.duration if not bar.place_notes(n, note_length): track.add_bar(bar) bar = Bar() bar.place_notes(n, note_length) track.add_bar(bar) self.composition.add_track(track) self.path = song.path self.song_name = song.reader.file_name[:-4]
def generate_track(g, n, name): root = np.random.randint(0, n) edges = nx.bfs_edges(g.G, root) nodes = [root] + [v for u, v in edges] m = MidiInstrument(4) t = Track() track = [] t.instrument = m nNotes = 0 print("##### Creating Tracks") for x in nodes: value = t.add_notes(NoteContainer(g.G.nodes[x]["note"]), g.G.nodes[x]["duration"]) t.bars[-1].set_meter((n, 1)) track.append(g.G.nodes[x]["note"]) nNotes = nNotes + 1 print("##### Notes Generated:") print(*t) print("##### Number of notes:") print(nNotes) midi_file_out.write_Track(name + ".mid", t) return t
def main(config_path): pickle_in = open("saved_winners.pickle", "rb") genomes = pickle.load(pickle_in) pickle_in.close() config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) for x, genome in enumerate(genomes): trainer.eval_fitness([(1, genome)], config) fitness = genome.fitness float_name = fitness * 1000 int_name = int(float_name) name = str(int_name) os.mkdir(name) for i in range(15): song = trainer.generate_song(x + 1) track = Track() for bar in song: track.add_bar(bar) xml = musicxml.from_Track(track) path = name + "\\" + str(i) + ".musicxml" xml_file = open(path, "w") xml_file.write( '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 2.0 Partwise//EN"\n "http://www.musicxml.org/dtds/partwise.dtd">\n' + xml)
class Song: instrument = "Electric Piano 1" #instrument tempo = 120.0 #tempo in beats per minute notes = Track() #Actual sequence of Notes (defined above) weights = None length = 16 #number of bars in the song key = "C" #key of the song raw_song = [] #the song as a simple list of note/duration pairs def __init__(self): self.instrument = "Electric Piano 1" self.tempo = 120.0 self.notes = Track() self.length = 16 self.key = "C" self.raw_song = [] self.weights = None
def write_mingus(self, outfile): notes = list(self.timeseries['Notes']) t = Track() for n in range(len(notes)): if n % 4 == 0: b = Bar(self.key, (4, 4)) if notes[n] != 'Z': b + notes[n] else: b + None if (n + 1) % 4 == 0: t + b self.composition + t self.track = t lily_composition = LilyPond.from_Composition(self.composition) print lily_composition LilyPond.to_pdf(lily_composition, outfile)
def sheets_from_peaks(peaks): """Generate and open the sheet music pdf that represents the notes contained in peaks.""" bass_range = Instrument() bass_range.set_range(['A-0', 'C-4']) bass_track = Track(bass_range) treble_range = Instrument() treble_range.set_range(['C-4', 'C-8']) treble_track = Track(treble_range) treble_track.add_bar(Bar()) bass_track.add_bar(Bar()) for time_slice in peaks: bass_chord, treble_chord = [], [] for note_index, note_value in enumerate(time_slice): if note_value: # add 9 to note_index to start at A-0 note = Note().from_int(note_index + 9) if bass_range.note_in_range(note): bass_chord.append(note) elif treble_range.note_in_range(note): treble_chord.append(note) if bass_chord == treble_chord == []: continue for chord, track in ((bass_chord, bass_track), (treble_chord, treble_track)): if track.bars[-1].is_full(): track.add_bar(Bar()) if chord: print chord track.bars[-1] + chord print track else: track.bars[-1].place_rest(4) print bass_track print treble_track merge_rests(treble_track, bass_track) save_and_print(treble_track, bass_track)
def change_speed(track, factor, key, up=True): changed_track = Track() #if factor is 0 we return an empty track if (factor != 0.0): input_track = copy.deepcopy(track) input_notes = input_track.get_notes() b = Bar(key=key) changed_track.add_bar(b) #if we want to speed up (notespeed *= factor) if up: for note in input_notes: changed_track.add_notes(note[-1], int(note[1] * factor)) #if we want to slow down (notespeed *= (1/factor)) else: for note in input_notes: changed_track.add_notes(note[-1], int(note[1] / factor)) return changed_track
def createMingusComposition(intermed, timesig, bIsTreble, bSharps): comp = Composition() comp.set_title('Trilled Results') comp.set_author('Author') if bIsTreble: ins = TrebleInstrument('') else: ins = BassInstrument('') track = Track(ins) track.name = 'Part 1' comp.add_track(track) assert len(timesig) == 2 and isinstance(timesig[0], int) and isinstance( timesig[1], int) firstbar = Bar(meter=timesig) track.add_bar(firstbar) mapDurs = { int(intermed.baseDivisions * 4): 1.0, #whole note, int(intermed.baseDivisions * 2): 2.0, #half note int(intermed.baseDivisions * 1): 4.0, #qtr note, and so on int(intermed.baseDivisions * 0.5): 8.0, int(intermed.baseDivisions * 0.25): 16.0, int(intermed.baseDivisions * 0.125): 32.0, int(intermed.baseDivisions * 0.0625): 64.0, } for note in intermed.noteList: if note.pitch == 0 or note.pitch == (0, ): # a rest thepitches = tuple() else: # a note thepitches = [] for pitch in note.pitch: pname, poctave = music_util.noteToName(pitch, bSharps) thepitches.append(pname + '-' + str(poctave)) dur = note.end - note.start if dur not in mapDurs: raise NotesinterpretException('Unknown duration:' + str(dur)) notecontainer = NoteContainer(thepitches) notecontainer.tied = note.isTied bFit = track.add_notes(notecontainer, mapDurs[dur]) assert bFit #note that, naturally, will enforce having correct measure lines, since going across barline throughs exception return comp
def setup_tracks(midi_file_out=None): from tracks import melodies, cantus_firmus, key, meter, species, author # Create a composition, and add the vocal tracks to it. composition = Composition() composition.set_title('Counterpoint Exercise', '') composition.set_author(author, '') # Set up our vocal 'tracks' with the notes, key, meter defined in tracks.py tracks = {} for voice in [Soprano, Alto, Tenor, Bass]: if len(melodies[voice.name]): tracks[voice.name] = Track(instrument=voice()) tracks[voice.name].add_bar(Bar(key=key, meter=meter)) tracks[voice.name].name = voice.name for note in melodies[voice.name]: tracks[voice.name].add_notes(*note) composition.add_track(tracks[voice.name]) if midi_file_out is not None: # Save the midi file! write_Composition(midi_file_out, composition, verbose=True) return composition, [], species
def reverse(track, key='C'): # Copy value of reference to aviod problems with overwriting input_track = copy.deepcopy(track) #empty track to write to later reversed_track = Track() b = Bar(key) reversed_track.add_bar(b) #create a reversed list of notes from input track input_notes = input_track.get_notes() reversed_notes = reversed(list(input_notes)) #Add notes to reversed_track for note in reversed_notes: reversed_track.add_notes(note[-1], duration=note[1]) # Return reversed track return reversed_track
def export(melody_track, chords, key, time_sig, bpm, file): i = Instrument() i.instrument_nr = 1 t2 = Track() for i in range(0, len(chords)): b = Bar(key, time_sig) if len(chords[i][0]) > 5: b.place_notes(None, 1) else: b.place_notes(NoteContainer(chords[i]), 1) t2 + b c = Composition() c.add_track(melody_track) c.add_track(t2) out_dir = 'out' if not os.path.exists(out_dir): os.makedirs(out_dir) mid = file.split('/')[-1] if os.path.exists(out_dir + '/' + mid): os.remove(out_dir + '/' + mid) MidiFileOut.write_Composition(out_dir + '/' + mid, c, bpm) file = out_dir + '/' + mid sys.argv.append('') sys.argv.append('') sys.argv[1] = "--midi-file=" + file sys.argv[2] = "--out-dir=" + out_dir midi.main() if os.path.exists(file): os.remove(file)
def __init__(self): self.track = Track()
tr = lambda note: chords.triad(note, "C") # that's stupid # http://www.youtube.com/watch?v=5pidokakU4I prg = [tr("C"), tr("G"), tr("A"), tr("F")] bars = [] for chord in prg: b = Bar() b.place_notes(chord, 4) bars.append(b) t = Track() for b in bars: t.add_bar(b) instrs = list(enumerate(MidiInstrument.names)) shuffle(instrs) for i, name in instrs: print i, name fluidsynth.set_instrument(1, i) fluidsynth.play_Track(t)
cymbalpercussion = [] tompercussion = [] major_chords = [ simple_chordI, simple_chordIV, simple_chordV, simple_chordIi, complex_chordI, complex_chordIV, complex_chordV, complex_chordIi ] minor_chords = [ simple_chordII, simple_chordIII, simple_chordVI, simple_chordV7, complex_chordII, complex_chordIII, complex_chordVI, complex_chordV7 ] left_hand_music = [] right_hand_list = [] right_hand_music = [] downbeatbar = Bar() righthandbar = Bar() synthtrack1 = Track() synthtrack1.instrument = synth electricguitartrack1 = Track() electricguitartrack1.instrument = electricguitar brasstrack1 = Track() brasstrack1.instrument = brass bassetrack1 = Track() bassetrack1.instrument = basse strintrack1 = Track() strintrack1.instrument = string guitartrack1 = Track() guitartrack1.instrument = guitar frhorntrack1 = Track() frhorntrack1.instrument = frhorn righthandtrack1 = Track() righthandtrack1.instrument = brightpiano
def Track_from_list(listt=[[[0.0, 8.0, None], [0.125, 16.0, ['C-6']]]]): t = Track() for bars in listt: t.add_bar(bars) return t
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 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 gen_midi(self, tracks_data): c = Composition() all_tracks = tracks_data["tracks_data"] curr_track = 0; for track_data in all_tracks: #TODO: set author, title, more specific instrument (that has a #range set data_max = max(track_data["note_data"]) data_min = min(track_data["note_data"]) data_dur_max = max(track_data["dur_data"]) data_dur_min = min(track_data["dur_data"]) data_range = data_max - data_min ####DURATIONS#### midi_durs = [self.map_range(0, len(self.mapping_dur_vals) - 1, data_dur_min, data_dur_max, x, "dur") for x in track_data["dur_data"]] midi_durs = [self.mapping_dur_vals[int(x)] for x in midi_durs] print "midi_durs: " print midi_durs ####PITCHES#### midi_vals = [self.map_range(0, len(self.overall_mapping_vals) - 1, data_min, data_max, x, "notes") for x in track_data["note_data"]] midi_vals = [self.overall_mapping_vals[int(x)] for x in midi_vals] print "midi_pitches: " print midi_vals for instr in self.instrs: t = Track() b = Bar() for index, midi_val in enumerate(midi_vals): print "-----------------" print "space left in bar" print b.space_left() if midi_val in instr["mapping_vals"]: print "inserting NON-REST NOTE" print "inserting NON-REST NOTE" val_to_insert = Note().from_int(int(midi_val)) print "DONE INSERTING NON-REST NOTE" else: print "INSERTING REST" val_to_insert = None #insert rest instead print "ABOUT TO INSERT" dur_to_insert_1 = 1.0/((1.0/float(midi_durs[index])) * 0.99) dur_to_insert_2 = 1.0/((1.0/float(midi_durs[index])) * 0.01) b, insert_result_1 = self.insert_into_bar(curr_track, b, val_to_insert, dur_to_insert_1) print "trying to insert note..." print insert_result_1 print "midi note DURATION is: " print midi_durs[index] if insert_result_1: b, insert_result_2 = self.insert_into_bar(curr_track, b, None, dur_to_insert_2) print "trying to insert note..." print insert_result_2 print "midi note DURATION is: " print midi_durs[index] if not insert_result_1: if b.space_left() == 0.0: print "hit edge case!!!!" t.add_bar(b) b = Bar() b, insert_result = self.insert_into_bar(curr_track, b, val_to_insert, dur_to_insert_1) b, insert_result = self.insert_into_bar(curr_track, b, None, dur_to_insert_2) print "bar is now (after edge case): " print b continue space_p = b.space_left() space = 1.0/space_p print "space percentage left: " print space_p print "note space left: " print space note_remainder = value.subtract(midi_durs[index], space) print "note duration: " print midi_durs[index] print "note remainder: " print note_remainder print "bar before INSERTING PART 1 OF TIE: " print b dur_to_insert_1_space = 1.0/((1.0/float(space)) * 0.99) dur_to_insert_2_space = 1.0/((1.0/float(space)) * 0.01) if space <= 16.0: print "NOTE IS LARGER THAN 16 NOTE" b, insert_result = self.insert_into_bar(curr_track, b, val_to_insert, dur_to_insert_1_space) b, insert_result = self.insert_into_bar(curr_track, b, None, 1.0/b.space_left()) else: print "NOTE IS *NOT* LARGER THAN 16 NOTE" b, insert_result = self.insert_into_bar(curr_track, b, None, space) print "bar AFTER: " print b print "inserting part one of tie result: " print insert_result print "is bar full??? (IT SHOULD BE)" print b.is_full() t.add_bar(b) b = Bar() b, insert_result = self.insert_into_bar(curr_track, b, None, note_remainder) print "inserting part TWO of tie result: " print insert_result print "bar after inserting remaining piece: " print b print "BAR IS NOW" print b #end for #add last bar if b.space_left() == 0.0: t.add_bar(b) else: #need to fill remaining space with rest space_p = b.space_left() space = 1.0/space_p #b, insert_result = self.insert_into_bar(curr_track, b, # Note(None), space) print "result for filling rest of last bar with rest: " print insert_result print "is bar full after adding rest to end of last bar??? (IT SHOULD BE)" print b.is_full() print "bar WITH REST is now: " print b t.add_bar(b) logger.debug("Track: ") logger.debug(t) #at very end of loop add track to composition c.add_track(t) curr_track += 1 #write_Composition("midi_success.mid", c); return self.gen_midi_data(c)
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) # note off if event["event"] == 8: if deltatime == 0: pass # note on elif event["event"] == 9: 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 # note aftertouch elif event["event"] == 10: pass # controller select elif event["event"] == 11: pass # program change elif event["event"] == 12: i = MidiInstrument() i.instrument_nr = event["param1"] t.instrument = i # meta event elif event["event"] == 15: # Track name if event["meta_event"] == 3: t.name = event["data"] # Marker elif event["meta_event"] == 6: pass # Cue Point elif event["meta_event"] == 7: pass # End of Track elif event["meta_event"] == 47: pass # Set tempo #warning Only the last change in bpm will get saved currently elif event["meta_event"] == 81: mpqn = self.bytes_to_int(event["data"]) bpm = 60000000 / mpqn # Time Signature elif event["meta_event"] == 88: 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) # Key Signature elif event["meta_event"] == 89: pass else: print "Unsupported META event", event["meta_event"] else: print "Unsupported MIDI event", event t + b c.tracks.append(t) return c, bpm
""" Three canti firmi from the "Composition in Simple Counterpoint" on p128 of the Sophomore Music manual. To be used in counterpoint stuff. """ from mingus.containers import Track first = Track() for note in ('D', 'A', 'Bb', 'A', 'G', 'D', 'F', 'E', 'D'): first.add_notes(note, 1) # current_beat attribute is currently 0.0 for all of these notes - do they play simultaneously? second = Track() for note in ('E-4', 'A-3', 'A-4', 'G-4', 'F-4', 'E-4', 'D-4', 'F-4', 'E-4'): second.add_notes(note, 1) third = Track() for note in ('C', 'G', 'A', 'B', 'C', 'D', 'E', 'D', 'C'): third.add_notes(note, 1) closer = Track() for note in ('D', 'D', 'E', 'F#', 'F#', 'F#', 'G', 'A', 'A', 'A', 'B', 'B', 'A', 'rest', 'rest', 'rest', 'A', 'A', 'G', 'F#', 'G', 'G', 'F#', 'E', 'D', 'D', 'E', 'C#', 'D', 'rest', 'rest', 'rest'): closer.add_notes(note, 1) # rests need to be placed separately in mingus?? maybe forking them is a good idea at this point print first print second
def compose(primary_pc_sets, rhythm_cycles, ensemble, meter, bpm, stability, repeat_chance, repeat_attempts, repeat_loops, repetitions, filename = 'output.mid'): """ Generates a post-tonal composition and resultant midi file using the given materials (function arguments) in conjunction with stochastic processes. Takes a list of PcSets, a list of Rythm_cycles, a list of Instruments, an integer tuple for meter (time signature), an integer for bpm (tempo), a floats for stability and repeat_chance, integers for repeat_loops and repetitions, and a string for output filename. """ for pc_set in primary_pc_sets: assert isinstance(pc_set, PcSet) for rhythm_cycle in rhythm_cycles: assert isinstance(rhythm_cycle, Rhythm_cycle) for instrument in ensemble: assert isinstance(instrument, Instrument) assert isinstance(meter, tuple) assert isinstance(bpm, int) assert isinstance(stability, int) or isinstance(stability, float) assert stability >= 0 and stability <= 100 assert isinstance(repeat_chance, int) or isinstance(repeat_chance, float) assert repeat_chance >= 0 and repeat_chance <= 100 assert isinstance(repeat_attempts, int) assert repeat_attempts in range(0, 101) assert isinstance(repeat_loops, int) assert repeat_loops in range(0, 101) assert isinstance(repetitions, int) assert repetitions in range(0, 101) assert isinstance(filename, str) # print parameters: print "\nBasic Parameters:\n" print "Meter: " + str(meter) print "BPM: " + str(bpm) print "Repeat chance:" + str(repeat_chance) print "Repeat attempts:" + str(repeat_attempts) print "Repeat loops:" + str(repeat_loops) print "Repetitions: " + str(repetitions) print "Output Destination: " + filename print "\nPrimary Pitch-Class Sets:" for index, item in enumerate(primary_pc_sets): interval_vector = item.ivec() common_tone_vector = ctvec(item) print "\n#" + str(index+1) + ":" print "Pitch-Class Set: " + str(item) print "Interval Vector: " + str(interval_vector) print "Common-Tone Vector: " + str(common_tone_vector) print "\nRhythm Cycles:" for index, rhythm in enumerate(rhythm_cycles): print "\n#" + str(index+1) + ":" rhythm_cycles[-1].display() # compose pc_set_progression sections: pc_set_progression = list() section_length = list() # section 1: for index in range(len(primary_pc_sets)): for primary_pc_set in primary_pc_sets[0:index+1]: spectrum = transposition_spectrum(primary_pc_set) contrast = index if contrast not in range(len(spectrum)): contrast = len(spectrum)-1 pc_set_progression.extend(neighbor_by_contrast(primary_pc_set, contrast)) section_length.append(len(pc_set_progression)) # section 2: for index, primary_pc_set in enumerate(primary_pc_sets[0:-1]): spectrum = transposition_spectrum(primary_pc_set) contrast = index if contrast not in range(len(spectrum)): contrast = len(spectrum)-1 pc_set_progression.extend(palindrome_successive_neighbor_by_contrast(primary_pc_set, contrast, len(primary_pc_sets[0:-1])-index)) section_length.append(len(pc_set_progression)) # section 3: primary_pc_set = primary_pc_sets[-1] spectrum = transposition_spectrum(primary_pc_set) contrast = len(spectrum)-1 pc_set_progression.extend(cadential_progressive_successive_neighbor(primary_pc_set)) section_length.append(len(pc_set_progression)) # section 4: for index, primary_pc_set in enumerate(reversed(primary_pc_sets)): spectrum = transposition_spectrum(primary_pc_set) contrast = len(spectrum)-(1+index) if contrast not in range(len(spectrum)): contrast = 0 pc_set_progression.extend(neighbor_by_contrast(primary_pc_set, contrast)) section_length.append(len(pc_set_progression)) print "\nSection lengths:" for item in section_length: print str(item) print "\nPitch-Class Set Progression:" for index, item in enumerate(pc_set_progression): print str(index) + ": " + str(item) # compose pc_sequence: pc_sequence = list() print "\nPitch-Class Sequence:" for pc_set in pc_set_progression: seq = Pc_sequence(pc_set, repeat_chance, repeat_attempts, repeat_loops) pc_sequence.append(seq) print str(pc_sequence[-1].sequence) instrument = ensemble[0] track = Track(instrument) track.name = instrument.name composition = Composition() #title = "my title" #composition.set_title(title) #print composition.title #author = "Pierrot" #composition.set_author(author) #print composition.author note = Note() track.add_bar(Bar()) track.bars[-1].set_meter(meter) count = 0 cur_rhythm_cycle = 0 cur_section = 0 first_note = False for index, item in enumerate(pc_sequence): orchestrator = Orchestrator(item, instrument, stability) while not orchestrator.completed(): # select rhythm cycle if index == len(pc_sequence)-1: cycle = rhythm_cycles[cur_rhythm_cycle] else: if count == 0: cycle = rhythm_cycles[cur_rhythm_cycle] elif count % section_length[cur_section] == 0: cur_rhythm_cycle += 1 cur_section += 1 if cur_rhythm_cycle == len(rhythm_cycles): cur_rhythm_cycle = 0 if cur_section == len(section_length): cur_section = 0 cycle = rhythm_cycles[cur_rhythm_cycle] print "\ncount = " + str(count) print "rhythm cycle # " + str(cur_rhythm_cycle) print "section # " + str(cur_section) print "section length = " + str(section_length[cur_section]) unit = cycle.get_next_unit() print "cycle position = " + str(cycle.get_index()) print "unit value = " + str(unit.get_value()) if track.bars[-1].is_full(): track.add_bar(Bar()) track.bars[-1].set_meter(meter) if unit.is_rest(): print "unit is rest" if not track.bars[-1].place_rest(unit.get_value()): print "not enough room in bar" if track.bars[-1].space_left() == 0: print "adding new bar" track.add_bar(Bar()) track.bars[-1].set_meter(meter) value_left = track.bars[-1].value_left() if track.bars[-1].space_left >= 1.0/unit.get_value(): print "placing rest" track.bars[-1].place_rest(unit.get_value()) else: difference = subtract(unit.get_value(), value_left) while difference != 0: print "spliting rest across bars" track.bars[-1].place_rest(value_left) track.add_bar(Bar()) track.bars[-1].set_meter(meter) if space_left >= 1.0/difference: track.bars[-1].place_rest(difference) break else: print "unit is note" note = orchestrator.next() if not first_note: first_note = note print str(next) if not track.bars[-1].place_notes(note, unit.get_value()): print "not enough room in bar" if track.bars[-1].space_left() != 0: value_left = track.bars[-1].value_left() print "value left = " + str(value_left) cur_beat = track.bars[-1].current_beat print "filling in remaining space" track.bars[-1].place_notes(note, value_left) value_needed = subtract(unit.get_value(), value_left) print "adding bars to fit full value" track.add_bar(Bar()) track.bars[-1].set_meter(meter) value_bar = track.bars[-1].value_left() bars_added = 1 while 1.0/value_needed > 1.0/value_bar: print "adding bar" track.add_bar(Bar()) track.bars[-1].set_meter(meter) value_needed = subtract(value_needed, value_bar) bars_added+=1 if not track.bars[-bars_added].place_notes_at(cur_beat, unit.get_value()): print "could not fit value" count+=1 note = first_note composition.add_track(track) write_Composition(filename, composition, bpm, repetitions) print "\n" print repr(composition) print "\nCompleted." print "\nOutput saved as: " + filename + "\n" return
from mingus.core import chords, intervals, notes, scales from mingus.containers import Note, NoteContainer, Bar, Track, Composition from mingus.containers.Instrument import MidiInstrument from mingus.midi import MidiFileOut from improv import generate_solo from subprocess import call num_progressions = 4 chords_list = ['CM', 'G7', 'CM7', 'FM7', 'G7', 'Am7', 'G7', 'C#+'] chords_bars = [] for chord in chords_list: chord_nc = NoteContainer(chords.from_shorthand(chord)) bar = Bar() bar.place_notes(chord_nc, 1) chords_bars.append(bar) solo_track = Track() chords_track = Track() for _ in range(num_progressions): for bar in generate_solo(chords_list): solo_track.add_bar(bar) for bar in chords_bars: chords_track.add_bar(bar) guitar = MidiInstrument() guitar.instrument_nr = 26 solo_track.instrument = guitar piano = MidiInstrument() piano.instrument_nr = 0 chords_track.instrument = piano
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: # this loop will gather data for all notes, # set up keys and time signatures for all bars # and set the tempo and instrument for the track. metronome = 1 # Tick once every quarter note thirtyseconds = 8 # 8 thirtyseconds in a quarter note step = 256.0 # WARNING: Assumes our smallest desired quantization step is a 256th note. meter = (4, 4) key = 'C' bar = 0 beat = 0 now = (bar, beat) b = None started_notes = {} finished_notes = {} b = Bar(key=key, meter=meter) bars = [b] bpm = None instrument = None track_name = None for deltatime, event in track: if deltatime != 0: duration = (ticks_per_beat * 4.0) / float(deltatime) dur_q = int(round(step/duration)) length_q = int(b.length * step) o_bar = bar c_beat = beat + dur_q bar += int(c_beat / length_q) beat = c_beat % length_q while o_bar < bar: o_bar += 1 o_key = b.key b = Bar(key=key, meter=meter) b.key = o_key bars.append(b) now = (bar, beat) if event['event'] == 8: # note off channel = event['channel'] note_int = event['param1'] velocity = event['param2'] note_name = notes.int_to_note(note_int % 12) octave = note_int / 12 - 1 note = Note(note_name, octave) note.channel = channel note.velocity = velocity x = (channel, note_int) start_time = started_notes[x] del started_notes[x] end_time = now y = (start_time, end_time) if y not in finished_notes: finished_notes[y] = [] finished_notes[y].append(note) elif event['event'] == 9: # note on channel = event['channel'] note_int = event['param1'] velocity = event['param2'] x = (channel, note_int) # add the note to the current NoteContainer started_notes[x] = now elif event['event'] == 10: # note aftertouch pass elif event['event'] == 11: # controller select pass elif event['event'] == 12: # program change # WARNING: only the last change in instrument will get saved. i = MidiInstrument() i.instrument_nr = event['param1'] instrument = i elif event['event'] == 0x0f: # meta event Text if event['meta_event'] == 1: pass elif event['meta_event'] == 3: # Track name track_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 mpqn = self.bytes_to_int(event['data']) bpm_o = bpm 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 = Track(instrument) t.name = track_name sorted_notes = {} # sort the notes (so they are added to the bars in order) # this loop will also split up notes that span more than one bar. for x in finished_notes: (start_bar, start_beat), (end_bar, end_beat) = x if end_beat == 0: end_bar -= 1 end_beat = int(bars[end_bar].length * step) while start_bar <= end_bar: nc = NoteContainer(finished_notes[x]) b = bars[start_bar] if start_bar < end_bar: # only executes when note spans more than one bar. length_q = int(b.length * step) dur = int(step/(length_q - start_beat)) else: # always executes - add the final section of this note. dur = int(step/(end_beat-start_beat)) if start_beat != 0: at = float(start_beat)/step else: at = 0.0 if start_bar not in sorted_notes: sorted_notes[start_bar] = {} if at not in sorted_notes[start_bar]: sorted_notes[start_bar][at] = (dur, nc) # set our offsets for the next loop start_beat = 0 start_bar += 1 # add all notes to all bars in order. for start_bar in sorted(sorted_notes.keys()): for at in sorted(sorted_notes[start_bar].keys()): dur, nc = sorted_notes[start_bar][at] bars[start_bar].place_notes_at(nc, dur, at) # add the bars to the track, in order for b in bars: b.fill_with_rests() t + b # add the track to the composition c.tracks.append(t) return (c, bpm)
You should specify the SF2 soundfont file. """ from mingus.core import progressions, intervals from mingus.core import chords as ch from mingus.containers import NoteContainer, Note, Track from mingus.midi.MidiFileOut import write_Track import time, sys from random import random def strip_chords(l): # une fonction pour ne garder que la fondamentale # d'un accord, sinon mingus nous le joue en arpeggié ret = [] for e in l: ret.append(e[0]) return ret progression = ["I", "vi", "iv", "V7"] key = 'C' chords = progressions.to_chords(progression, key) notes = strip_chords(chords) tr = Track() for note in notes: tr.add_notes(note, duration=1) write_Track('out.mid', tr)
class BassInstrument(Instrument): name = '' range = (Note('C', 0), Note('C', 10)) clef = 'Bass' def __init__(self, name): self.name = name Instrument.__init__(self) comp = Composition() comp.set_title('The Mingus') comp.set_author('Ben') ins = TrebleInstrument('kazoo') track = Track(ins) track.name = 'WWW' #instead of 'untitled' comp.add_track(track) firstbar = Bar(meter=(3,4)) track.add_bar(firstbar) print track.add_notes(['C-5'], 4.0) print track.add_notes(['E-5'], 2.0) print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4','F-4'], 8.0) print track.add_notes([], 8.0) #treated as rest? print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4'], 24.0)
c.augment() #升半音 c.diminish() #降半音 c.remove_redundant_accidentals() #清理多余升降号(只能成对清理,烂) #谱容器 from mingus.containers import NoteContainer #创建谱容器对象(继承列表,完全可以按列表操作,不用看下面的) n = NoteContainer(['A-3', 'C-5', 'B-4']) n.add_note('F-1') # 0位加音 n.remove_note('B', 4) #删音 n.empty() #清空 #乐器音色 from mingus.containers.instrument import Instrument, Piano, Guitar #创建乐器对象 i = Instrument() i.range #乐器音域 i.set_range((Note('C-2'), Note('E-4'))) #设定音域 i.note_in_range('F-4') #判断音是否在乐器音域内 #音轨 from mingus.containers import Track t = Track(i) #乐器放入音轨容器 #MIDI音乐播放(安装困难) #from mingus.midi import fluidsynth #fluidsynth.init("soundfont.SF2") #fluidsynth.play_Note( Note('C-5') ) from mingus.midi import MidiFileOut MidiFileOut.write_NoteContainer('test.mid', n)
import time PATH_SOUNDFONT = "./TimGM6mb.sf2" from mingus.midi import fluidsynth fluidsynth.init(PATH_SOUNDFONT, "pulseaudio") time.sleep(1) from mingus.containers import Note, Track #fluidsynth.play_Note(Note("C-5")) track = Track() track.add_notes(["A-5", "D-5"], 2) track.add_notes(["B-5", "E-5"], 2) fluidsynth.play_Track(track) time.sleep(5)