def __init__(self, packetlistener): self._packetlistener = packetlistener self._packetanalyser = PacketAnalyser(self._packetlistener) fluidsynth.init("Bandpass.sf2", 'alsa') self._music_loop()
def fib_song(): fluidsynth.init('soundfonts/grand_piano.sf2') comp = Composition() comp.add_track(fib_seq()) comp.add_track(fib_seq(offset=4)) comp.add_track(fib_seq(offset=8)) fluidsynth.play_Composition(comp)
def main(): if not os.path.isfile('./data/probs.json'): print ('Creating json file...') fname = "./data/interval-5gram.csv" counts = get_counts(fname, 4) probs = get_probs(counts) with open('./data/probs.json', 'w') as outfile: json.dump(probs, outfile) with open('./data/probs.json', 'r') as infile: probs_dict = json.load(infile, encoding='utf-8') start_int = C4 melody = [] fluidsynth.init("/usr/share/sounds/sf2/FluidR3_GM.sf2", "alsa") streamer = stream_notes(probs_dict) for i in range(100): next_int = start_int + int(next(streamer)) next_note = Note() next_note.from_int(next_int) melody.append(next_note) start_int = next_int print(next_note) fluidsynth.play_Note(next_note) time.sleep(.2)
def play(self): fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2', 'alsa') fluidsynth.set_instrument(0, self.instrument) # Use channel 0 self.previous = int(SoundGen.kNoteNone) # Previously played note self.shift = random.randint(-10, 5) # Allow the key to be shifted beat_tracker = int(0) # 4/4 time. while self.should_stop == False: v = random.randint(65, 75) if beat_tracker % 8 == 0: # First beat, strong v = random.randint(85, 95) elif (beat_tracker - 4) % 8 == 0: # Third beat, semi-strong v = random.randint(75, 85) elif beat_tracker % 2 == 1: # Off-beat, very soft v = random.randint(55, 65) # Random note length possible_lengths = [ 4 ] + [2] * 10 + [1] * 4 # 4 is 2 beats, 2 is 1 beat, 1 is half-beat if beat_tracker % 2 == 1: # avoid non-half-beat if currently in half-beat possible_lengths += [1] * 20 # Add weight to half-beat length = random.choice(possible_lengths) beat_tracker += length if self.previous != SoundGen.kNoteNone: fluidsynth.stop_Note(self.previous + self.shift, 0) self.previous = SoundGen.__next_note__(self.previous) fluidsynth.play_Note(self.previous + self.shift, 0, v) time.sleep(length * self.OneBeatLength)
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_composition(pattern, progression_type, nb_bars, key="C", rythm=60): fluidsynth.init("198_u20_Electric_Grand.SF2") # permet d'initialiser l'instrument newComposition = Composition() progression_list = on_progression_type_change(progression_type, nb_bars) left_hand = generate_pattern(progression_list, key, pattern, nb_bars) newComposition.add_track(left_hand) MidiFileOut.write_Composition("myComposition.mid", newComposition, rythm, False)
def __init__(self, starting_note='C-3'): fluidsynth.init(path_to_instrument, audio_driver) self.starting_note = Note(starting_note) self.relative_major_scale = np.array([0, 2, 4, 5, 7, 9, 11]) self.scale = self.relative_major_scale + int(self.starting_note) self.note = Note(self.starting_note) self.bar = Bar() fluidsynth.play_Note(self.note)
def fluidsynth_init(): ''' fluidsynth_init - initializes fluidsynth to the soundfont file and sets the instrument for each channel according to the list in constants.py ''' fluidsynth.init(general_soundfont, "alsa") for i in instruments: fluidsynth.set_instrument(i[0], i[1], i[2])
def __init__(self, master): frame = Frame(master) frame.pack() fluidsynth.init("ChoriumRevA.SF2") roman_num = [0,2,4,5,7,9,11] self.progression = [] self.buttons = {} self.prog_var = StringVar() self.display = Label( master, textvariable = self.prog_var).pack() self.uniprog_var = StringVar() self.unidisplay = Label( master, textvariable = self.uniprog_var).pack() self.sug_var = StringVar() self.sug_label = Label( master, textvariable = self.sug_var).pack() #### Chord Buttons #### self.key_btn = Listbox(frame) self.key_btn.bind("<<ListboxSelect>>", self.display_progression) self.key_btn.pack(side=BOTTOM) for k in number.keys(): self.key_btn.insert(END, k) for ch in roman_num: btn = Button(frame, text=roman[ch], command=partial( self.print_ch, ch ) ) btn.pack(side=LEFT) self.buttons[ ch ] = btn #### other buttons #### self.pop = Button(frame, text='Del', command=self.pop_ch) self.pop.pack(side=BOTTOM) self.play = Button(frame, text='Play', command=self.play_prog) self.play.pack(side=TOP) self.sugg = Button(frame, text='?', command=self.suggest) self.sugg.pack(side=BOTTOM) self.save_btn = Button(frame, text='Save', command=self.save_midi) self.save_btn.pack(side=TOP) #### Checkbox buttons for intervals #### self.add7_var = BooleanVar() self.add7 = Checkbutton( master, text="+ 7", variable = self.add7_var ) self.add7.pack() self.maj_var = BooleanVar() self.maj = Checkbutton( master, text="Major", variable = self.maj_var ) self.maj.pack()
def erreproduzitu_marrazkia(screen): fluidsynth.init( '/home/galtzagorri/Mahaigaina/Arachno SoundFont - Version 1.0.sf2', "alsa") for i in range(0, len(zerrenda)): print zerrenda[i].posy nota = (zerrenda[i].posy) % 127 fluidsynth.play_Note(nota, 1, 100) time.sleep(0.5)
def Open(self): pygame.mixer.init() pygame.mixer.music.load("short_music.wav") pygame.mixer.music.play() self.last_detect_time = time.time() fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2', "alsa") fluidsynth.set_instrument(0, 6) fluidsynth.set_instrument(1, 4)
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)
def playNotes(notes, xscale=0.01): fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2', "alsa") currTime = 0 for n in notes: waitTime = n.startx * xscale - currTime currTime = n.startx * xscale fluidsynth.play_Note(pow(n.energy, 0.2), 0, 100) print("Played %s, Waiting for %s " % (n, waitTime)) time.sleep(waitTime) fluidsynth.stop_everything()
def playNotes(notes, xscale = 0.01): fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2',"alsa") currTime = 0 for n in notes: waitTime = n.startx * xscale - currTime currTime = n.startx * xscale fluidsynth.play_Note(pow(n.energy, 0.2), 0, 100) print("Played %s, Waiting for %s " % (n, waitTime)) time.sleep(waitTime) fluidsynth.stop_everything()
def play_pattern(pattern_index, key): pattern = patterns.PATTERNS[pattern_index] fluidsynth.init("198_u20_Electric_Grand.SF2") # permet d'initialiser l'instrument previews_note = None b = Bar(key, (4, 4)) position_note = 0 already_used=[] for pattern_note in pattern : if position_note not in already_used : is_chord = chord_length(pattern_note, pattern, position_note) if is_chord[2] : note_list = [] # c est un accord for p_note in pattern[is_chord[0]:is_chord[1]+1] : note_str = get_note_pattern(p_note, key) note = Note(note_str, p_note[5]) if previews_note is not None: if p_note[4]=='+': if int(note) < previews_note : note.octave_up() elif p_note[4]=='-': if int(note) > previews_note : note.octave_down() previews_note = int(note) note_list.append(note) for n in range(is_chord[0], is_chord[1]+1): already_used.append(n) b.place_notes(note_list, pattern_note[1]) else : note_str = get_note_pattern(pattern_note, key) note = Note(note_str, pattern_note[5]) if previews_note is not None: if pattern_note[4]=='+': if int(note) < previews_note : note.octave_up() elif pattern_note[4]=='-': if int(note) > previews_note : note.octave_down() previews_note = int(note) b.place_notes(note, pattern_note[1]) already_used.append(position_note) position_note+=1 fluidsynth.play_Bar(b, 1, 60)
def __init__(self): self.store = db() fluidsynth.init(MIDI_FILE, 'alsa') self.builder = gtk.Builder() self.builder.add_from_file('res/gui.glade') self.window = self.builder.get_object('window') self.new_evolution_dialog = self.builder.get_object('new_evolution_dialog') self.new_neural_network_dialog = self.builder.get_object('new_neural_network_dialog') self.open_evolution_dialog = self.builder.get_object('open_evolution_dialog') self.nn_list = gtk.ListStore(str) self.nn_combo = self.builder.get_object('nn_combo') self.nn_combo.set_model(self.nn_list) cell = gtk.CellRendererText() self.nn_combo.pack_start(cell, True) self.nn_combo.add_attribute(cell,'text', 0) self.update_nn_list() self.evolution_list = gtk.ListStore(str) self.evolution_combo = self.builder.get_object('evolution_combo') self.evolution_combo.set_model(self.evolution_list) cell = gtk.CellRendererText() self.evolution_combo.pack_start(cell, True) self.evolution_combo.add_attribute(cell, 'text', 0) self.update_evolution_list() self.genome_list = gtk.ListStore(int, str) self.genome_view = self.builder.get_object('genome_view') self.genome_view.set_model(self.genome_list) cell = gtk.CellRendererText() column = gtk.TreeViewColumn('Genome', cell, text=1) self.genome_view.append_column(column) self.controls = { 'initialize': self.builder.get_object('initialize_button'), 'evaluate': self.builder.get_object('evaluate_button'), 'select' : self.builder.get_object('apply_selection_button'), 'play' : self.builder.get_object('play_button') } self.console = gtk.TextBuffer() self.builder.get_object('console').set_buffer(self.console) # hide dialogs instead of destroying them for reuse self.hide_dialog = gtk.Widget.hide_on_delete self.builder.connect_signals(self)
def __init__(self, instrument=None): super(FlowTrack, self).__init__(instrument) if type(instrument) is Guitar: fluidsynth.init('soundfonts/acoustic_guitar.sf2') else: fluidsynth.init('soundfonts/grand_piano.sf2') self.rate = 100 self.chords = [] self.key = 'C' self.octave = 4
def main(): # Parse command-line user arguments and initializes settings fluidsynth.init(st.SOUNDFONT) # start FluidSynth # Change instrument # fluidsynth.set_instrument(1, 14) # Select game settings = SettingsContainer(game_menu()) # Play Game while 1: new_question_rn(settings)
def setUp(self): soundfont = os.getenv("SOUNDFONT") if soundfont is None: raise ValueError( "A soundfont (*.sf2) file path must be provided in the SOUNDFONT environment variable" ) self.tempdir = tempfile.mkdtemp() output_file = os.path.join(self.tempdir, "test.wav") fluidsynth.init(soundfont, file=output_file) fluidsynth.set_instrument(0, 0) s = SequencerObserver() fluidsynth.midi.attach(s)
def main(): comp = Composition() with open('out.txt', 'r') as f: lines = f.readlines() for line in lines: tb = TrackBuilder() symbols = line.rstrip().split(' ')[1:] print(symbols) for symbol in symbols: tb.add_symbol(symbol) track = tb.flush() comp.add_track(track) fluidsynth.init('../sfs/soundfont.sf2', 'alsa') fluidsynth.play_Composition(comp)
def play_midi(midi_path, save_path, beats, midi_vel, stop_all,midi_device_nr): from mingus.midi import fluidsynth from mingus.containers.note import Note curr_path = lib.os.path.dirname(lib.os.path.abspath(__file__)) fluidsynth.init("/Users/js/Desktop/sounds/Nice-Keys-PlusSteinway-JNv2.0.sf2") f = open(save_path + '/play_midi.csv', 'w+') # open file to save log values f.write('time,beats,midi_note,midi_vel\n') # write first line with corresponding titles mid = lib.mido.MidiFile(midi_path+'.mid') # save parsed MIDI file using mido library s_times = [] # np.zeros((times[0],2)) # create an empty array to storenote events in the MIDI file #port = lib.mido.open_output(lib.mido.get_output_names()[midi_device_nr.value]) # open port to send MIDI messages all_time = 0 # aggregate time for all the messages msg_count = 0 # this is to count MIDI messages with note information all_messages = [] # create an ampty array to only store note information and their position in the score for msg in mid: # for every message in the midi file all_time += msg.time # the file stores midi time based on previous onset, we h if hasattr(msg, 'note'): # checks that the MIDI message is Note #all_time += msg.time # all_messages.append(msg) # adds note message from MIDI file to our playback thing s_times.append([msg_count, all_time]) # array to store note score time msg_count += 1 # count of how many note messages there are in total s_times = lib.np.array(s_times) # convert array to numpy.array yo = lib.copy.deepcopy(s_times) # deepcopy the array so the original doesn't get manipulated while True: if len(yo) != 0: # keep running the loop until there are no more notes to play #print 'here' if yo[0, 1] < beats.value: # if the playhead is larger than the first note in the array play the first note and then delete msgMIDI = all_messages[int(yo[0, 0])] # add note information and it's timing to the midi message to be sent if midi_vel.value > 127: msgMIDI.velocity = 127 else: msgMIDI.velocity = midi_vel.value # add velocity to the MIDI message to be sent f.write( # store values for later analysis "%f, %f, %f, %f\n" % (lib.time.time(), beats.value, all_messages[int(yo[0, 0])].note, midi_vel.value)) msgMIDI.channel = 0 note = Note(all_messages[int(yo[0, 0])].note-12) print note note.velocity = msgMIDI.velocity if msgMIDI.type == 'note_on': fluidsynth.play_Note(note) if msgMIDI.type == 'note_off': fluidsynth.stop_Note(note) #port.send(msgMIDI) # send the message using predefined port (midi device) yo = lib.np.delete(yo, 0, 0) # once the note has been played delete the first message #print beats.value/2 else: # if there are no more notes to play f.close # stop storing the values in csv stop_all.value = True # flag to indicate to the rest of the system that the file has finished. print 'MIDI Playback Finished' # print for use rto acknowledge break
def build(self): fluidsynth.init(os.path.join(ROOT_DIR, 'sounds', 'FluidR3_GM.sf2')) self.midi_in = MidiInputDispatcher() midi_device = self.config.get('MIDI', 'Input device') if midi_device: self.midi_in.open_port(midi_device) self.setting_panel = Settings() party = PlayerParty() sm = TonePoemGame(OrderedDict([ ('area', AreaScreen(name='area')), ('encounter', EncounterScreen(name='encounter', party=party)) ]), app=self) return sm
def main(): # Initialize import settings as st # parses command-line user arguments and initializes settings fluidsynth.init(st.SOUNDFONT) # start FluidSynth # Change instrument # fluidsynth.set_instrument(1, 14) # Initialize Game from game_modes import game_modes st.CURRENT_MODE = game_modes[st.INITIAL_MODE] st.CURRENT_MODE.intro() while 1: st.CURRENT_MODE.new_question()
def main(): #take first channel of file Fs, data = wavfile.read(INPUT_FILE) y = data[:,0] #load piano soundfont SF2 = 'audio/FazioliGrandPiano.sf2' if not fluidsynth.init(SF2): print ("Couldn't load soundfont", SF2) #initialize variables for windowing sampSize = (Fs * WINDOW_LEN)/2 prevStart = 0 end = int(sampSize) totalSamp = int(len(y)/(sampSize*2) *2) #get the chords of the smoothed input for j in range(0,totalSamp): getFrequencies(smooth(y[prevStart:end]),Fs) prevStart += sampSize end += sampSize #play the chord back out again for idx,chord in enumerate(BAR): fluidsynth.play_NoteContainer(chord) time.sleep(PLAYBACK) time.sleep(PLAYBACK+0.3)
def __init__(self): # possible fluidsynth guys ##main_volume(channel, value) ##modulation(channel, value) ##pan(channel, value) if not fluidsynth.init( os.path.join(config.RESOURCEdirectory, config.SOUNDfont), config.FLUIDSYNTHdriver): sys.exit(" COULD NOT LOAD SOUNDFONT PianoMenu.sf2 ") # set instruments on each channel. fluidsynth.set_instrument( config.PIANOchannel, ## channel to set instrument on config.SOUNDfontPIANO) ## instrument. determined by sound font self.keysmod12 = [ "C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B" ] self.keyson = [0] * 12 # denotes all keys on in an octave self.newnotesonlist = [ ] # list of new [note,velocity] that player has hit self.newnotesofflist = [ ] # list of new note that player has taken fingers off of #self.noteson = set() # set of notes that the player currently has down # commented out since it was crashing things to remove notes sometimes... self.pitchwheel = 64 # current value of the pitch wheel self.modwheel = 0 # current value of the mod wheel self.transientnotes = [] pygame.midi.init()
def __init__(self, filename): fluidsynth.init(filename) note_names = ("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") coords = (15, 35, 52, 71, 88, 125, 144, 160, 180, 197, 216, 234, 270, 289, 307, 325, 343, 378, 398, 415, 434, 452, 470, 487) self.is_pressed = dict.fromkeys(note_names, [False] * len(note_names)) self.note_coordinate = dict(zip(note_names, coords)) self.note_names = note_names self.window_title = 'Keyboard' cv2.namedWindow(self.window_title) self.img = cv2.imread('./resources/keyboard.jpg', cv2.CV_LOAD_IMAGE_COLOR) cv2.imshow(self.window_title, self.img) self.turn_sound_on()
def __init__(self): self._notes = [] self._bar = None self._durs = [] self._index = 0 self._key = "" self._bpm = 120 self._dynamics = {} self.paused = False self._bar = Bar() fs.init("sound.sf2", "oss") mixer.init()
def __init__(self, soundfont_name=None): if soundfont_name is None: fluidsynth.init('../soundfonts/soundfont.sf2', 'alsa') else: fluidsynth.init(soundfont_name, 'alsa') self.m_chain = MarkovChain(get_all_progressions()) self.sim = self.m_chain.infinite_progression() down1 = (0.7, 0.05, 0.2) down2 = (0.2, 0.05, 0.7) off = (0.0, 0.4, 0.1) self.bassproba = [down1, off, down2, off, down1, off, down2, off] self.current = self.m_chain.START
def erreproduzitu_marrazkia2(screen): fluidsynth.init( '/home/galtzagorri/Mahaigaina/Arachno SoundFont - Version 1.0.sf2', "alsa") #fluidsynth.init('/home/galtzagorri/Mahaigaina/grand-piano-YDP-20160804.sf2',"alsa") for i in range(0, len(zerrenda)): print zerrenda[i].posy print zerrendaBase[i].posy nota = (zerrenda[i].posy) % 127 nota2 = (zerrendaBase[i].posy) % 126 t = threading.Thread(target=fluidsynth.play_Note(nota, 1, 100)) t2 = threading.Thread(target=fluidsynth.play_Note(nota2, 1, 100)) #t.start() #t2.start() #fluidsynth.play_Note(nota,1,100) #fluidsynth.play_Note(nota2,2,100) time.sleep(0.5)
def __init__(self, filename): fluidsynth.init(filename) note_names = ("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") coords = (15, 35, 52, 71, 88, 125, 144, 160, 180, 197, 216, 234, 270, 289, 307, 325, 343, 378, 398, 415, 434, 452, 470, 487) self.is_pressed = dict.fromkeys(note_names, [False] * len(note_names)) self.note_coordinate = dict(zip(note_names, coords)) self.note_names = note_names self.window_title = 'Keyboard' cv2.namedWindow(self.window_title) self.img = cv2.imread('./resources/keyboard.jpg', cv2.IMREAD_COLOR) cv2.imshow(self.window_title, self.img) self.turn_sound_on()
def loadSynth(): SF2 = '~/Depot/fluid-soundfont/FluidR3_GM2-2.SF2' if not fluidsynth.init(SF2, 'coreaudio'): print('Could not load soundfont', SF2) print( 'Install FluidSynth soundfont (FluidR3_GM2-2.SF2) into the directory ~/Depot/fluid-soundfont.' ) sys.exit(1)
def main(): if not fluidsynth.init(SF2): print "Couldn't load soundfont", SF2 sys.exit(1) notes = [] for fn in sys.argv[1:]: print fn read_notes(fn, notes) play_notes(notes)
def __init__(self, soundfont_file, soundfont_driver="alsa", valve_mapping=default_valve_mapping, freq_ranges=default_freq_ranges, note_mapping=default_note_mapping): """ Initialize Trumpet """ self.valve_mapping = valve_mapping # Valve to key map self.freq_ranges = freq_ranges # Freq range to harmonic series # Note mapping indexed as [freq range index][valve combo (index)] self.note_mapping = note_mapping # Initialize Fluidsynth self.soundfont_file = soundfont_file self.soundfont_driver = soundfont_driver fluidsynth.init(soundfont_file, soundfont_driver) # Keep track of the current note state self.current_note = "" self.prev_freq = 0
def generate_composition(pattern_index, progression_type, nb_bars, mode='none', key="C", rythm=60): fluidsynth.init("198_u20_Electric_Grand.SF2") # permet d'initialiser l'instrument newComposition = Composition() progression_list = on_progression_type_change(progression_type, nb_bars) # truc pour la main droite if nb_bars == 1 : phrase_list = choose_phrases(key, mode, nb_bars) right_hand = use_phrase(phrase_list, progression_list, nb_bars, pattern_index, mode='none', key="C") else : chorus = generate_chorus(progression_list, pattern_index, mode, key) #chorus retourne : une phrase de debut, une phrase de fin, 3 bars fixes phrase_list = choose_first_phrases(nb_bars, key, mode, chorus[1], chorus[2], pattern_index) right_hand = generate_long_right_hand(phrase_list, progression_list, nb_bars, pattern_index, mode, key, chorus) newComposition.add_track(right_hand) left_hand = generate_pattern(progression_list, key, pattern_index, nb_bars) newComposition.add_track(left_hand) MidiFileOut.write_Composition("myCompo.mid", newComposition, rythm, False) return newComposition
def playProgression(): progression = ["I", "vi", "ii", "iii7", "I7", "viidom7", "iii7", "V7"] key = "C" chords = progressions.to_chords(progression, key) if not fluidsynth.init(SF2): print "Couldn't load soundfont", SF2 sys.exit(1) while 1: i = 0 for chord in chords: c = NoteContainer(chords[i]) l = Note(c[0].name) p = c[1] l.octave_down() print ch.determine(chords[i])[0] # Play chord and lowered first note fluidsynth.play_NoteContainer(c) fluidsynth.play_Note(l) time.sleep(1.0) # Play highest note in chord fluidsynth.play_Note(c[-1]) # 50% chance on a bass note if random() > 0.5: p = Note(c[1].name) p.octave_down() fluidsynth.play_Note(p) time.sleep(0.50) # 50% chance on a ninth if random() > 0.5: l = Note(intervals.second(c[0].name, key)) l.octave_up() fluidsynth.play_Note(l) time.sleep(0.25) # 50% chance on the second highest note if random() > 0.5: fluidsynth.play_Note(c[-2]) time.sleep(0.25) fluidsynth.stop_NoteContainer(c) fluidsynth.stop_Note(l) fluidsynth.stop_Note(p) i += 1 print "-" * 20
def synthComm(): # print "I AM IN synthComm" timeStart = time.time() fluidsynth.init(config.sf2Path) note = Note() ser = serial.Serial(config.megaPath, config.megaBaud,timeout = 1) fluidsynth.stop_Note(note) while config.playing: info = ser.readline() print info if info is not '' and len(info) == 9: # print info # print timeStart fluidsynth.stop_Note(note) # print "---" # print len(info) # print "---" timeElp, x, y, vel = parseInput(timeStart, info) n = pos2Num(x,y) # print n # print names[n] note = Note(names[n],octave) note.velocity = vel fluidsynth.play_Note(note) print "-----" print "Time: {0} \nPosition: {1},{2}\n Velocity: {3}".format(timeElp, x, y, vel) print "-----" else: fluidsynth.stop_Note(note) # config.userHits = np.hstack((config.userHits, np.array([[time],[vel],[x],[y]))) # when done, close out connection ser.close() # print " I HAVE CLOSED THE connection" return
def start(): piano_folder = "25-Piano-Soundfonts" piano_options = convert(os.listdir(piano_folder)) pp.pprint(piano_options) selected_piano = None while selected_piano is None: piano_name = input("Enter Piano: ") selected_piano = piano_options.get(piano_name) SF2 = f"{piano_folder}/{selected_piano}" print("Left Hand") pp.pprint(qwerty_keys_to_standard.get('left')) print("Right Hand") pp.pprint(qwerty_keys_to_standard.get('right')) if not fluidsynth.init(SF2): print("Couldn't load soundfont", SF2) sys.exit(1)
def __init__( self ): # possible fluidsynth guys ##main_volume(channel, value) ##modulation(channel, value) ##pan(channel, value) if not fluidsynth.init( os.path.join( config.RESOURCEdirectory, config.SOUNDfont), config.FLUIDSYNTHdriver ): sys.exit(" COULD NOT LOAD SOUNDFONT PianoMenu.sf2 ") # set instruments on each channel. fluidsynth.set_instrument( config.PIANOchannel, ## channel to set instrument on config.SOUNDfontPIANO ) ## instrument. determined by sound font self.keysmod12 = [ "C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B" ] self.keyson = [ 0 ]*12 # denotes all keys on in an octave self.newnotesonlist = [ ] # list of new [note,velocity] that player has hit self.newnotesofflist = [ ] # list of new note that player has taken fingers off of #self.noteson = set() # set of notes that the player currently has down # commented out since it was crashing things to remove notes sometimes... self.pitchwheel = 64 # current value of the pitch wheel self.modwheel = 0 # current value of the mod wheel self.transientnotes = [] pygame.midi.init()
def __init__(self): if not fluidsynth.init( os.path.join(config.RESOURCEdirectory, config.SOUNDfont), config.FLUIDSYNTHdriver): sys.exit(" Kan de Fluidsynth Sountfont PianoMenu.sf2 niet laden ") # Een instrument geven aan je channels. fluidsynth.set_instrument( config.PIANOchannel, ## channel voor je instrument. config.SOUNDfontPIANO) ## instrument gebaseerd op je soundfont. self.keysmod12 = [ "C", "C#", "D", "Eb", "E", "F", "F#", "G", "Ab", "A", "Bb", "B" ] self.keyson = [0] * 12 # Representeert alle keys in een octaaf self.newnotesonlist = [ ] # lijst van de noten die de gebruiker heeft aangeslagen. self.newnotesofflist = [] # Lijst van noten die gebruiker loslaat. #self.noteson = set() # noten die gebruiker gebruikt. self.pitchwheel = 64 self.modwheel = 0 self.transientnotes = [] pygame.midi.init()
import json import numpy import os import sys import time from mingus.midi import fluidsynth fluidsynth.init( '/Users/paulodenwaldt/Desktop/NLP/finalproject/data/FluidR3_GM.sf2') from itertools import dropwhile, takewhile ''' The audio playback of this program depends on the mingus and fluidsynth libraries. Both can be installed with pip or homebrew. (pip/brew install mingus, pip/brew install fluidsynth). You will also need the FluidR3_GM.sf2 file - this contains the waveforms necessary for synthesis. You can find it here: https://member.keymusician.com/Member/FluidR3_GM/index.html Once you have these installed, just change the path in line 7 to wherever you installed the sf2 file to. ''' # To run this, you will need numpy. An example call is this: # py -3.7 .\melody_generator_epoch.py 1750-1799 -debug # (or whichever era you want to look at instead of 1750-1799), and the # flag -debug is optional which prints progress as the program runs. # The program requires that you have the unique-grams generated for # the time period in the folder unique_ngrams_epochs, # generated by n-gram_epoch_scraper.py, as well as a folder epochs_hmm # with the same time periods which were generated by # n-gram_epoch_predicter.py from the unique_ngrams_epochs folder. # Note: older time periods may give short melodies as a result of
def init(soundfont_path='FluidR3_GM.sf2', driver='alsa'): fluidsynth.init(soundfont_path, driver)
#William Ambrozic 2018 from turtle import * import Tkinter as tk from tkColorChooser import askcolor from mingus.midi import fluidsynth fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2', "alsa") def getDots(Link, view): scale = 6 #increses / decreases the size of the patterns to a factor of scale t.tracer(0) for x in range(numONodes.get()): if (rainbow.get() == 0): t.dot(5, nodeColor.get()) Link[x] = t.position() t.forward(scale * 360.0 / numONodes.get() ) #I want all of the shapes to be to same relative size t.left( 360.0 / numONodes.get() ) #After simpliying (n-2) * 180 given that I need to find the complimentary angle return Link def createPoly(view): colors = [ "#660000", "#990000", "#CC0000", "#FF0000", "#CC3333", "#FF6666", "#FF9999", "#FFCCCC", "#663300", "#993300", "#CC3300", "#FF3300", "#FF6600", "#FF6633", "#FF9966", "#FFCC99", "#996633", "#CC9900", "#FFCC00", "#FFFF00", "#FFFF33", "#FFFF66", "#FFFF99", "#FFFFCC", "#003300", "#006600", "#009900", "#00CC00", "#00FF00", "#66FF66", "#CCFFCC", "#003333", "#336666", "#009999", "#00CCCC", "#66CCCC", "#66FFCC", "#99FFCC", "#003399", "#0033FF", "#0066FF", "#00CCFF",
#!/usr/bin python import constants as consts from libavg import avg, Point2D from mingus.midi import fluidsynth from mingus.containers.Note import Note SF2 = "GeneralUser.sf2" if not fluidsynth.init(SF2, "alsa"): print "Couldn't load soundfont", SF2 class Key(avg.RectNode): def __init__(self, size, pos, pitch, isWhite, parent=None, **kwargs): super(Key, self).__init__(**kwargs) if parent: parent.appendChild(self) self.size = size self.pos = pos self.pitch = pitch self.isWhite = isWhite self.fillopacity = 1 self.setNote() if self.isWhite: self.fillcolor = "FFFFFF" self.color = "000000" self.onDown = self.onWhiteDown self.onUp = self.onWhiteUp self.onOut = self.onWhiteOut else:
from kivy.animation import Animation from kivy.core.window import Window from kivy.graphics import Color, Line, Bezier from kivy.uix.widget import Widget from kivy.uix.spinner import Spinner from kivy.uix.button import Button from kivy.uix.label import Label from kivy.uix.boxlayout import BoxLayout from kivy.uix.floatlayout import FloatLayout from mingus.core import notes, chords from mingus.containers import * from random import random from math import ceil from mingus.midi import fluidsynth fluidsynth.init('fluid.sf2') #set soundfont #initialize default settings #these are changed by buttons #so they are declared here globally fluidsynth.set_instrument(1, 0) octaveSet = 2 keySet = 'C' scaleSet = 'Major' notesChange = True #keep track of changes, so we don't have to recompute unnecessarily allScales = {} currentNotes = [] class SlateWidget(Widget): notesp = {} #contain playing notes
Uses mingus fluidsynth. """ import sys, pdb, time, os sys.path.append("..") from util.constants import * from core.Note import numToPitch_absolute, pitchToNum_absolute from core.solver import make_var import mingus.containers # Try to initialize playback curfiledir = os.path.split(os.path.abspath(os.path.realpath(__file__)))[0] PATH_SOUNDFONT = os.path.join(curfiledir, "./TimGM6mb.sf2") try: from mingus.midi import fluidsynth canPlayback = fluidsynth.init(PATH_SOUNDFONT, "pulseaudio") except ImportError: print "Warning: Could not import mingus. Playback is not supported." canPlayback = False if not canPlayback: print "Warning: Playback is not supported!" else: print "Playback supported!" def playSolution(solution): """ Plays back a given solution. INPUT: dict solution: NOTE: GUI passes in a list of the form: [["<singer><time>", int pitchnum], ...] Command-line interface uses a different representation than
from mingus.midi import fluidsynth fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2') fluidsynth.play_Note(64,0, 100)
def __init__(self,sf_file,bpm): synth.init(sf_file,"alsa") #initialize synth module from Mingus with soundfont file and alsa as default self.bpm = float(bpm) self.me_time = float(240/bpm) #Set the time in seconds that each measure in 4/4 time takes
p[0].append([p[1][0][0],p[1][0][1]]) def p_note_pitch_duration(p): 'note : pitch DASH duration' p[0] = [[p[1],p[3]]] def p_pitch_terminals(p): 'pitch : LETTER DASH NUMBER' p[0] = Note(''.join(p[1:4])) def p_duration_terminals(p): 'duration : NUMBER' p[0] = int(p[1]) def p_error(p): print("parser: syntax error") yacc.yacc() if __name__ == '__main__': fluidsynth.init('sounds/electricPiano.SF2','coreaudio') while 1: try: s = raw_input(">>> ") if s == 'q': break if s == '': continue except EOFError: break result = yacc.parse(s) fluidsynth.play_Track(result,1,bpm)
''' tester for mingus fluidsynth ''' from mingus.midi import fluidsynth from mingus.containers import Note import sys import time import random fluidsynth.init("../HS_Magic_Techno_Drums.SF2") names = ['A', 'Bb', 'B', 'C', 'Db','D','Eb', 'E', 'F', 'Gb','G','Ab'] # while(True): # n = Note(names[random.randrange(0,11,1)], random.randrange(1,4,1)) # n.velocity = random.randrange(40,100,1) # # fluidsynth.set_instrument(1, random.randrange(1,5,1), bank =1) # fluidsynth.play_Note(n) # time.sleep(.1*random.randrange(1,15,1)) # # fluidsynth.stop_Note(n) # time.sleep(.5*random.randrange(1,15,1)) # # fluidsynth.play_Note(n) for i in xrange(0,12): # for j in xrange(1,4): # n = Note(names[i],j) # fluidsynth.play_Note(n) # time.sleep(2) n = Note(names[i], 4) n.velocity = 127 fluidsynth.play_Note(n) time.sleep(1)
def run(**config_params): load_config(**config_params) fluidsynth.init(config.SOUNDFONT_FILE) bottle.run(host=config.HOST, port=config.PORT)
def init(): if not fluidsynth.init(SF2): print "Couldn't load soundfont", SF2 sys.exit(1)
""" """ from mingus.core import progressions, intervals, chords from mingus.core.scales import ionian, aeolian, locrian, whole_note, mixolydian from mingus.containers import NoteContainer, Note, Bar, Track, Composition from mingus.midi import fluidsynth import time, sys import random import math solo_sound_font = "soundfont.sf2" if not fluidsynth.init(solo_sound_font): print "Couldn't load soundfont", solo_sound_font sys.exit(1) choose_scale = {'M' : ionian, 'm' : aeolian, 'dim' : locrian, '+' : whole_note, '7' : mixolydian, 'm7': aeolian, 'M7': ionian} def generate_scale(chord_name): i = 1 while chord_name[i] == 'b' or chord_name[i] == '#': i += 1 return choose_scale[chord_name[i:]](chord_name[:i])
def setUp(self): fluidsynth.init("/home/bspaans/workspace/fluidsynth/ChoriumRevA.SF2") fluidsynth.set_instrument(0,0) s = SequencerObserver() fluidsynth.midi.attach(s)
# Control beginning of solos and chords solo_start = 8 solo_end = 20 chord_start = 16 chord_end = 24 # Channels chord_channel = 1 chord_channel2 = 7 chord_channel3 = 3 bass_channel = 4 solo_channel = 13 random_solo_channel = False if not fluidsynth.init(SF2): print "Couldn't load soundfont", SF2 sys.exit(1) chords = progressions.to_chords(progression, key) loop = 1 while loop < song_end: i = 0 if random_solo_channel: solo_channel = choice(range(5, 8) + [11]) for chord in chords: c = NoteContainer(chords[i]) l = Note(c[0].name) n = Note('C') l.octave_down() l.octave_down() print ch.determine(chords[i])[0]
if block.swing == "Default": block.swing = bool(options.swing) def load_fluidsynth(options): if not options.no_fluidsynth: try: from mingus.midi import fluidsynth except ImportError, msg: raise OptionError, msg except: raise OptionError, "Couldn't load the FluidSynth bindings in mingus. Are you sure FluidSyth has been installed?" if hasattr(options, 'driver'): driver = options.driver else: driver = None if not fluidsynth.init(options.SF2, driver): raise OptionError, "Couldn't load '%s'." % options.SF2 def get_sequencer_from_cli(): options, args = get_options() list_arguments(options) return get_sequencer(options) def get_sequencer(options): movement = get_movement(options) movement.blocks = [] movement.instruments = [] set_ensemble(options, movement) set_instrument(options, movement) blocks = get_blocks(options)