def easy_play(notes, durations=None, bpm=None): """`notes` should be a list of notes and/or note_containers. durations will all default to 4 (quarter notes). bpm will default current BPM setting, `st.BPM`.""" if not bpm: bpm = st.BPM fluidsynth.play_Bar(easy_bar(notes, durations), bpm=bpm)
def playManyNotes(self, notes): """Plays the next note in the song and advances the index""" tempBar = Bar() tempBar.set_meter((len(notes) * 4, 4)) for n in notes: tempBar.place_notes(n, 1) fs.play_Bar(tempBar, 1, 200)
def playBeforeAnswer(randPassage): while (True): fluidsynth.play_Bar(randPassage) ans = input("Press R to replay, enter for answer.> ") if ans.lower() == "r": pass else: return
def playNextNoteLong(self): """Plays the next note in the song and advances the index""" tempBar = Bar() tempBar.set_meter((1, 1)) tempBar.key = self._key tempBar.place_notes(self._notes[self._index], 1) fs.play_Bar(tempBar, 120)
def playAfterAnswer(randPassage): while (True): again = input( "Type X to quit to menu, R to replay, enter for a new dictation.> " ) if again.lower() == "x": return (False) elif again.lower() == "r": fluidsynth.play_Bar(randPassage) else: return (True)
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 playNextNote(self): """Plays the next note in the song and advances the index""" tempBar = Bar() beats = 1.0 / (1.0 / self._beat) / (1.0 / self._durs[self._index]) tempBar.set_meter((beats, self._beat)) tempBar.key = self._key tempBar.place_notes(self._notes[self._index], self._durs[self._index]) print tempBar fs.play_Bar(tempBar, self._bpm) return self._index
def test_changing_bpm_bar(self): b = Bar() n = NoteContainer(['C', 'E', 'G']) n.bpm = 150 b + NoteContainer(['A', 'C', 'E']) b + Note('E') b + n b + Note('Eb') self.assert_(fluidsynth.play_Bar(b, 0, 120))
def test_changing_bpm_bar(self): b = Bar() n = NoteContainer(['C', 'E', 'G']) n.bpm = 150 b + NoteContainer(['A', 'C', 'E']) b + Note('E') b + n b + Note('Eb') self.assert_(fluidsynth.play_Bar(b, 0, 120))
def test_changing_bpm_bar(self): b = Bar() n = NoteContainer(["C", "E", "G"]) n.bpm = 150 b + NoteContainer(["A", "C", "E"]) b + Note("E") b + n b + Note("Eb") self.assert_(fluidsynth.play_Bar(b, 0, 120))
def test_changing_bpm_bar(self): b = Bar() n = NoteContainer(["C", "E", "G"]) n.bpm = 150 b + NoteContainer(["A", "C", "E"]) b + Note("E") b + n b + Note("Eb") self.assertTrue(fluidsynth.play_Bar(b, 0, 120))
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 test_bar_velocity(self): b = Bar() n = Note("C") n.velocity = 0 m = Note("C") m.velocity = 40 o = Note("C") o.velocity = 80 p = Note("C") p.velocity = 120 b + n b + m b + o b + p self.assert_(fluidsynth.play_Bar(b), 0)
def test_bar_velocity(self): b = Bar() n = Note("C") n.velocity = 0 m = Note("C") m.velocity = 40 o = Note("C") o.velocity = 80 p = Note("C") p.velocity = 120 b + n b + m b + o b + p self.assertTrue(fluidsynth.play_Bar(b), 0)
def test_playbar(self): b = Bar() b + Note("C") b + Note("E") b + Note("G") self.assert_(fluidsynth.play_Bar(b), 0)
def play_seventh_chord(choice, key): fs.play_Bar(get_bar_from_chord(SEVENTH_CHORD_FUNCS[choice](key)))
def play_triad(choice, key): fs.play_Bar(get_bar_from_chord(TRIAD_FUNCS[choice](key)))
def play_bar(self): fluidsynth.play_Bar(self.bar)
def playNote(self, note): """Plays the next note in the song and advances the index""" tempBar = Bar() tempBar.place_notes(note, 1) fs.play_Bar(tempBar, 1, 200)
#!/usr/bin/env python2 import mingus.containers as c from mingus.midi import fluidsynth, MidiFileOut sf = '/usr/share/soundfonts/Unison.sf2' fluidsynth.init(sf, 'alsa') bar = c.Bar() bar + c.Note('A',4) bar + c.Note('B',4) bar + c.Note('C',4) bar + c.Note('D',4) print(bar) for _ in range(10): print('Play') fluidsynth.play_Bar(bar)
def playChord(self, note1, note2): """Plays the next note in the song and advances the index""" tempBar = Bar() tempBar.place_notes([note1, note2], 1) fs.play_Bar(tempBar, 1, 200)
def test_playbar(self): b = Bar() b + Note('C') b + Note('E') b + Note('G') self.assert_(fluidsynth.play_Bar(b), 0)
def play_chord(choice, key): fs.play_Bar(get_bar_from_triad(CHORD_FUNCS[choice](key)))
def test_playbar(self): b = Bar() b + Note('C') b + Note('E') b + Note('G') self.assert_(fluidsynth.play_Bar(b), 0)
def test_playbar(self): b = Bar() b + Note("C") b + Note("E") b + Note("G") self.assertTrue(fluidsynth.play_Bar(b), 0)
def next_bar(self): self.bar = self.random_bar() fluidsynth.play_Bar(self.bar)
def speedDrill(): print("""INPUT FORMAT: You are expected to type the letter name (A, B, C, etc.) with your left hand. Your right hand will type the accidental. , = flat . = natural / = sharp This is meant to roughly even out the effort for typing each note, whether F# or C; but if you wish, you may also enter a standard name, e.g. A4, C#3, Eb6. Inputs are not case sensitive. If you cannot hear a pitch, enter S to skip that question. Type X to quit.\n""" ) ## TO DO: Give a report card of average times and accuracy for each pc. ## Also, make timer interrupt any raw_input. (Right now it only checks timer when the loop iterates.) while (True): try: timelimit = int(input("Enter time limit in minutes (1-5) > ")) if timelimit >= 1 and timelimit <= 5: timelimit = timelimit * 60.0 break except ValueError: pass while (True): octaves = input("Test octaves? (Y/N) > ") if octaves.lower() == "y": octaves = True break elif octaves.lower() == "n": octaves = False break else: pass score = 0 attempts = 1 input("Press ENTER to begin.") startTime = time.time() while (time.time() - startTime < timelimit): randInstrument(1) randPitch = Note(12 * randint(3, 6) + randint(0, 12)) randBar = Bar() randBar.place_notes(randPitch, 4) fluidsynth.play_Bar(randBar) ans1 = ans2 = altans1 = altans2 = "x" # Create two possible answers for black keys. ans1 is the "preferred" answer. # Only ans1 will be printed and needs mixed case; the others are only for # internal comparison and are assigned lowercase only. if randPitch.name == "C#": ans1 = "C#" altans1 = "c/" ans2 = "db" altans2 = "d," elif randPitch.name == "D#": ans1 = "Eb" altans1 = "e," ans2 = "d#" altans2 = "d/" elif randPitch.name == "F#": ans1 = "F#" altans1 = "f/" ans2 = "gb" altans2 = "g," elif randPitch.name == "G#": ans1 = "G#" altans1 = "g/" ans2 = "ab" altans2 = "a," elif randPitch.name == "A#": ans1 = "Bb" altans1 = "b," ans2 = "a#" altans2 = "a/" else: ans1 = randPitch.name ans2 = ans1.lower() altans1 = ans2 + "." altans2 = altans1 if (octaves): ans1 = ans1 + str(randPitch.octave) ans2 = ans2 + str(randPitch.octave) altans1 = altans1 + str(randPitch.octave) altans2 = altans2 + str(randPitch.octave) correct = False guess = input("Enter guess. > ") if guess.lower() == "s": print("Skipped.") elif guess.lower() == "x": break elif guess.lower() == ans1.lower() or guess.lower( ) == ans2 or guess.lower() == altans1 or guess.lower() == altans2: score += 1 print("CORRECT ({0}). SCORE: {1}/{2} ({3}%)".format( ans1, score, attempts, round(100 * float(score) / attempts), 2)) attempts += 1 else: print("* WRONG ({0}). SCORE: {1}/{2} ({3}%)".format( ans1, score, attempts, round(100 * float(score) / attempts), 2)) attempts += 1 print("Time's up.")
def targetYN(): print( "GOAL: Choose a target pitch. Listen to a random melody: is the target pitch in there? If yes, play it again, and type in the index of the pitch (i.e. what number does it fall in the sequence: 1, 2, 3 ...).\n" ) pcSought_in = input("Which pc are you listening for? (0-11) > ") try: pcSought = int(pcSought_in) except: print("Error. Please type an integer 0-11.") return if pcSought < 0 or pcSought > 11: print("Error. Please type an integer 0-11.") numnotes_in = input("Please choose a melody length. (1-16) > ") try: numnotes = int(numnotes_in) except: print("Error. Please type an integer 1-16.") return if numnotes < 1 or numnotes > 16: print("Error. Please type an integer 1-16.") return loopTarget = True while (loopTarget): randInstrument(1) randNotes = [] randBar = Bar() randBar.set_meter((numnotes, 4)) pitch_list = [] for i in range(0, numnotes): randPitch = Note(12 * randint(3, 6) + randint(0, 12)) randNotes.append(randPitch) pitch_list.append(notes.note_to_int(randPitch.name)) randBar.place_notes(randPitch, 4) fluidsynth.play_Bar(randBar) note_present = False if (pcSought in pitch_list): note_present = True present_in = input("Was the desired note present? (Y/N) > ") player_thinks = False if present_in.lower() == "y": player_thinks = True if player_thinks == note_present: print("Correct! The note", end="") if note_present: print(" was present.\n") else: print(" was not present.\n") else: print("Incorrect. The note\n", end="") if note_present: print(" was present.\n") else: print(" was not present.\n") if note_present: print( "Press ENTER to replay, then type where in the sequence the note appears." ) fluidsynth.play_Bar(randBar) locations_in = input( "Enter the indices of the note, starting with 1, and separated by spaces. > " ) #string processing: make an array from the input. Make an array of the pitch locations. Compare. Are they correct? Output the array. print(randNotes) loopTarget = playAfterAnswer(randBar)
def play_solo_bar_with_chord(chord_name): chord = NoteContainer(chords.from_shorthand(chord_name)) solo = solo_bar(chord_name) fluidsynth.play_NoteContainer(chord, 13) fluidsynth.play_Bar(solo, 10) fluidsynth.stop_NoteContainer(chord, 13)
def play_interval(choice, key): fs.play_Bar(get_bar_from_interval([key, INTERVAL_FUNCS[choice](key)]))