def test_beat3(server):
inp = pyo.Input([0, 1])
mix = pyo.Mix(inp)
gt = pyo.Gate(mix, -30, outputAmp=True)
prn = pyo.Print(gt, 1, message='gt')
return prn
def test_level_to_midi(server):
def trig_func(obj):
print('velocity', obj.stream.getValue())
velo = int(obj.stream.getValue())
server.ctlout(28, velo, 1)
#print(obj, dir(obj))
#print(obj.stream, dir(obj.stream))
#mc = functools.partial(meter_callback, server)
#def mcb(*args, **kwargs):
# print(args, kwargs)
#server.setMeterCallable(mcb)
inp = pyo.Input([0,1])
inx = pyo.Mix(inp)
flr = pyo.Follower(inx)
scl = pyo.Scale(flr, outmax=31, exp=0.5)
rnd = pyo.Round(scl)
#rnds = pyo.Switch(rnd, outs=2)
#prn = pyo.Print(rnd, 1, message='rnd')
chg = pyo.Change(rnd)
#pr2 = pyo.Print(chg, 1, message='chg')
scl2 = pyo.Scale(rnd, inmax=31, outmin=0, outmax=127)
rnd2 = pyo.Round(scl2)
trg = pyo.TrigFunc(chg, trig_func, rnd2)
return trg
def __init__(self, res=50, lag=.01, lag2=.03):
self.snd = SndReader()
self.res = res
self.lag = lag
self.lag2 = lag2
self.dur = self.snd.dur
self.refreshRate = self.snd.refreshRate
self.len = int(self.dur * self.res)
self.tab = pyo.DataTable(self.len)
self.datar = np.asarray(self.tab.getBuffer())
self.table = self.snd.table
self.env = self.table.getEnvelope(self.len)
self.envAr = np.concatenate(
np.round(np.absolute(np.asarray(self.env)), 2))
self.tableOG = self.snd.tableOG
self.durOG = self.snd.durOG
self.son = pyo.TableRead(self.table, 1 / self.dur, 1)
self.sig = None
self.son = pyo.TableRead(self.table, 1 / self.dur, 1).play()
self.son = pyo.Mix(self.son, 2)
self.son.out()
def test_metronome(server):
def trig_func():
print(server.getCurrentTime(), 'trig')
inp = pyo.Input([0,1])
inx = pyo.Mix(inp)
#atd = pyo.AttackDetector(inx)
#prn = pyo.Print(atd, 1, message='attack')
#avg = pyo.Average(inx)
#prn = pyo.Print(avg, 1, message='avg')
#sig = pyo.Sig(0.5)
bpm = pyo.Sig(value=120)
#bpm_round = pyo.Round(bpm)
#bpm2 = pyo.Clip(bpm2, 30, 360)
tpb = 2.5 / (pyo.Clip(pyo.Round(bpm), 30, 360))
met = pyo.Metro(time=tpb)
met.play()
print(server.getBufferSize())
trg = pyo.TrigFunc(met, trig_func)
#ti = pyo.Timer(met, met)
#prn = pyo.Print(met, 1, message='met')
#bpm = pyo.Round(60 / ti)
#bpm2 = pyo.Clip(bpm, 30, 360)
#pr2 = pyo.Print(pyo.Clip(pyo.Round(60 / ti), 30, 360), 0, message='bpm')
def update_met():
print('update met')
#met.setTime(0.4)
bpm.setValue(150)
#met.stop()
#met.play()
ca = pyo.CallAfter(update_met, 10)
return bpm, trg, ca
def test_beat3a(server):
inp = pyo.Input([0, 1])
mix = pyo.Mix(inp)
ad = pyo.AttackDetector(mix, 0.005, 10, 3, -30, 0.1)
ad.ctrl()
tmr = pyo.Timer(ad, ad)
prn = pyo.Print(tmr, 1, message='tmr')
return ad, prn
def setInputChannels(self, value):
if not isinstance(value, (list, tuple)):
value = [value]
if self._input_channels != value:
self._input_channels = value
if self._but_lp:
inp = pyo.Input(self._input_channels)
mix = pyo.Mix(inp)
self._but_lp.setInput(mix)
def play(self):
if not self._but_lp:
inp = pyo.Input(self._input_channels)
mix = pyo.Mix(inp)
self._but_lp = pyo.ButLP(mix, self._lpf)
if not self._follower:
self._follower = pyo.Follower2(self._but_lp,
risetime=self._attack,
falltime=self._release)
if not self._peak_amp:
self._peak_amp = pyo.PeakAmp(self._follower,
self._peak_amp_callback)
def test_beat3b(server):
inp = pyo.Input([0, 1])
mix = pyo.Mix(inp)
flr1 = pyo.Follower2(mix, 0.005, 0.005)
spl1 = pyo.AToDB(flr1)
flr2 = pyo.Follower2(mix, 0.1, 0.1)
spl2 = pyo.AToDB(flr2)
diff = spl2 - spl1
thr = pyo.Thresh(diff, 6)
nxt = pyo.TrackHold(diff, thr, 1)
tmr = pyo.Timer(thr, thr)
prn = pyo.Print(tmr, 1, message='thr')
return prn, nxt
def test_beat1a(server):
# Based on http://damian.pecke.tt/beat-detection-on-the-arduino
inp = pyo.Input([0, 1])
mix = pyo.Mix(inp)
# 20 - 200hz Bandpass Filter
#q = pyo.Sig(.1) # No idea what Q should be...
bpf = pyo.ButBP(mix, 63.245, 9.1)
ab = pyo.Abs(bpf)
lpf = pyo.ButLP(ab, 10)
bp2 = pyo.ButBP(lpf, 2.57, 9)
#server.setCallback()
sp = pyo.Spectrum(bp2)
return bpf, sp, lpf, bp2
def listen(device_num, initial_files):
"""Start listening for MIDI. This function will not block, just
start the audio serber and all the midi handling."""
server = pyo.Server(nchnls=1)
server.deactivateMidi()
server.boot().start()
players = {
note: pyo.SfPlayer(path, mul=.1).stop()
for note, path in initial_files.items()
}
mixdown = pyo.Mix(list(players.values()))
out = pyo.Compress(mixdown)
out = pyo.Freeverb(out).out()
raw = pyo.MidiListener(make_callback(players, out), device_num).start()
return players, server
def test_table(server):
def process():
data = table.getTable()
# "data" is a list of floats of length "buffer size".
# Register the "process" function to be called at the beginning
# of every processing loop.
server.setCallback(process)
# Create a table of length `buffer size`.
table = pyo.DataTable(size=server.getBufferSize())
inp = pyo.Input([0,1])
mix = pyo.Mix(inp)
# Fill the table with the audio signal every processing loop.
tfl = pyo.TableFill(mix, table)
return tfl
def refresh(self):
self.snd.refresh()
self.snd = self.snd
self.dur = self.snd.dur
self.refreshRate = self.snd.refreshRate
self.len = int(self.dur * self.res)
self.tab = pyo.DataTable(self.len)
self.datar = np.asarray(self.tab.getBuffer())
self.table = self.snd.table
self.env = self.table.getEnvelope(self.len)
self.envAr = np.concatenate(
np.round(np.absolute(np.asarray(self.env)), 2))
self.tableOG = self.snd.tableOG
self.durOG = self.snd.durOG
self.son = pyo.TableRead(self.table, 1 / self.dur, 1).play()
self.son = pyo.Mix(self.son, 2)
self.son.out()
def StartAudioInputMeter(self):
input_meter = wx.FindWindowById(ID_INPUT_METER)
if not input_meter:
self.StopAudioInputMeter()
return
input_meter_ref = weakref.ref(input_meter)
def peak_amp_func(*args):
meter_data = [min(120, max(0, int(-120.0 if arg < 0.000001 else 20.0 * math.log10(arg)) + 90)) for arg in args]
# meter_data = [min(120, max(0, int(pyo.rescale(arg, 0, 1, 0, 120)))) for arg in args]
input_meter = input_meter_ref()
if input_meter:
input_meter.SetData(meter_data, 0, len(meter_data))
aic = self.GetAudioInputChannels()
chans = [n for n in range(8) if (aic & (2 ** n))]
inp = pyo.Input(chans)
mix = pyo.Mix(inp, 2)
self._input_peak_amp = pyo.PeakAmp(mix, peak_amp_func)
def __init__(self) -> None:
self.fader = pyo.Fader(fadein=0.005, fadeout=self._fadeout_time)
self.trigger1 = pyo.Trig()
self._mul = self.max_vol
self.spatialisation = [[pyo.Sig(0) for _ in range(4)]
for _ in range(2)]
self.table_reads = [
pyo.TableRead(
table,
freq=table.getRate(),
) for table in self.snd_tables[0]
]
self.processed_tables = [
pyo.ButLP(table_read, freq=6000) for table_read in self.table_reads
]
self.spatialised_tables = [
pyo.Mix(signal,
voices=4,
mul=[self.fader * spat_value for spat_value in spat])
for signal, spat in zip(self.processed_tables, self.spatialisation)
]
self.generator = self.spatialised_tables[0] + self.spatialised_tables[1]
def create_synth_passthrough(self):
'''Create a "synth" that will pass audio on the input channel to
your output channel(s).'''
self.log.debug('creating passthrough synth')
i = pyo.Input()
return pyo.Mix(i, voices=2, mul=0)
masker = pyo.IRWinSinc(n, freq=freqcent, bw=bandwidth, type=3,
order=400).mix(2).out()
if tone:
soundwaveObjs = []
soundwaveObjs.append(
pyo.Sine(freq=frequency, mul=toneSoundObj).mix(2).out())
soundwaveObjs.append(masker)
else:
soundwaveObj = masker
# -- Set recording parameters --
soundFilename = '/home/jarauser/workspace/sounds/{0}amp_{1}octaves_{2}.wav'.format(
soundAmp, octaves,
str(toneAmp) + "tone" if tone else "noTone")
ss.recordOptions(dur=duration,
filename=soundFilename,
fileformat=0,
sampletype=0)
soundObj = pyo.Mix([noiseSoundObj, toneSoundObj], voices=2).out()
soundObj.play()
noiseSoundObj.play()
toneSoundObj.play()
ss.start()
# -- Shutdown the server and delete the variable --
ss.shutdown()
del ss
os.system('aplay {0}'.format(soundFilename))
def test_beat1(server):
server.server_ms = 0
last_ms = 0
server.last_bpm = 0
server.bpms = []
server.last_avg = 0
def trig_func():
#ct = server.getCurrentTime()
delta = server_ms - last_ms
last_ms = server_ms
#delta = ct - last_ct
#bpm =
print(delta, 'trig')
def time_callback(hours, minutes, seconds, milliseconds):
#print(hours, minutes, seconds, milliseconds)
server.server_ms = hours * 3600000 + minutes * 60000 + seconds * 1000 + milliseconds
def process_callback():
if ad.minthresh != thr.get():
ad.minthresh = thr.get()
#if server.last_avg != avg.get():
# print('avg', avg.get())
# server.last_avg = avg.get()
return
#bpm = 120 / (tmr.get() or 0.001)
#while bpm > 360:
# bpm /= 2
#while bpm < 40:
# bpm *= 2
#print('bpm?', bpm)
data = table.getTable()
if len(data):
#data = [d for d in data if d]
#print(len(data), sum(data), server.server_ms)
bpm = len(data) * 60 / (sum(data) or 0.001)
while bpm > 360:
bpm /= 2
while bpm < 40:
bpm *= 2
#server.bpms.append()
bpm = int(bpm)
if bpm != server.last_bpm:
server.last_bpm = bpm
print('bpm?', bpm)
table.reset()
#tfl.play()
#print(ad.minthresh)
server.setTimeCallable(time_callback)
server.setCallback(process_callback)
table = pyo.DataTable(size=32)
inp = pyo.Input([0, 1])
mix = pyo.Mix(inp)
flr = pyo.Follower2(mix, 0.5, 0.5)
fla = pyo.Average(flr, server.getBufferSize())
#flr.ctrl()
spl = pyo.AToDB(flr)
thr = spl - 6
ad = pyo.AttackDetector(mix, 0.005, 1000, 12, -30, 0.05)
#ad.ctrl()
#prn = pyo.Print(ad, 1, message='ad')
prn = None
tmr = pyo.Timer(ad, ad)
#avg = pyo.Average(tmr, server.getBufferSize())
#bpm = 60 / pyo.Min(tmr, 0.001)
#trg = pyo.TrigFunc(ad, trig_func)
prn2 = pyo.Print(tmr, 1, message='tmr')
#tfl = pyo.TableFill(tmr, table)
return ad, prn, thr, prn2