def startServer(rate=44100, jack=True, channels=2):
global pyoserver
if jack:
audio = 'jack'
else:
audio = 'portaudio'
if sys.platform == 'win32':
pyoserver = Server(
sr=rate,
nchnls=channels,
duplex=0,
)
else:
pyoserver = Server(sr=rate,
nchnls=channels,
duplex=0,
audio=audio,
jackname="Slicer")
if audio == 'jack':
pyoserver.setJackAuto(
False, False) ## ERROR in laptop while autoconnecting
pyoserver.boot()
pyoserver.start()
def serverSetup(device, bufsize, api='portaudio', amp=1.0):
_s = Server(sr=48000, nchnls=2, buffersize=bufsize, duplex=0, audio=api)
_s.setOutputDevice(device)
_s.setAmp(amp)
_s.boot()
_s.start()
return _s
def record_midi_wav(mid_):
# write mid_ to file
with open("test.mid", "wb") as bin_file:
mid_.writeFile(bin_file)
s = Server().boot().start()
# create app synth
midi_reader = Notein()
amp = MidiAdsr(midi_reader['velocity'])
pit = MToF(midi_reader['pitch'])
osc = SineLoop(freq=pit, feedback=0, mul=amp).mix(1)
rev = STRev(osc, revtime=1, cutoff=4000, bal=0.2).out()
# create recorder
rec = Record(rev, buffering=2, filename='beat.wav', quality=0.4)
clean = Clean_objects(12, rec)
clean.start()
midi_reader = MidiFile('test.mid')
# makeshift infinite loop
for message in midi_reader.play():
s.addMidiEvent(*message.bytes())
s.stop()
def pink_noise_to_file(duration, filename, mono=True, sampletype=1):
"""
filename : file to generate
duration : duration in seconds of the file to generate
fs : fs of the file to generate
sampletype : 16 bits int (default)
24 bits int
32 bits int
32 bits float
64 bits float
U-Law encoded
A-Law encoded
mono : generates mono file if mono = True
"""
from pyo import Server, PinkNoise
s = Server(duplex=0, audio="offline").boot()
s.boot()
name = filename
s.recordOptions(dur=duration + 0.1,
filename=filename,
fileformat=0,
sampletype=sampletype)
a = PinkNoise(.1).out()
s.start()
s.shutdown()
if mono == True:
from transform_audio import wav_to_mono
wav_to_mono(filename, filename)
def audio_server():
# setup
server = Server(sr=48000, buffersize=512, audio="manual").boot()
yield server
# teardown
server.shutdown()
def switchOn(sampleRate=48000, outputDevice=None, bufferSize=None):
"""You need to switch on the microphone before use, which can take several seconds.
The only time you can specify the sample rate (in Hz) is during switchOn().
You can switchOff() and switchOn() with a different rate, and can `resample()`
a given an `AudioCapture()` object (if one has been recorded).
Considerations on the default sample rate 48kHz::
DVD or video = 48,000
CD-quality = 44,100 / 24 bit
human hearing: ~15,000 (adult); children & young adult higher
human speech: 100-8,000 (useful for telephone: 100-3,300)
google speech API: 16,000 or 8,000 only
Nyquist frequency: twice the highest rate, good to oversample a bit
pyo's downsamp() function can reduce 48,000 to 16,000 in about 0.02s (uses integer steps sizes)
So recording at 48kHz will generate high-quality archival data, and permit easy downsampling.
outputDevice, bufferSize: set these parameters on the pyoServer before booting;
None means use pyo's default values
"""
# imports from pyo, creates globals pyoServer
t0 = core.getTime()
try:
global Server, Record, Input, Clean_objects, SfPlayer, serverCreated, serverBooted
from pyo import Server, Record, Input, Clean_objects, SfPlayer, serverCreated, serverBooted
global getVersion, pa_get_input_devices, pa_get_output_devices, downsamp, upsamp
from pyo import getVersion, pa_get_input_devices, pa_get_output_devices, downsamp, upsamp
global haveMic
haveMic = True
except ImportError:
msg = 'Microphone class not available, needs pyo; see http://code.google.com/p/pyo/'
logging.error(msg)
raise ImportError(msg)
global pyoServer
if serverCreated():
pyoServer.setSamplingRate(sampleRate)
else:
pyoServer = Server(sr=sampleRate, nchnls=2, duplex=1)
if outputDevice:
pyoServer.setOutputDevice(outputDevice)
if bufferSize:
pyoServer.setBufferSize(bufferSize)
pyoServer.boot()
core.pyoServers.append(pyoServer)
pyoServer.start()
logging.exp('%s: switch on (%dhz) took %.3fs' %
(__file__.strip('.py'), sampleRate, core.getTime() - t0))
def init(self):
#Boot server
self.server = Server(audio='jack')
self.server.deactivateMidi()
self.server.boot().start()
#Init devices
for device in self.outputs.values():
device.init()
#Load Registrations
self.pers_mgr.load(self)
print("Loaded Registrations")
def cb(r):
for o in self.outputs.values():
o.on_reg_change()
self.reg_mgr.add_listener(cb)
#Init devices
for device in self.outputs.values():
device.on_reg_change()
def main():
'''Driver code'''
app = S3App()
app.load_file(input('Enter filename: '))
app.load_trainedsynth()
s = Server()
s.setMidiInputDevice(99) # Open all input devices.
s.boot()
def play_midi(filename: str):
mid = MidiFile(filename)
# ... and reading its content.
for message in mid.play():
# For each message, we convert it to integer data with the bytes()
# method and send the values to pyo's Server with the addMidiEvent()
# method. This method programmatically adds a MIDI message to the
# server's internal MIDI event buffer.
s.addMidiEvent(*message.bytes())
Synthesiser = S3Synth(app.reg.coef_)
a = Synthesiser.out()
s.gui(locals())
from pyo import Server, Sine
server = Server()
server.setMidiInputDevice(2) # Change as required
server.boot()
if __name__ == '__main__':
server.start()
audio = Sine().out()
server.gui(locals())
from tabulate import tabulate
import re
import platform
if platform.system() == 'Windows':
import pyreadline
else:
import readline
import string
import sys
import time
from pyo import Server, Fader, Sine
#s = Server(nchnls=1, audio='jack').boot()
#s = Server(nchnls=2, audio='pulseaudio').boot()
s = Server(nchnls=2).boot()
s.start()
class Lexer(object):
tokens = [
'NOTE', 'IS', 'OF', 'FLOAT', 'FRACTION', 'INTEGER', 'HERTZ',
'INTERVAL_NUMBER', 'INTERVAL_QUALITY', 'ABOVEBELOW', 'PLUSMINUS',
'COMMA_TYPE', 'COMMA', 'CENT', 'DROP', 'COMPARE', 'GENERATE', 'BASE',
'TRANSPOSE', 'UPDOWN', 'PLAY', 'TO', 'RPAREN', 'LPAREN', 'LOAD',
'SAVE', 'FILENAME', 'PRINT', 'ON', 'OFF', 'END_STMT'
]
t_ignore = ' \t'
t_NOTE = r'([A-G]b+|[A-G]\#*|[X-Z])'
t_IS = r'\bis\b'
if __name__ == "__main__":
cls()
#camera
cap = cv2.VideoCapture(0)
#useful for debugging
show = False
if "-v" in argv:
show = True
#Pyo server/objects
s = Server().boot()
s.start()
wav = SineLoop(freq=2 * Pi * 261.626)
notes = dict()
notes['a'] = 220
notes['b'] = 246.942
notes['c'] = 261.626
notes['d'] = 293.665
notes['e'] = 329.628
notes['f'] = 349.228
notes['g'] = 391.995
notes['highA'] = 440
try:
main()
except KeyboardInterrupt:
self._amp2Env.stop()
return PyoObject.stop(self)
def out(self, chnl=0, inc=1, dur=0, delay=0):
self._reson1Env.play(dur, delay)
self._reson2Env.play(dur, delay)
self._amp1Env.play(dur, delay)
self._amp2Env.play(dur, delay)
return PyoObject.out(self, chnl, inc, dur, delay)
# Run this script to test the Aqueous class.
if __name__ == "__main__":
from pyo import Delay, Metro, Server, Snap, TrigXnoiseMidi, WGVerb, Pattern
s = Server(duplex=0).boot()
s.setAmp(1.0)
s.start()
t = 3.776
metroAqueous = Metro(time=t * 2).play()
noteAqeous = TrigXnoiseMidi(metroAqueous, dist=0, mrange=(42, 83))
snapAqueous = Snap(noteAqeous, choice=[0, 2, 4, 5, 7, 9, 11], scale=1)
a = Aqueous(snapAqueous, dur=t * 0.75, mul=0.9)
def noteOn():
a.play()
playAqueous = Pattern(function=noteOn, time=t * 2).play()
delay = Delay(a,
delay=t * 0.75,
feedback=0.6,
players = []
ESC = 27
PLUS = 43
MINUS = 45
notes1 = ['a', 'b', 'c']
notes2 = ['d', 'g', 'h']
notes3 = ['e', 'f', 'i', 'j']
screen = pygame.display.set_mode((800, 600))
run = True
server = Server().boot()
server.start()
met = Metro(.125, 12).play()
players.append(Player(met, notes1))
players.append(Player(met, notes2))
players.append(Player(met, notes3))
while run:
for event in pygame.event.get():
if event.type == pygame.KEYUP:
for player in players:
player.note_off(chr(event.key))
if event.key == ESC:
from pyo import Server, Input, Chorus, Delay, Sine # Initialize Audio Server server = Server(audio="portaudio",nchnls=1).boot() server.start() # Initialize Audio Feed audio_in = Input(chnl=0) # Initialize Effect Variables depth = 0.5 feedback = 0.5 bal = 0.5 # Pedal Effect Initialization input = audio_in chorus = Chorus(audio_in, depth=depth, feedback=feedback, bal=bal) lfo = Sine(freq=4,phase=.5,mul=.5,add=.3) delay = Delay(audio_in, delay=0.25, feedback=lfo, maxdelay=3) # Output input.out() chorus.out() delay.out() # GUI Effect Controllers audio_in.ctrl() chorus.ctrl(title="Chorus") lfo.ctrl(title="Sine") delay.ctrl(title="Delay")
def initializeAudio(self):
self.audioServer = Server(audio='jack')
self.audioServer.boot()
self.audioServer.start()
self.reloadAudioFile()
self.audioInitialized = True
def setup_audio_server():
s = Server().boot()
s.start()
return s
def play(self, drum_kit, pattern, measure_length, syncope=False):
"""
This function plays the selected pattern with the selected drum machine
Args:
drum_kit (dict): created drum kit by the user
pattern (dict): pattern or drum loop to play
measure_length (int): relative length of th selected pattern
syncope (bool): flag to select whether the pattern should be played syncopated or not
"""
sleep_time = (1 / (self.BPM / 60)) / 2
# Initialize server
s = Server().boot()
s.start()
bar_counter = 0
measure_counter = 0
if not syncope:
# Go over all the loops
while measure_counter < self.loops:
bar_counter += 1
# Go over all the measures
if bar_counter > measure_length:
bar_counter = 1
measure_counter += 1
players = []
for instrument, beats in pattern.items():
if bar_counter in beats:
# Play in stereo!
players.append(
SfPlayer(drum_kit[instrument], speed=1,
loop=False).out(chnl=[0]))
players.append(
SfPlayer(drum_kit[instrument], speed=1,
loop=False).out(chnl=[1]))
# Wait to reproduce the next note (computed with the BPM)
sleep(sleep_time)
else:
# Syncope counter
syncop_count = 2
while measure_counter < self.loops:
bar_counter += 1
if bar_counter > measure_length:
bar_counter = 1
measure_counter += 1
players = []
for instrument, beats in pattern.items():
if bar_counter in beats:
players.append(
SfPlayer(drum_kit[instrument], speed=1,
loop=False).out(chnl=[0]))
players.append(
SfPlayer(drum_kit[instrument], speed=1,
loop=False).out(chnl=[1]))
# Syncopate notes by elongating by 2 half of the notes
if syncop_count % 2 == 0:
sleep(sleep_time * 2)
else:
sleep(sleep_time)
syncop_count += 1
