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 switchOn(sampleRate=44100):
"""Must explicitly switch on the microphone before use, can take several seconds.
"""
# imports from pyo, creates globals including pyoServer and pyoSamplingRate
global haveMic
haveMic = False
t0 = time.time()
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
from pyo import getVersion, pa_get_input_devices, pa_get_output_devices
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 pyoSamplingRate
pyoSamplingRate = sampleRate
global pyoServer
if serverCreated():
pyoServer.setSamplingRate(sampleRate)
pyoServer.boot()
else:
pyoServer = Server(sr=sampleRate, nchnls=2, duplex=1).boot()
pyoServer.start()
logging.exp('%s: switch on (%dhz) took %.3fs' % (__file__.strip('.py'), sampleRate, time.time() - t0))
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 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 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 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 __init__(self, config_path='config.txt'):
self.parse_config_file(config_path)
# init members & properties
self._server = Server().boot() # do first
self._heartbeat = MusebotBase.Heartbeat(self._config)
self._osc_listeners = {}
self._osc_recv = OscDataReceive(self.port, '/', self.osc_listener_callback)
# register osc listeners
self.register_osc_listener('/agent/gain', self.gain)
self.register_osc_listener('/agent/kill', self.shutdown)
self.register_osc_listener('/agent/quit', self.shutdown)
self.register_osc_listener('/agent/off', self.shutdown)
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 __init__(self):
"""Constructor for music_player"""
"""Make sure to call add_gui once initialized"""
self.instruments = [] #instrument/track volume is here
self.tempo = 120.0 #BPM (for now)
self.global_volume = 0.75 #between 0 and 1
self.page_index = 0 #1st page
self.play_all = False
self.playhead_index = 0
self.beat_index = 0
self.server = Server(duplex=0)
"""Set proper output device for latency-free playback on Windows"""
"""Source: https://groups.google.com/d/msg/pyo-discuss/9fvFiGbch3c/tzJTfbpLUY8J"""
if platform.system() == "Windows":
out_devices = pa_get_output_devices()
od_index = 0
for od in out_devices[0]:
if "Primary Sound Driver" in od:
pai = int(out_devices[1][od_index])
self.server.setOutputDevice(pai)
break
od_index += 1
self.server.boot()
self.server.start()
metronome_time = self.SECONDS_PER_MIN / self.tempo
self.metronome = Metro(time=metronome_time)
self.metronome_callback = TrigFunc(self.metronome, function=self.step)
# Create instruments
wavetable_a = WaveInstrument(self, WaveInstrument.BASS)
wavetable_b = WaveInstrument(self, WaveInstrument.LEAD)
drums = DrumInstrument(self)
self.instruments.append(wavetable_a)
self.instruments.append(wavetable_b)
self.instruments.append(drums)
self.mixer_setup()
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, LFO s = Server().boot() s.start() t = CosTable([(0,0), (100,1), (500,.3), (8191,0)]) beat = Beat(time=.125, taps=16, w1=[90,80], w2=50, w3=35, poly=1).play() trmid = TrigXnoiseMidi(beat, dist=12, mrange=(60, 96)) trhz = Snap(trmid, choice=[0,2,3,5,7,8,10], scale=1) tr2 = TrigEnv(beat, table=t, dur=beat['dur'], mul=beat['amp']) a = Sine(freq=trhz, mul=tr2*0.3).out() s.gui(locals())
class MidiCube:
def __init__(self, pers_mgr=PersistenceManager()):
self.inputs = {}
self.outputs = {}
self.reg_mgr = RegistrationManager()
self.pers_mgr = pers_mgr
def reg(self):
return self.reg_mgr.cur_reg
def add_input(self, device: MidiInputDevice):
device.cube = self
self.inputs[device.get_identifier()] = device
#Add Binding callback
def callback(msg: mido.Message):
for binding in self.reg().bindings:
binding.apply(msg.copy(), self, device)
device.add_listener(MidiListener(-1, callback))
def add_output(self, device: MidiOutputDevice):
device.cube = self
self.outputs[device.get_identifier()] = device
print('Added output: ' + device.get_identifier())
def load_devices(self):
for name in mido.get_input_names():
device = mido.open_input(name)
self.add_input(PortInputDevice(device))
for name in mido.get_output_names():
device = mido.open_output(name)
self.add_output(PortOutputDevice(device))
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 close(self, save=True):
for key, inport in self.inputs.items():
try:
inport.close()
except:
pass
for key, outport in self.outputs.items():
try:
outport.close()
except:
pass
if save:
self.pers_mgr.save(self)
print("Saved registrations!")
self.server.stop()
def create_menu(self):
#Option list
options = [
midicube.menu.SimpleMenuOption(self.__bind_device_menu,
"Bind Devices", ""),
midicube.menu.SimpleMenuOption(self.__setup_device_menu,
"Set Up Devices", ""),
midicube.menu.SimpleMenuOption(self.__delete_binding_menu,
"Delete Bindings", ""),
midicube.menu.SimpleMenuOption(self.__registration_menu,
"Registrations", "")
]
menu = midicube.menu.OptionMenu(options, history=True)
return menu
def __bind_device_menu(self):
#Callback
def enter():
self.reg().bindings.append(
DeviceBinding(in_device.curr_value(), out_device.curr_value(),
in_channel.curr_value(),
out_channel.curr_value()))
#out_device.curr_value().bind(in_device.curr_value(), in_channel.curr_value(), out_channel.curr_value())
return None
#Options
in_device = midicube.menu.ValueMenuOption(enter, "Input Device",
[*self.inputs.keys()])
out_device = midicube.menu.ValueMenuOption(enter, "Output Device",
[*self.outputs.keys()])
in_channel = midicube.menu.ValueMenuOption(enter, "Input Channel",
range(-1, 16))
out_channel = midicube.menu.ValueMenuOption(enter, "Output Channel",
range(-1, 16))
#Menu
return midicube.menu.OptionMenu(
[in_device, out_device, in_channel, out_channel])
def __setup_device_menu(self):
#Callback
def enter():
return device.curr_value().create_menu()
#Options
device = midicube.menu.ValueMenuOption(enter, "Device",
[*self.outputs.values()])
#Menu
return midicube.menu.OptionMenu([device])
def __delete_binding_menu(self):
#Callback
def enter():
if binding.curr_value() != None:
self.reg().bindings.remove(binding.curr_value())
return None
#Options
binding = midicube.menu.ValueMenuOption(enter, "Delete Bindings",
self.reg().bindings)
#Menu
return midicube.menu.OptionMenu([binding])
def __registration_menu(self):
#TODO Refresh menu when registrations are changed
#Callbacks
def select_reg():
self.reg_mgr.select(registration.curr_value())
return None
def save_reg_menu():
reg = self.reg()
def save_reg(name):
reg.name = name
self.reg_mgr.add_registration(reg)
return None
return midicube.menu.InputMenu(save_reg, "Save as", reg.name)
def overwrite_reg_menu():
reg = self.reg()
def overwrite_name(name):
def overwrite_reg(new_name):
del self.reg_mgr.registrations[name]
reg.name = new_name
self.reg_mgr.add_registration(reg)
return midicube.menu.InputMenu(overwrite_reg, "New Name",
reg.name)
return midicube.menu.InputMenu(overwrite_name, "Overwrite",
reg.name)
def delete_reg():
del self.reg_mgr.registrations[self.reg().name]
return None
#Options
registration = midicube.menu.ValueMenuOption(
select_reg, "Select Registration",
[*self.reg_mgr.registrations.values()])
save = midicube.menu.SimpleMenuOption(save_reg_menu,
"Save Registration", "")
overwrite = midicube.menu.SimpleMenuOption(overwrite_reg_menu,
"Overwrite Registration",
"")
delete = midicube.menu.SimpleMenuOption(delete_reg,
"Delete Registration", "")
#Menu
return midicube.menu.OptionMenu(
[registration, save, overwrite, delete])
class DspFileHandler():
def __init__(self, dspFile, svg=False, ir=False, af='', line=False, impLen=1, lenSec = 0.5, plotter=None):
self.svg = svg
self.dspFile = dspFile
self.ir = ir
self.af =af
self.line=line
self.lenSec = lenSec
self.impLen = impLen
self.sr = 44100.
self.lenSamps = int(round(self.lenSec*self.sr))
self.audioInitialized = False
self.irAvailable = False
logging.debug(self.lenSamps)
self.lastIR = np.zeros(self.lenSamps)
self.lastSpec = None
self.lastLine = None
self.dspDir = os.path.dirname(os.path.abspath(dspFile))
self.baseName = os.path.basename(dspFile)
self.projectName = self.baseName[:-4]
self.outputPath= config.audioOutPath
self.inputPath= config.audioInPath
self.plotter = plotter
logging.info('watching file: '+os.path.abspath(dspFile))
# self.initializeAudio()
def initializeAudio(self):
self.audioServer = Server(audio='jack')
self.audioServer.boot()
self.audioServer.start()
self.reloadAudioFile()
self.audioInitialized = True
def reloadAudioFile(self):
self.sfplayer = SfPlayer(self.outputPath, loop=False, mul=1).out()
def compute(self):
if not self.svg and not self.ir and not self.af and not self.line:
logging.info('only compiling, no other action.')
cmd = 'faust '+self.dspFile
cmd = shlex.split(cmd)
proc = subprocess.Popen(
cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
resp = proc.communicate()[0]
resp = resp.decode("utf-8")
if 'ERROR' in resp:
print(bcolors.FAIL+'>[ER]'+bcolors.ENDC+resp)
elif 'WARNING' in resp:
print(bcolors.WARNING+'>[WA]'+bcolors.ENDC+resp)
else:
print(resp)
print(bcolors.OKGREEN+'>[OK]'+bcolors.ENDC)
if self.svg:
cmd = 'faust --svg '+self.dspFile
cmd = shlex.split(cmd)
proc = subprocess.Popen(cmd,stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
resp = proc.communicate()[0]
resp = resp.decode("utf-8")
if 'ERROR' in resp:
print (bcolors.FAIL+'>[ER]'+bcolors.ENDC+resp)
elif 'WARNING' in resp:
print (bcolors.WARNING+'>[WA]'+bcolors.ENDC+resp)
self.openSVG()
else:
print(resp)
print (bcolors.OKGREEN+'>[OK]'+bcolors.ENDC)
self.openSVG()
if self.ir:
returnCode = self.compile()
if returnCode <2:
self.getIR()
self.plotSignalQt()
if self.line:
returnCode = self.compile()
if returnCode <2:
self.getLineResponse()
self.plotSignalQt()
if len(self.af)>0:
returnCode = self.compile()
if returnCode<2:
self.inputPath = self.af
self.sr, self.inputSignal = wavfile.read(self.af)
self.processFile(self.af)
self.plotSignalQt()
return
def compile(self):
self.binaryPath = 'offlineProcessor'
outfileCpp = 'offline.cpp'
cmd = 'faust -a '+config.offlineCompArch+' -o '+outfileCpp+' '+self.dspFile
cmd = shlex.split(cmd)
proc = subprocess.Popen(cmd,stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
resp = proc.communicate()[0]
resp = str(resp)
cmd = 'g++ -lsndfile '+outfileCpp+' -o '+self.binaryPath
cmd = shlex.split(cmd)
proc = subprocess.Popen(cmd,stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
resp1 = proc.communicate()[0]
if 'ERROR' in resp:
print (bcolors.FAIL+'>[ER]'+bcolors.ENDC+resp)
return 2
elif 'WARNING' in resp:
print (bcolors.WARNING+'>[WA]'+bcolors.ENDC+resp)
return 1
else:
print (bcolors.OKGREEN+'>[OK]'+bcolors.ENDC)
return 0
def openSVG(self):
svgPath = os.path.join(self.dspDir,self.projectName+'-svg','process.svg')
cmd = 'xdg-open '+svgPath
cmd = shlex.split(cmd)
proc = subprocess.Popen(cmd,stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
def getIR(self):
impOffsetSamps = int(round(self.lenSamps*0.25))
impLength = self.impLen
imp = np.zeros(self.lenSamps)
imp[impOffsetSamps:impOffsetSamps+impLength] = 1
self.processArray(imp)
return
def getLineResponse(self):
line = np.linspace(-1,1,self.sr)
self.processArray(line)
return
def processFile(self, tempPath):
cmd = os.path.join(self.dspDir,self.binaryPath)+' '+tempPath+' '+self.outputPath
cmd = shlex.split(cmd)
proc = subprocess.Popen(cmd,stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
resp = proc.communicate()[0]
self.irAvailable = True
if not self.audioInitialized:
self.initializeAudio()
self.play()
return
def processArray(self,anArray, sr=44100,inputPath='/tmp/offlineInput.wav'):
assert type(anArray) ==np.ndarray
self.inputSignal = anArray.astype(np.float32)
wavfile.write(inputPath, sr, anArray)
self.inputPath = inputPath
cmd = os.path.join(self.dspDir,self.binaryPath)+' '+inputPath+' '+self.outputPath
cmd = shlex.split(cmd)
proc = subprocess.Popen(cmd,stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
resp = proc.communicate()[0]
if not self.audioInitialized:
self.initializeAudio()
self.play()
return
def play(self):
logging.debug('play function called')
self.reloadAudioFile()
# self.trig.play()
def plotSignalQt(self):
_, y = wavfile.read(self.outputPath)
currentAndLast = np.array([self.lastIR,y]).T
self.plotter.plot(currentAndLast)
self.lastIR = y
return
def getSpec(self):
x = self.inputSignal
f, Pxx_den = sig.welch(x, self.sr, nperseg=1024)
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:
:Args:
x : int
New number of harmonics
"""
self._order = x
self._tri_table.replace(self._create_list(x))
self.normalize()
self.refreshView()
@property
def order(self):
"""int. Number of harmonics triangular waveform is made of."""
return self._order
@order.setter
def order(self, x):
self.setOrder(x)
# Run the script to test the TriTable object.
if __name__ == "__main__":
s = Server(duplex=0).boot()
s.setAmp(0.05)
s.start()
t = TriTable(10, 8192)
t.view()
a = Osc(t, 500, mul=.3).out()
s.gui(locals())
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
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:
def play(self):
self._metro.play()
self._table_rec.play()
self._trig_dump.play()
return self
def stop(self):
self._metro.stop()
self._table_rec.stop()
self._trig_dump.stop()
def print_data(self, num, step=1):
self.cpt = 0
self.num = num
print "\n>>>class AccDataAnalyser"
if step > 1:
print "[[X list], [Y list], [Z list]] Data for %d buffers in steps of %d." % (num, step)
self.percent = Percent(self._table_rec['trig'], percent=100./step)
self.trig_print = TrigFunc(self.percent, self._print_data)
else:
print "[[X list], [Y list], [Z list]] Data for %d buffer(s)." % num
self.trig_print = TrigFunc(self._table_rec['trig'], self._print_data)
if __name__ == "__main__":
from pyo import Server
s = Server(sr=SAMP_RATE, buffersize=BUFFER_SIZE).boot()
acc = AccDataAnalyser(12000, "/accxyz").play()
#acc.print_data(4,10)
s.gui(locals())
class MusicPlayer:
"""Playback engine for sequencer samples and sounds"""
NUM_PAGES = 8
NUM_ROWS = 8
NUM_COLS = 8
NUM_TRACKS = 3
NUM_BEATS = NUM_PAGES * NUM_COLS
SECONDS_PER_MIN = 60.0
# Parameters for GUI to build sliders
MIN_TEMPO = 40.0
MAX_TEMPO = 240.0
MIN_VOLUME = 0.0
MAX_VOLUME = 1.0
MIN_REVERB = 0.0
MAX_REVERB = 1.0
# Instrument descriptive constants
WAVETABLE_A = 0
WAVETABLE_B = 1
DRUM_KIT = 2
def __init__(self):
"""Constructor for music_player"""
"""Make sure to call add_gui once initialized"""
self.instruments = [] #instrument/track volume is here
self.tempo = 120.0 #BPM (for now)
self.global_volume = 0.75 #between 0 and 1
self.page_index = 0 #1st page
self.play_all = False
self.playhead_index = 0
self.beat_index = 0
self.server = Server(duplex=0)
"""Set proper output device for latency-free playback on Windows"""
"""Source: https://groups.google.com/d/msg/pyo-discuss/9fvFiGbch3c/tzJTfbpLUY8J"""
if platform.system() == "Windows":
out_devices = pa_get_output_devices()
od_index = 0
for od in out_devices[0]:
if "Primary Sound Driver" in od:
pai = int(out_devices[1][od_index])
self.server.setOutputDevice(pai)
break
od_index += 1
self.server.boot()
self.server.start()
metronome_time = self.SECONDS_PER_MIN / self.tempo
self.metronome = Metro(time=metronome_time)
self.metronome_callback = TrigFunc(self.metronome, function=self.step)
# Create instruments
wavetable_a = WaveInstrument(self, WaveInstrument.BASS)
wavetable_b = WaveInstrument(self, WaveInstrument.LEAD)
drums = DrumInstrument(self)
self.instruments.append(wavetable_a)
self.instruments.append(wavetable_b)
self.instruments.append(drums)
self.mixer_setup()
def mixer_setup(self):
# Combine all tracks in mixer
self.track_mixer = Mixer(outs=1)
for inst_index in range(0, len(self.instruments)):
instrument = self.instruments[inst_index]
generator = instrument.get_generator()
self.track_mixer.addInput(inst_index, generator)
self.track_mixer.setAmp(inst_index, 0, instrument.get_volume())
# Prepare master output
self.master_out = Mixer(outs=1, chnls=2)
self.master_out.addInput(0, self.track_mixer[0])
self.master_out.setAmp(0, 0, self.global_volume)
self.master_out.out()
def add_gui(self, gui):
""" Sets the GUI that this music player must instruct to update playhead.
Must be called right after constructor before operation.
Arguments:
gui: GUI object monitoring this player
"""
self.gui = gui
def terminate(self):
"""Terminate MusicPlayer server in preparation for shutdown"""
self.server.stop()
self.server.shutdown()
def step(self):
""" Step the music player through next beat """
# Set GUI to reflect current beat
self.gui.update_playhead()
# Play step for instruments
for instrument in self.instruments:
instrument.play_step()
# For next iteration, increment playhead and beat indices
self.playhead_index = (self.playhead_index + 1) % self.NUM_COLS
if (self.play_all == True):
self.beat_index = (self.beat_index + 1) % self.NUM_BEATS
elif (self.play_all == False):
self.beat_index = (self.page_index * self.NUM_COLS) +\
self.playhead_index
def add_network_handler(self, network_handler):
self.network_handler = network_handler
"""playback methods"""
def play(self):
self.metronome.play()
def pause(self):
for instrument in self.instruments:
instrument.pause()
self.metronome.stop()
def set_session(self, session):
"""used to load a session into the music player"""
# Reload pertinent MusicPlayer variables
self.set_tempo(session.tempo)
# Reconstruct each instrument from session data
self.instruments = []
instrument_data = session.instrument_data
for data in instrument_data:
volume = data.volume
reverb_mix = data.reverb_mix
notes = data.notes
if isinstance(data, WaveInstrumentData):
wavetype = data.wavetype
wave_instrument = WaveInstrument(self, wavetype, volume,
reverb_mix, notes)
self.instruments.append(wave_instrument)
elif isinstance(data, DrumInstrumentData):
drum_instrument = DrumInstrument(self, volume, reverb_mix,
notes)
self.instruments.append(drum_instrument)
# Reload mixer to reflect new instruments
self.mixer_setup()
""" Modifiers """
def set_note(self, note):
instrument = self.instruments[note.track_id]
instrument.set_note(note)
def set_global_volume(self, volume):
self.global_volume = volume
self.master_out.setAmp(0, 0, volume)
def set_volume(self, track_id, volume):
self.instruments[track_id].set_volume(volume)
self.track_mixer.setAmp(track_id, 0, volume)
def set_reverb(self, track_id, reverb):
self.instruments[track_id].set_reverb(reverb)
def set_tempo(self, new_tempo):
new_time = self.SECONDS_PER_MIN / new_tempo
self.metronome.setTime(new_time)
self.tempo = new_tempo
"""getter methods"""
def get_session(self):
"""Get descriptive MusicPlayer session to restore later"""
session = Session(self, self.instruments)
return session
"""getter methods for GUI"""
def get_names(self, track_id):
return self.instruments[track_id].get_names()
def get_reverb(self, track_id):
return self.instruments[track_id].get_reverb()
def get_volume(self, track_id):
return self.instruments[track_id].get_volume()
def get_global_volume(self):
return self.global_volume
def get_tempo(self):
return self.tempo
def get_note(self, track_id, page_index, position, pitch):
pass
def get_current_page(self, track_id):
instrument = self.instruments[track_id]
notes = instrument.get_page(self.page_index)
return notes
def startPyo():
s = Server().boot()
s.start()
return s
# Make input compatible with python3
if version_info[0] > 2:
raw_input = input
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()
notes = {
'a':220,
'b':246.942,
'c':261.626,
'd':293.665,
'e':329.628,
'f':349.228,
'g':391.995,
'highA':440,
}
# set wav to middle c
wav = SineLoop(freq = 2 * Pi * notes['c'])
class MusebotBase(object):
'''
This class includes the functionality required by all Musebots, namely the
ability to parse the config file, communicate with the server, and gracefully
start up and shut down as per the Musebot communication spec.
'''
class Heartbeat:
def __init__(self, config={}):
self._del = 1 # 1 beat per second
self._msg = [config['id']]
self._osc = OscDataSend('s', config['mc_listen_port'],
'/agent/alive', host=config['mc_hostname'])
def beat(self):
while True:
self._osc.send(self._msg)
sleep(self._del)
if not serverBooted(): break
def start(self, run_as_deamon=True):
self._thread = Thread(target=self.beat)
self._thread.daemon = run_as_deamon # True => die when main thread dies
self._thread.start()
def __init__(self, config_path='config.txt'):
self.parse_config_file(config_path)
# init members & properties
self._server = Server().boot() # do first
self._heartbeat = MusebotBase.Heartbeat(self._config)
self._osc_listeners = {}
self._osc_recv = OscDataReceive(self.port, '/', self.osc_listener_callback)
# register osc listeners
self.register_osc_listener('/agent/gain', self.gain)
self.register_osc_listener('/agent/kill', self.shutdown)
self.register_osc_listener('/agent/quit', self.shutdown)
self.register_osc_listener('/agent/off', self.shutdown)
def parse_config_file(self, config):
with open(config) as f:
self._config = {}
for line in f:
k,v = line.split()
if k in {'mc_listen_port', 'my_listen_port', 'output_channels'}:
self._config[k] = int(v)
else:
self._config[k] = v
def run(self):
'''Implemented in user code'''
pass
def start(self):
self._heartbeat.start()
self.run()
def register_osc_listener(self, address, func):
self._osc_listeners[address] = func
self._osc_recv.addAddress(address)
def osc_listener_callback(self, address, *args):
if address in self._osc_listeners:
self._osc_listeners[address](args)
############################################################################
# osc callbacks
#
def shutdown(self, *args):
print(self.id+' shutting down!')
self._server.stop()
self._server.closeGui()
def gain(self, gain, *args):
self._server.amp = float(gain[0])
############################################################################
# properties
#
@property
def server(self):
return self._server
@property
def config(self):
return deepcopy(self._config)
@property
def id(self):
return self.config['id']
@property
def port(self):
return self.config['my_listen_port']
@property
def hostname(self):
return self.config['mc_hostname']
@property
def hostport(self):
return self.config['mc_listen_port']
@property
def heartbeat(self):
return self._heartbeat
def initializeAudio(self):
self.audioServer = Server(audio='jack')
self.audioServer.boot()
self.audioServer.start()
self.reloadAudioFile()
self.audioInitialized = True
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,
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")
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'
Table containing the waveform samples.
freq: float or PyoObject, optional
Frequency in cycles per second. Defaults to 1.
loop: int {0, 1}, optional
Looping mode, 0 means off, 1 means on. Defaults to 0.
interp: int, optional
Choice of the interpolation method. Defaults to 2.
"""
super().__init__(table,
freq=freq,
loop=loop,
interp=interp,
mul=mul,
add=add)
TrigFunc(self["trig"], lambda: print("LOOP\n\n\n\n\n\n\n"))
if __name__ == "__main__":
from pyo import Server, TableRead
def close():
server.closeGui()
inst.close()
server = Server().boot()
inst = AudioTable(r"D:\music\mosesdt.mp3", 0)
inst.decode()
inst.view()
reader = AudioReader(inst, inst.getRate(), loop=1).out()
server.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())
def setup_audio_server():
s = Server().boot()
s.start()
return s
