def main(): # REPLACE WITH RELEVANT PATHS path_to_midi = '../../../Xylo/midis/' path_to_log = '../../../Xylo/logs/' # F-3 to F-6 would be 37 keys. are we getting rid of 'F-3' or 'F-6'? low = Note('F-3') high = Note('F-6') xylo = create_instrument(low, high) infile = get_name('in') c, bpm = MIDI_to_Composition(path_to_midi + infile) write_log(c, bpm, path_to_log + infile) # query user to select tracks we actually want from the midi c.selected_tracks = select_tracks(c, bpm, xylo) # INSPECT LOG TO SEE WHICH TRACK NUMBERS YOU WANT INCLUDED AND # PUT THEM INTO THE BELOW LIST # c.selected_tracks = [1] # for mhall, only the track at index 1 is to be included # ratio of highest note value to keep in composition to beat unit. # e.g. if meter is 4/4, then a 'cutoff' of 2 would eliminate any # notes whose value exceeds 8 (anything briefer than an eighth note) cutoff = [8] * len(c.selected_tracks) # composition containing only the selected tracks, the correct notes, # with everything transposed w/in the range of the instrument c = rebuild_composition(c, xylo, cutoff) # seconds it takes for motor to step the necessary amount to drop # a ball step_time = 0.1 # multiply BPM by the ratio of smallest gap between # a note played consecutively and step_time -- only if this number # is less than 1 # bpm *= slow_down_composition(c, bpm, step_time) # print(bpm) play_comp_to_user(c, bpm) # check that everything sounds ok with selected tracks, removed notes, # and transposition outfile = get_name('out', infile) write_Composition(path_to_midi + outfile, c, bpm) # TODO: replace with actual ordering once known. ordering by # distance from device center lsa_ordering = ['F-3', 'F#-3', 'G-3', 'G#-3', 'A-3', 'A#-3', 'B-3', 'C-4', 'C#-4', 'D-4', 'D#-4', 'E-4', 'F-4', 'F#-4', 'G-4', 'G#-4', 'A-4', 'A#-4', 'B-4', 'C-5', 'C#-5', 'D-5', 'D#-5', 'E-5', 'F-5', 'F#-5', 'G-5', 'G#-5', 'A-5', 'A#-5', 'B-5', 'C-6', 'C#-6', 'D-6', 'D#-6', 'E-6', 'F-6'] # don't need to pass xylo here -- range contained in c[0] pb = create_playback_events(c, bpm, xylo, lsa_ordering) send_to_Arduino(pb) write_log(c, bpm, path_to_log + outfile, pb)
def to_midi(self, fp=''): if len(fp)>0: outf = r'C:\Users\Sam\Documents\Sidewinder\local files\\'+f'{fp}.mid' else: outf = r'C:\Users\Sam\Documents\Sidewinder\local files\midi_out.mid' if type(self.source) == Composition: midi_file_out.write_Composition(outf, self.source, repeat=0, verbose=True) elif type(self.passage) == Track: midi_file_out.write_Track(outf, self.passage, repeat=0, verbose=True)
async def run(self): while await self.receive(): # flush messages pass c = Composition() c.set_author("amg") c.set_title(CFG.OUTPUT_PREFIX + self.agent.name) c.add_track(self.agent.get("melody_track")) c.add_track(self.agent.get("accompaniment_track")) # fluidsynth.init("4U-Yamaha C5 Grand-v1.5.sf2", "alsa") # fluidsynth.play_Composition(c) midi_file_out.write_Composition( CFG.OUTPUT_FOLDER + CFG.OUTPUT_PREFIX + self.agent.name + ".mid", c, CFG.SONG_TEMPO) l = lilypond.from_Composition(c) extra = " \\score { \\new PianoStaff << \\set PianoStaff.instrumentName = #\"Piano \" \\new Staff = \"upper\" \\upper \\new Staff = \"lower\" \\lower >> \\layout { } }" l2 = l.replace("{ {", "upper = {x {x", 1).replace( "{ {", "lower = { {", 1).replace("{x {x", "{ {", 1) + extra # print("<lilipond-"+CFG.OUTPUT_FOLDER+CFG.OUTPUT_PREFIX+self.agent.name+">\n"+l2) lilypond.to_pdf( l2, CFG.OUTPUT_FOLDER + CFG.OUTPUT_PREFIX + self.agent.name) self.agent.presence.set_presence( state=PresenceState(available=True, show=PresenceShow.AWAY)) self.set_next_state(S_FINISHED)
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)
random.choice(possible_fills) for num in range(0, BAR_NUMBER): b = Bar() for i2 in range(0, 8): n = NoteContainer() n.add_notes(notes[num * 8 + i2]) b.place_notes(n, 8) drumtrack.add_bar(b) b = Bar() b.place_notes([cc, bd], 4) drumtrack.add_bar(b) song.add_track(drumtrack) midi_file_out.write_Composition("song.mid", song, bpm=random.randint(8, 14) * 10) print "Wrote to file..." output = False MUSESCORE_PATH = 'D:\\Program Files (x86)\\MuseScore 2\\bin\\MuseScore.exe' # Bad environment detection if os.path.isfile(MUSESCORE_PATH) and output: subprocess.Popen("taskkill /F /IM WWAHost.exe").communicate() # Kill music app, wait until done subprocess.Popen("taskkill /F /IM MuseScore.exe").communicate() # Kill musescore call = '"' + MUSESCORE_PATH + '" ' + '-o "song.mp3" song.mid' # Convert midi to mp3 using musescore subprocess.Popen(call).communicate() print "Outputted mp3... opening." os.startfile('song.mp3') # open both files os.startfile('song.mid')
leadBar.place_notes(n, lastNoteLength) else: # add a rest leadBar.place_rest(choice(noteLengths)) lead.append(leadBar) for note in container: note = note.octave_down() noteLengths = [1] bar = Bar(key, meter) bar.place_notes(container, choice(noteLengths)) comp.append(bar) track = Track() for bar in comp: track.add_bar(bar) leadTrack = Track() for bar in lead: leadTrack.add_bar(bar) composition = Composition() composition.add_track(track) # composition.add_track(leadTrack) MidiFile.write_Composition("musgen.mid", composition) MidiFile.write_Track("musgenLead.mid", leadTrack)
def parse_varbyte_as_int(self, fp, return_bytes_read=True): """Read a variable length byte from the file and return the corresponding integer.""" result = 0 bytes_read = 0 r = 0x80 while r & 0x80: try: r = self.bytes_to_int(fp.read(1)) self.bytes_read += 1 except: raise IOError("Couldn't read variable length byte from file.") if r & 0x80: result = (result << 7) + (r & 0x7F) else: result = (result << 7) + r bytes_read += 1 if not return_bytes_read: return result else: return (result, bytes_read) if __name__ == "__main__": from sys import argv from mingus.midi import fluidsynth, midi_file_out fluidsynth.init(argv[2]) (m, bpm) = MIDI_to_Composition(argv[1]) midi_file_out.write_Composition("test.mid", m, bpm)
def generate_fugue(key, subject): #If subject doesn't fill full bars fill out rest of last bar of subject with rest #if last bar is not full if not (subject[-1].is_full()): #place a rest at the end of the last bar with the length of 1/(remaining fraction of bar) subject[-1].place_rest(int(1.0 / subject[-1].space_left())) # Create first bar with subject in first voice and rest in second voice. rest_1bar = Bar(key) rest_1bar.place_rest(1) first_voice = copy.deepcopy(subject) #Add same amount of "rest bars" as the number of bars in the subject for i in range(len(subject)): second_voice.add_bar(copy.deepcopy(rest_1bar)) # Create second bar with answer in second voice. answer = Track_Functions.create_answer(subject, key) #second_voice = second_voice + answer Track_Functions.add_tracks(second_voice, answer) # Generate countersubject eg_counter = EvolutionaryGenerator(key, nr_bars=1, fitness_function='counter', input_melody=subject, nr_generations=counter_nr_generations) print('Generating evolutionary part 1 of 7') eg_counter.run_evolution() counter_subject = copy.deepcopy(eg_counter.best_individual) Track_Functions.add_tracks(first_voice, counter_subject) # Save bar 2 for later modulation bar_2 = first_voice[-1] # Generate development in minor in bar 5 and 6. # Transposed -3 to minor + (stämma i för second voice tills vidare tom) minor_first_voice = Track_Functions.transpose_to_relative_minor( first_voice, key, False) minor_second_voice = Track_Functions.transpose_to_relative_minor( second_voice, key, False) bar_5 = minor_first_voice[0] # Generate harmony in second voice in bar 5 eg_harmony_minor = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy(minor_first_voice[0])), nr_generations=harmony_nr_generations) print('Generating evolutionary part 2 of 7') eg_harmony_minor.run_evolution() minor_second_voice[0] = eg_harmony_minor.best_individual[0] # Generate bar 3 and 4 as a modulation between bar 2 and 5 eg_modulate_to_minor = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_2, to_bar=bar_5, nr_generations=modulate_nr_generations) print('Generating evolutionary part 3 of 7') eg_modulate_to_minor.run_evolution() modulate_first_voice = copy.deepcopy(eg_modulate_to_minor.best_individual) # Generate second voice as harmony to the first voice in bar 3 and 4 eg_second_voice_modulate = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print('Generating evolutionary part 4 of 7') eg_second_voice_modulate.run_evolution() modulate_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add bar 3-6 to the voice tracks Track_Functions.add_tracks(first_voice, modulate_first_voice) Track_Functions.add_tracks(second_voice, modulate_second_voice) Track_Functions.add_tracks(first_voice, minor_first_voice) Track_Functions.add_tracks(second_voice, minor_second_voice) bar_6 = first_voice[-1] # Create canon in bar 9 and 10. # subject i first voice # second voice is subject but shifted (half a bar for now) canon_first_voice = Track() canon_first_voice.add_bar(copy.deepcopy(subject[0])) bar_9 = canon_first_voice[0] canon_second_voice = Track_Functions.shift(subject, 2) # Create modulation from minor to major in 7 and 8 eg_modulate_to_major = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_6, to_bar=bar_9, nr_generations=modulate_nr_generations) print('Generating evolutionary part 5 of 7') eg_modulate_to_major.run_evolution() modulate_back_first_voice = copy.deepcopy( eg_modulate_to_major.best_individual) # Generate second voice as harmony to the first voice in bar 7 and 8 eg_second_voice_modulate_back = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print('Generating evolutionary part 6 of 7') eg_second_voice_modulate_back.run_evolution() modulate_back_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add bar 7-10 to the voice tracks Track_Functions.add_tracks(first_voice, modulate_back_first_voice) Track_Functions.add_tracks(second_voice, modulate_back_second_voice) Track_Functions.add_tracks(first_voice, canon_first_voice) Track_Functions.add_tracks(second_voice, canon_second_voice) # Add cadence ending to second voice Track_Functions.second_voice_ending(second_voice, key) second_voice_ending = Track().add_bar(copy.deepcopy(second_voice[-3])) second_voice_ending.add_bar(copy.deepcopy(second_voice[-2])) # Generate harmony to cadence in first voice first_voice_last_bar = Track_Functions.first_voice_ending(first_voice, key) eg_first_voice_ending = EvolutionaryGenerator( key, nr_bars=2, fitness_function='ending', input_melody=second_voice_ending, from_bar=subject[0], to_bar=first_voice_last_bar[0], nr_generations=harmony_nr_generations) print('Generating evolutionary part 7 of 7') eg_first_voice_ending.run_evolution() first_voice_ending = copy.deepcopy(eg_first_voice_ending.best_individual) Track_Functions.add_tracks(first_voice, first_voice_ending) Track_Functions.add_tracks(first_voice, first_voice_last_bar) #Add voices together to create a final composition fugue.add_track(first_voice) fugue.add_track(second_voice) #Generate lilypond file for fugue named final_fugue finished_fugue = LilyPond.from_Composition(fugue) to_LilyPond_file(finished_fugue, "final_fugue") #Generate MIDI output for fugue named final_fugue midi_file_out.write_Composition("final_fugue.mid", fugue)
def generate_longer_fugue(key, subject, nr_parts=1, order_of_parts=None): #If subject doesn't fill full bars fill out rest of last bar of subject with rest #if last bar is not full if not (subject[-1].is_full()): #place a rest at the end of the last bar with the length of 1/(remaining fraction of bar) subject[-1].place_rest(int(1.0 / subject[-1].space_left())) # Create first bar with subject in first voice and rest in second voice. rest_1bar = Bar(key) rest_1bar.place_rest(1) first_voice = copy.deepcopy(subject) #Add same amount of "rest bars" as the number of bars in the subject for i in range(len(subject)): second_voice.add_bar(copy.deepcopy(rest_1bar)) total_nr_evolutionary_parts = 3 + 3 * nr_parts # Create second bar with answer in second voice. answer = Track_Functions.create_answer(subject, key) Track_Functions.add_tracks(second_voice, answer) # Generate countersubject nr_current_generated = 1 eg_counter = EvolutionaryGenerator(key, nr_bars=1, fitness_function='counter', input_melody=subject, nr_generations=counter_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_counter.run_evolution() counter_subject = copy.deepcopy(eg_counter.best_individual) Track_Functions.add_tracks(first_voice, counter_subject) # Save subject, answer and countersubject first_voice_first_part = copy.deepcopy(first_voice) second_voice_first_part = copy.deepcopy(second_voice) # Save bar 2 for later modulation bar_prev = first_voice[-1] variants = ['Minor', 'Reverse', 'Inverse'] iParts = 0 if order_of_parts is None: order_of_parts = [] for i in range(nr_parts): rVariant = rnd.choice(variants) order_of_parts.append(rVariant) while iParts < nr_parts: current_variant = order_of_parts[iParts] if current_variant == 'Minor': # Generate development in minor # Transposed -3 to minor (stämma i second voice tills vidare tom) new_first_voice = Track_Functions.transpose_to_relative_minor( first_voice, key, False) new_second_voice = Track_Functions.transpose_to_relative_minor( second_voice, key, False) bar_after = new_first_voice[0] # Generate harmony in second voice first bar eg_harmony = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy( new_first_voice[0])), nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_harmony.run_evolution() new_second_voice[0] = eg_harmony.best_individual[0] elif current_variant == 'Reverse': # Generate reverse development new_first_voice = Track_Functions.reverse(first_voice_first_part, key) new_second_voice = Track_Functions.reverse(second_voice_first_part, key) bar_after = new_first_voice[0] # Generate harmony in second voice first bar eg_harmony = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy( new_first_voice[1])), nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_harmony.run_evolution() new_second_voice[1] = eg_harmony.best_individual[0] elif current_variant == 'Inverse': # Generate inverse development new_first_voice = Track_Functions.inverse(first_voice_first_part) new_second_voice = Track_Functions.inverse(second_voice_first_part) bar_after = new_first_voice[0] # Generate harmony in second voice first bar eg_harmony = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy( new_first_voice[0])), nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_harmony.run_evolution() new_second_voice[0] = eg_harmony.best_individual[0] # Generate the two bars linking this new part to the previous parts eg_modulate = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_prev, to_bar=bar_after, nr_generations=modulate_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_modulate.run_evolution() modulate_first_voice = copy.deepcopy(eg_modulate.best_individual) # Generate second voice as harmony to this linking part eg_second_voice_modulate = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_second_voice_modulate.run_evolution() modulate_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add new bars to the voice tracks Track_Functions.add_tracks(first_voice, modulate_first_voice) Track_Functions.add_tracks(second_voice, modulate_second_voice) Track_Functions.add_tracks(first_voice, new_first_voice) Track_Functions.add_tracks(second_voice, new_second_voice) bar_prev = first_voice[-1] iParts += 1 # Create canon in bar 9 and 10. # subject i first voice # second voice is subject but shifted (half a bar for now) canon_first_voice = Track() canon_first_voice.add_bar(copy.deepcopy(subject[0])) bar_after = canon_first_voice[0] canon_second_voice = Track_Functions.shift(subject, 2) # Create modulation from minor to major in 7 and 8 eg_modulate_to_major = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_prev, to_bar=bar_after, nr_generations=modulate_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_modulate_to_major.run_evolution() modulate_back_first_voice = copy.deepcopy( eg_modulate_to_major.best_individual) # Generate second voice as harmony to the first voice in bar 7 and 8 eg_second_voice_modulate_back = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_second_voice_modulate_back.run_evolution() modulate_back_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add bar 7-10 to the voice tracks Track_Functions.add_tracks(first_voice, modulate_back_first_voice) Track_Functions.add_tracks(second_voice, modulate_back_second_voice) Track_Functions.add_tracks(first_voice, canon_first_voice) Track_Functions.add_tracks(second_voice, canon_second_voice) # Add cadence ending to second voice Track_Functions.second_voice_ending(second_voice, key) second_voice_ending = Track().add_bar(copy.deepcopy(second_voice[-3])) second_voice_ending.add_bar(copy.deepcopy(second_voice[-2])) # Generate harmony to cadence in first voice first_voice_last_bar = Track_Functions.first_voice_ending(first_voice, key) eg_first_voice_ending = EvolutionaryGenerator( key, nr_bars=2, fitness_function='ending', input_melody=second_voice_ending, from_bar=subject[0], to_bar=first_voice_last_bar[0], nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) eg_first_voice_ending.run_evolution() first_voice_ending = copy.deepcopy(eg_first_voice_ending.best_individual) Track_Functions.add_tracks(first_voice, first_voice_ending) Track_Functions.add_tracks(first_voice, first_voice_last_bar) #Add voices together to create a final composition fugue.add_track(first_voice) fugue.add_track(second_voice) #Generate lilypond file for fugue named final_fugue (removed for submission) finished_fugue = LilyPond.from_Composition(fugue) to_LilyPond_file(finished_fugue, "final_fugue") #Generate MIDI output for fugue named final_fugue midi_file_out.write_Composition("final_fugue.mid", fugue) return
def write_midi(self, outfile): midi_file_out.write_Composition(outfile, self.composition, bpm=self.tempo)
def main(): repo = Repo(sys.argv[1]) factory = cf.ConverterFactory() converter = factory.get_converter("mod") curtime = datetime.datetime.now() if (len(sys.argv) == 3): target_file = sys.argv[2] else: target_file = "gitmelody" + str(curtime.year) + str(curtime.month) + str(curtime.hour) \ + str(curtime.minute) + str(curtime.second) + ".mid" commits = list(repo.iter_commits('master')) timesignature = converter.getTimeSignature(commits) tsValue = timesignature[0] / timesignature[1] print(tsValue) print(timesignature) #nc = NoteContainer() bar = Bar() if timesignature != None: bar.set_meter((timesignature[0], timesignature[1])) t = Track() t2 = Track() dursum = 0 tsValue = 1 c = Composition() #durations are between 1 and 128 for item in commits: #note_item = get_note_from_commit(item.stats.total) note_item = converter.getNoteFromCommit(item.stats.total) if (dursum + (1 / note_item[1]) <= tsValue): dursum = dursum + 1 / note_item[1] bar.place_notes(note_item[0], note_item[1]) else: dursum = 0 if (bar.space_left() > 0): booleanValue = bool(random.getrandbits(1)) if booleanValue == True: bar.place_notes(note_item[0], bar.space_left()) else: bar.place_rest(bar.space_left()) t.add_bar(bar) second_line = converter.getChordOrArpeggio(bar) t2.add_bar(second_line) bar = Bar() bar.set_meter((timesignature[0], timesignature[1])) c.add_track(t) c.add_track(t2) print(bar.meter) #bar.place_notes(note_item[0], note_item[1]) #t.add_notes(note_item[0]) #print(item.stats.total['insertions']) #print(item.stats.additions) #print(item.stats.deletions) #print(item.stats.total)a #nc = NoteContainer(["A", "C", "E"]) #midi_file_out.write_Track(target_file, t) midi_file_out.write_Composition(target_file, c)
def generate_midi(instrument, key, chord_progression, pad, octave=None, applause=False): composition = Composition() how_many_bars = 16 # Make all these configurable # Or make them all random from a range track = Track(instrument, channel=1) drone_track = track_creator(pad, channel=2) # drone_track = track_creator("Pad4 (choir)", channel=2) # It's one of the few pitched drums timpani_track = track_creator("Timpani", channel=3) applause_track = track_creator("Applause", channel=4) bar = Bar(key, (4, 4)) nc = NoteContainer("C", octave=2) bar.place_notes(nc, 1) applause_track.add_bar(bar) for _ in range(how_many_bars): # Can we get an index # We can with enumerate, but why do we want it for chord in chord_progression: # The Chord Progression bar = Bar(key, (4, 4)) if not octave: octave = INSTRUMENT_OCTAVE.get(instrument.name, 4) for length in random.sample(CHORD_RHYTHMS, 1)[0]: some_notes = random.sample(chord, random.randint(1, len(chord))) nc = NoteContainer(some_notes, octave=int(octave)) bar.place_notes(nc, length) track.add_bar(bar) drone_bar = Bar(key, (4, 4)) nc = NoteContainer(chord[0], octave=2) drone_bar.place_notes(nc, 1) drone_track.add_bar(drone_bar) timpani_bar = Bar(key, (4, 4)) nc = NoteContainer(key, octave=2) for length in [4, 4, 4, 4]: timpani_bar.place_notes(nc, length) timpani_track.add_bar(timpani_bar) composition.add_track(timpani_track, channel=5) composition.add_track(drone_track) composition.add_track(track) # Do we want to add the channel when adding or creating the track? if applause: composition.add_track(applause_track) instrument_name = MidiInstrument.names[instrument.instrument_nr] write_Composition(midi_file_name(instrument_name), composition, bpm=120)
def write_comp(c, bpm, filename): write_Composition(filename, c, bpm)
from mingus.containers import Note from mingus.containers import NoteContainer from mingus.containers import Bar from mingus.containers import Track from mingus.containers.instrument import Instrument, Piano, Guitar from mingus.containers import Composition from mingus.midi.midi_file_out import write_Composition eb = Note("Eb", 4) g = Note("G", 4) bb = Note("Bb", 4) n = NoteContainer([eb, g, bb]) c = Composition() c.set_author('Dusty Carver', '*****@*****.**') c.set_title('Late Nights') t = Track(Guitar()) b = Bar('Eb', (4, 4)) b.place_notes(n, 4) b.place_notes(n, 4) b.place_notes(n, 4) b.place_notes(None, 4) t.add_bar(b) c.add_track(t) write_Composition("one.mid", c)