def __init__(self):
self.time_var = 20
self.fade = pyo.Fader(fadein=0.005, fadeout=10, dur=20).play()
self.amp = pyo.SigTo(value=self.fade, time=0, init=0.0)
self.freq = pyo.SigTo(2200, time=7, mul=[1, 1.005], init=2200)
self.sig = pyo.RCOsc([self.freq, self.freq - 20],
sharp=4,
mul=self.amp).out()
self.freq.setValue(60)
self.n = pyo.Noise()
self.pan_lfo = pyo.Sine(freq=1, mul=.5, add=.5)
self.fade2 = pyo.Fader(fadein=10, fadeout=10, dur=50).play()
self.lfo1 = pyo.Sine(freq=.1, mul=500, add=1000)
self.lfo2 = pyo.Sine(freq=.4).range(2, 8)
self.bp1 = pyo.ButBP(self.n,
freq=self.lfo1,
q=self.lfo2,
mul=self.fade2)
self.pan = pyo.SPan(self.bp1, outs=2, pan=self.pan_lfo).out()
self.fader3 = pyo.Fader(fadein=0.01, fadeout=5, dur=5, mul=3).play()
self.lfd = pyo.Sine([.4, .3], mul=.2, add=.5)
self.sawer = pyo.SuperSaw(freq=[49, 50],
detune=[self.lfd, self.lfd + 10],
bal=0.7,
mul=self.fader3).out()
time.sleep(50)
def playback5(self, file_path=icq_uh_oh):
print('pb5')
count = self.count
fade = pyo.Fader(fadein=.1, fadeout=0.1, dur=3).play()
select = random.random()
snd = pyo.SndTable(file_path)
env = pyo.HannTable()
pos = pyo.Phasor(snd.getRate() * .25, random.random(), snd.getSize())
dur = pyo.Noise(.05, .1)
g = pyo.Granulator(
snd,
env, [self.granulated_pitch, self.granulated_pitch + .001],
pos,
dur,
24,
mul=fade)
panner = pyo.Pan(g,
outs=2,
pan=random.random(),
spread=random.random()).out()
self.granulated_pitch -= .05
if self.granulated_pitch < .049:
self.granulated_pitch = .05
time.sleep(fade.dur + .05)
g.stop()
def filtered_saw(delay, note, amp, dur=1.):
t = pyo.SawTable(order=15).normalize()
dur *= 2.
env = pyo.Fader(fadein=.02, fadeout=0.02, dur=dur * 0.9,
mul=amp).play(dur=2.5 * dur, delay=delay)
adsr = pyo.Adsr(attack=dur * 0.05,
decay=0.05 * dur,
sustain=0.3,
release=dur * 0.7,
dur=dur * 0.9,
mul=amp).play(dur=2.5 * dur, delay=delay)
osc = pyo.Osc(t, freq=pyo.midiToHz(note), mul=adsr).mix(1)
rev = pyo.Freeverb(osc, size=1., damp=0.5, bal=1.,
mul=env).play(dur=2.5 * dur, delay=delay)
# rev.out(delay=delay, dur=dur)
eq = pyo.Biquad(rev, freq=800, q=1., type=0).play(dur=2.5 * dur,
delay=delay)
eq.out(delay=delay, dur=dur)
# eq = None
return osc, env, rev, eq
def filtered_square(delay, note, amp, dur=1.):
a = np.sqrt(np.linspace(1., 0., 15))
t = pyo.HarmTable(a.tolist())
dur *= 2.
env = pyo.Fader(fadein=.02, fadeout=0.02, dur=dur * 0.9,
mul=amp).play(dur=2.5 * dur, delay=delay)
adsr = pyo.Adsr(attack=dur * 0.05,
sustain=0.707,
decay=0.1 * dur,
release=dur * 0.7,
dur=dur * 0.9,
mul=amp).play(dur=2.5 * dur, delay=delay)
osc = pyo.Osc(t, freq=pyo.midiToHz(note), mul=adsr).mix(1)
rev = pyo.Freeverb(osc, size=1., damp=0.5, bal=1.,
mul=env).play(dur=2.5 * dur, delay=delay)
# rev.out(delay=delay, dur=dur)
eq = pyo.Biquad(rev, freq=500, q=1., type=2).play(dur=2.5 * dur,
delay=delay)
eq.out(delay=delay, dur=dur)
# eq = None
return osc, env, rev, eq
def __init__(self):
self.fader = pyo.Fader(fadein=0.001, fadeout=0.1)
super().__init__(self.snd_tables[0][0], mul=self.fader)
self._left_right_cycle_per_sample = [
infit.ActivityLevel(
5,
start_at=next(self._start_at_cycle),
is_inverse=next(self._is_inverse_cycle),
)
for _ in self.snd_tables
]
def __init__(self):
self.fader = pyo.Fader(fadein=0.5, fadeout=0.5)
self.lfoo0 = pyo.LFO(freq=0.01, mul=1, type=3)
self.lfoo1 = pyo.Sine(freq=0.02, mul=1)
self.lfo = pyo.Sine(freq=self.lfoo0 + self.lfoo1, mul=1)
self.generator = pyo.SineLoop(freq=100,
feedback=0.015 +
((1 + self.lfo) * 0.025),
mul=[self.fader, 0, 0])
self.generator.stop()
self.stop()
self._mul = self.max_vol
self._mul_setter = pyo.Trig()
def playback6(self):
print('pb6')
self.time_var = 20
self.fade = pyo.Fader(fadein=0.005, fadeout=10, dur=20).play()
self.amp = pyo.SigTo(value=self.fade, time=0, init=0.0)
self.freq = pyo.SigTo(2200, time=7, mul=[1, 1.005], init=2200)
self.sig = pyo.RCOsc([self.freq, self.freq - 20],
sharp=4,
mul=self.amp)
panner = pyo.Pan(self.sig,
outs=2,
pan=random.random(),
spread=random.random()).out()
def _enter(self):
if _pyo_server is None:
# try and init it with defaults
# print some warning
init_audio_server()
# process the vars
self.duration = val(self.dur)
self._fader = pyo.Fader(fadein=val(self.fadein),
fadeout=val(self.fadeout),
dur=self.duration,
mul=val(self.volume))
self._sine = pyo.Sine(freq=val(self.freq), mul=self._fader).out()
def playback1(self):
freqs = self.message_translation
self.env2 = pyo.Fader(fadein=.1, fadeout=1, dur=10.01).play()
rand = pyo.Choice(choice=freqs, freq=[1, self.message_length])
osc = pyo.SuperSaw(freq=[rand, rand / 2, rand / 3],
detune=.5,
bal=0.8,
mul=self.env2).out()
d = pyo.Delay(osc, delay=[.2, .5, .75], feedback=.5, mul=self.env2)
panner = pyo.Pan(d,
outs=2,
pan=random.random(),
spread=random.random()).out()
time.sleep(self.env2.dur + .001)
def __init__(self, input, buf_size=8192, overlap=1024):
self.input = input
self.overlap = overlap
self.buf_size = buf_size
self.table_count = 3
self.data = []
self.np_emitter = NpBuffer(self.input, buf_size=self.buf_size, overlap=self.overlap)
self.trig = pyo.TrigFunc(self.np_emitter['trig'], self.get_data_rt)
self.tables = self.table_count * [pyo.DataTable(self.buf_size)]
self.faders = self.table_count * [pyo.Fader(fadein=overlap/SAMPLE_RATE, fadeout=overlap/SAMPLE_RATE, dur=buf_size/SAMPLE_RATE, mul=0.5)]
self.oscs = [pyo.Osc(t, freq=SAMPLE_RATE / self.buf_size, mul=f) for t, f in zip(self.tables, self.faders)]
# TODO add oscs
self._base_objs = self.input.getBaseObjects()
def _enter(self):
super(Beep, self)._enter()
default_init_audio_server()
self._sound_start_time = None
if self._start_time == self._end_time:
self.__fader = None
self.__sine = None
else:
self.__fader = pyo.Fader(fadein=self._fadein,
fadeout=self._fadeout,
mul=self._volume)
self.__sine = pyo.Sine(freq=self._freq, mul=self.__fader)
clock.schedule(self._start_sound, event_time=self._start_time)
if self._end_time is not None:
clock.schedule(self._stop_sound,
event_time=self._end_time - self._fadeout)
def __init__(self, msg, count):
self.lydian_list = [
lydian_dictionary[ord(letter) % 6] for letter in msg
]
self.phrygian_list = [
phrygian_dictionary[ord(letter) % 6] for letter in msg
]
if random.random() <= .5:
self.message_translation = self.lydian_list
else:
self.message_translation = self.phrygian_list
self.message_length = 5 / len(msg)
self.octave = 1 + 1 / (30 % len(msg) + 1)
self.env = pyo.Fader(fadein=.1, fadeout=.1, dur=0).play()
if self.octave == 0:
self.octave = 10
def playback2(self):
print('pb2')
fade = pyo.Fader(fadein=.1, fadeout=0.1, dur=10).play()
glissando = pyo.SigTo(value=200, time=0.1, init=200)
sinewave = pyo.SineLoop(
freq=[glissando, glissando * 4 / 5, glissando * 4 / 3],
feedback=.2,
mul=fade)
panner = pyo.Pan(sinewave,
outs=2,
pan=random.random(),
spread=random.random()).out()
def pick_new_freq():
glissando.value = pyo.Choice(choice=self.message_translation,
freq=[1, 3])
pattern = pyo.Pattern(function=pick_new_freq, time=[.25, 1]).play()
time.sleep(fade.dur + .05)
def __init__(self, input=None, buf_size=SAMPLE_RATE//4, overlap=0, patience=None, buffer_count=2, mul=1, add=0):
"""
Parameters
----------
input : PyoObject
Parent PyoObject (stub)
length : int
Number of samples per buffer
overlap : int
Number of overlapping samples between adjacent buffers
"""
pyo.PyoObject.__init__(self, mul, add)
self.input = input
self.buf_size = buf_size
self.overlap = overlap
self.patience = patience
self.fifo = Queue()
self.is_tfilling = True # filling tables (upon initial play)
self.is_qfilling = False # filling queue (until patience reached)
self.is_ready = False # ready to play
self.is_playing = False # should be playing when ready
# Tables and table readers do process grains of audio
self.curr_buf = 0
assert overlap <= buf_size / 2
self.buffer_count = buffer_count
if self.patience is None: self.patience = self.buffer_count
self.tables = [pyo.DataTable(buf_size) for _ in range(self.buffer_count)]
self.faders = [pyo.Fader(fadein=overlap/SAMPLE_RATE, fadeout=overlap/SAMPLE_RATE, dur=buf_size/SAMPLE_RATE, mul=mul) for _ in range(self.buffer_count)]
self.oscs = [pyo.TableRead(t, freq=t.getRate(), mul=f) for t, f in zip(self.tables, self.faders)]
self.sum = reduce(lambda a, b: a + b, self.oscs) + add
# Timing mechanism to coordinate the tables
self.p_metros = [pyo.Metro(time=(self.buffer_count * (buf_size - overlap) / SAMPLE_RATE)) for i in range(self.buffer_count)]
self.p_trigs = [pyo.TrigFunc(m, self._play_table, arg=(i)) for i, m in enumerate(self.p_metros)]
self.l_trigs = [pyo.TrigFunc(tbr['trig'], self._load_table, arg=(i)) for i, tbr in enumerate(self.oscs)]
self._base_objs = self.sum.getBaseObjects()
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 playback2(self):
print('pb2')
fader = pyo.Fader(fadein=0.2, fadeout=0.2, dur=5, mul=.2)
table = pyo.HarmTable([1, 2, 2, 5, 9])
glissando = pyo.SigTo(value=self.message_translation[0],
time=0.1,
init=self.message_translation[0])
osc = pyo.Osc(
table=table,
freq=[glissando / 2, (glissando - 1) / 2, (glissando + 100) / 2],
mul=fader)
panner = pyo.Pan(osc,
outs=2,
pan=random.random(),
spread=random.random()).out()
def pat():
freq = random.choice(self.message_translation)
glissando.value = freq
p = pyo.Pattern(pat, [self.message_length, .25, .75]).play()
fader.play()
time.sleep(fader.dur + .05)
osc.stop()
ss = pyo.Server(audio="offline")
ss.boot()
duration = 2.0
octaves = 0.5
soundAmp = 0.3
modRate = 10
centerFreq = 2000
freqhigh = centerFreq * np.power(2, octaves / 2)
freqlow = centerFreq / np.power(2, octaves / 2)
envelope = pyo.Sine(freq=modRate,
mul=soundAmp / 2,
add=soundAmp / 2,
phase=0.75)
soundObj = pyo.Fader(fadein=0.002, fadeout=0.002, dur=duration, mul=envelope)
freqcent = float((freqhigh + freqlow) / 2)
bandwidth = float(freqhigh - freqlow)
n = pyo.Noise(mul=soundObj)
soundwaveObj = pyo.IRWinSinc(n, freq=freqcent, bw=bandwidth, type=3,
order=400).out()
#soundwaveObj = pyo.IRWinSinc(n, freq=centerFreq, bw=centerFreq, type=3, order=400).out()
# -- Set recording parameters --
soundFilename = '/home/jarauser/workspace/sounds/{0}octaves.wav'.format(
octaves)
ss.recordOptions(dur=duration,
filename=soundFilename,
fileformat=0,
sampletype=0)
# starting server
SERVER.boot()
# starting sound loop
_speaker_cycle = itertools.cycle(range(INCREMENT, N_CHANNELS + INCREMENT))
ALLOWED_TYPES = {"noise": pyo.Noise(), "sine": pyo.Sine(freq=400)}
try:
SIGNAL = ALLOWED_TYPES[TYPE]
except KeyError:
msg = "Unknown type '{}'. Valid types would be '{}'.".format(
TYPE, ALLOWED_TYPES)
raise NotImplementedError(msg)
FADER = pyo.Fader(fadein=0.07, fadeout=0.07, dur=TIME, mul=MUL)
SIGNAL.mul = FADER
# red & bold printing
print(
"\033[91m",
"\033[1m",
"\n",
)
def _loop() -> None:
speaker = next(_speaker_cycle)
print(
"SPEAKER: ",
"{}".format(speaker + 1),
sep="",
def create_sound(self, soundParams):
'''
NOTE: This methods needs to return both the soundObj and soundwaveObj to be able to
play the sound form elsewhere. If soundwaveObj is not returned, it will not exist
outside this scope, and the pyo server plays nothing on soundObj.play()
'''
if isinstance(soundParams['amplitude'], list) or isinstance(
soundParams['amplitude'], np.ndarray):
soundAmp = list(soundParams['amplitude'])
else:
soundAmp = 2 * [soundParams['amplitude']]
# -- Define sound according to type --
if soundParams['type'] == 'tone':
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=soundParams['duration'],
mul=soundAmp)
soundwaveObj = pyo.Sine(freq=float(soundParams['frequency']),
mul=soundObj).out()
return (soundObj, soundwaveObj)
elif soundParams['type'] == 'chord':
nTones = soundParams['ntones'] # Number of components in chord
factor = soundParams[
'factor'] # Components will be in range [f/factor, f*factor]
centerFreq = soundParams['frequency']
freqEachComp = np.logspace(np.log10(centerFreq / factor),
np.log10(centerFreq * factor), nTones)
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=soundParams['duration'],
mul=soundAmp)
soundwaveObjs = []
for indcomp in range(nTones):
#soundwaveObjs.append(pyo.Sine(freq=freqEachComp[indcomp],
# mul=soundObj).mix(2).out())
soundwaveObjs.append(
pyo.Sine(freq=float(freqEachComp[indcomp]),
mul=soundObj).out())
return (soundObj, soundwaveObjs)
elif soundParams['type'] == 'noise':
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=soundParams['duration'],
mul=soundAmp)
#soundwaveObj = pyo.Noise(mul=soundObj).mix(2).out()
soundwaveObj = pyo.Noise(mul=soundObj).out()
return (soundObj, soundwaveObj)
elif soundParams['type'] == 'AM':
if isinstance(soundAmp, list):
halfAmp = [0.5 * x for x in soundAmp]
else:
halfAmp = 0.5 * soundAmp
envelope = pyo.Sine(freq=soundParams['modFrequency'],
mul=halfAmp,
add=halfAmp,
phase=0.75)
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=soundParams['duration'],
mul=envelope)
soundwaveObj = pyo.Noise(mul=soundObj).out()
return (soundObj, [envelope, soundwaveObj])
'''
soundObj = pyo.Fader(fadein=self.risetime, fadeout=self.falltime,
dur=soundParams['duration'], mul=soundAmp)
envelope = pyo.Sine(freq=soundParams['modFrequency'],mul=soundObj,add=soundAmp,phase=0)
soundwaveObj = pyo.Noise(mul=envelope).out()
return(soundObj,[envelope,soundwaveObj])
'''
elif soundParams['type'] == 'tone_AM':
if isinstance(soundAmp, list):
halfAmp = [0.5 * x for x in soundAmp]
else:
halfAmp = 0.5 * soundAmp
nTones = soundParams['ntones'] # Number of components in chord
factor = soundParams[
'factor'] # Components will be in range [f/factor, f*factor]
centerFreq = soundParams['frequency']
freqEachComp = np.logspace(np.log10(centerFreq / factor),
np.log10(centerFreq * factor),
nTones) if nTones > 1 else [centerFreq]
envelope = pyo.Sine(freq=soundParams['modRate'],
mul=halfAmp,
add=halfAmp,
phase=0.75)
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=soundParams['duration'],
mul=envelope)
soundwaveObjs = []
for indcomp in range(nTones):
soundwaveObjs.append(
pyo.Sine(freq=float(freqEachComp[indcomp]),
mul=soundObj).out())
return (soundObj, [envelope, soundwaveObjs])
elif soundParams['type'] == 'band':
frequency = soundParams['frequency']
octaves = soundParams['octaves']
freqhigh = frequency * np.power(2, octaves / 2)
freqlow = frequency / np.power(2, octaves / 2)
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=soundParams['duration'],
mul=soundAmp)
freqcent = (freqhigh + freqlow) / 2
bandwidth = freqhigh - freqlow
n = pyo.Noise(mul=soundObj)
soundwaveObj = pyo.IRWinSinc(n,
freq=freqcent,
bw=bandwidth,
type=3,
order=400).out()
return (soundObj, soundwaveObj)
elif soundParams['type'] == 'band_AM':
if isinstance(soundAmp, list):
halfAmp = [0.5 * x for x in soundAmp]
else:
halfAmp = 0.5 * soundAmp
frequency = soundParams['frequency']
octaves = soundParams['octaves']
freqhigh = frequency * np.power(2, octaves / 2)
freqlow = frequency / np.power(2, octaves / 2)
envelope = pyo.Sine(freq=soundParams['modRate'],
mul=halfAmp,
add=halfAmp,
phase=0.75)
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=soundParams['duration'],
mul=envelope)
freqcent = (freqhigh + freqlow) / 2
bandwidth = freqhigh - freqlow
n = pyo.Noise(mul=soundObj)
soundwaveObj = pyo.IRWinSinc(n,
freq=freqcent,
bw=bandwidth,
type=3,
order=400).out()
return (soundObj, [envelope, soundwaveObj])
elif soundParams['type'] == 'fromfile':
tableObj = pyo.SndTable(soundParams['filename'])
samplingFreq = tableObj.getRate()
if soundParams.get('duration'):
duration = soundParams['duration']
else:
duration = tableObj.getDur()
if soundParams.get('channel') == 'left':
fs = [samplingFreq, 0]
elif soundParams.get('channel') == 'right':
fs = [0, samplingFreq]
else:
fs = 2 * [samplingFreq]
soundObj = pyo.Fader(fadein=self.risetime,
fadeout=self.falltime,
dur=duration,
mul=soundAmp)
print duration
print fs
soundwaveObj = pyo.Osc(table=tableObj, freq=fs, mul=soundObj).out()
return (soundObj, soundwaveObj)
else:
raise TypeError(
'Sound type "{0}" has not been implemented.'.format(
soundParams['type']))
20000,
)
frequencies = tuple(b - a for a, b in zip(frequencies, frequencies[1:]))
k50fl_specification = expenvelope.Envelope.from_levels_and_durations(
levels, frequencies)
converter = LoudnessToAmplitudeConverter(2)
server = pyo.Server(audio="jack").boot().start()
dur = 0.4
sleep = 0.11
fifths = list(range(8))
random.seed(100)
random.shuffle(fifths)
for fifth in fifths:
frequency = 100 * ((15 / 8)**fifth)
if STATIC:
amp = 0.03
else:
amp = converter.convert(frequency)
print(frequency, amp)
f = pyo.Fader(mul=amp, fadeout=0.01, dur=dur)
sine = pyo.Sine(freq=frequency, mul=f).out(dur=dur)
f.play()
time.sleep(dur + sleep)
import pyo
import os
import numpy as np
# Run this the first time
if 1:
ss = pyo.Server(audio="offline")
ss.boot()
# make a fader
duration = 2.0
soundAmp = [0.05, 0.05]
soundObj = pyo.Fader(fadein=0, fadeout=0, dur=duration, mul=soundAmp)
a = pyo.Noise(mul=soundObj).out()
# play the fader.
# -- Set recording parameters --
soundFilename = '/tmp/test.wav'
ss.recordOptions(dur=duration, filename=soundFilename,
fileformat=0, sampletype=0)
soundObj.play()
ss.start()
# # -- Shutdown the server and delete the variable --
ss.shutdown()
del ss
def pymt_plugin_activate(w, ctx):
ctx.c = MTWidget()
# We initialize the pyo server.
global pyo_count
pyo_count += 1
if pyo_count == 1:
pyo_server.start()
# We create 4 lists which will contain our sliders (to control pitch),
# buttons (to trigger the sound), pyo sine waves and fader objects.
sliders = []
buttons = []
sines = []
faders = []
vlayouts = []
hlayout = MTBoxLayout(spacing=w.width / 10, size=w.size)
def resize_hlayout(w, h):
# reajust layout when moving
hlayout.spacing = w / 10
hlayout.size = w, h
hlayout.do_layout()
w.connect('on_resize', resize_hlayout)
# We create 4 instances of each of the above
for widget in range(4):
vlayouts.append(MTBoxLayout(orientation='vertical', spacing=10))
sliders.append(MTSlider(min=100, max=1000, size_hint=(1, .9)))
buttons.append(MTButton(label='', size_hint=(1, .1)))
vlayouts[widget].add_widget(buttons[widget])
vlayouts[widget].add_widget(sliders[widget])
hlayout.add_widget(vlayouts[widget])
faders.append(pyo.Fader(fadein=0.5, fadeout=0.5, dur=0, mul=0.25))
sines.append(pyo.Sine(mul=faders[widget], freq=300))
sines[widget].out()
ctx.c.add_widget(hlayout)
# This function gets called when a slider moves, it sets the pitch of each sine.
def on_value_change_callback(slider, value):
sines[slider].freq = value
# When the button is pressed, the fader object performs it's fade.
def on_press_callback(btn, *largs):
faders[btn].play()
# When the button is released, the fader object fades back to 0.
def on_release_callback(btn, *largs):
faders[btn].stop()
# We push the handlers and feed it with the slider number so the callback function knows which sine to work on.
for s in range(4):
sliders[s].push_handlers(
on_value_change=curry(on_value_change_callback, s))
sliders[s].value = 300
# Handlers for the buttons are pushed here.
for b in range(4):
buttons[b].push_handlers(on_press=curry(on_press_callback, b))
buttons[b].push_handlers(on_release=curry(on_release_callback, b))
w.add_widget(ctx.c)
duration = 1.0
soundAmp = 0.3
toneAmp = 1.5
frequency = 2000
modRate = 4.0
octaves = 2.0
freqhigh = frequency * np.power(2, octaves / 2)
freqlow = frequency / np.power(2, octaves / 2)
tone = True
halfAmp = 0.5 * soundAmp
envelope = pyo.Sine(freq=modRate, mul=halfAmp, add=halfAmp, phase=0.75)
noiseSoundObj = pyo.Fader(fadein=0.002,
fadeout=0.002,
dur=duration,
mul=envelope)
toneSoundObj = pyo.Fader(fadein=0.002,
fadeout=0.002,
dur=duration,
mul=(soundAmp / 16.0) * toneAmp)
#noiseFaderObj = pyo.Fader(dur=duration, mul=envelope)
#toneFaderObj = pyo.Fader(dur=duration, mul=toneAmp)
if np.isinf(octaves):
masker = pyo.Noise(mul=noiseSoundObj).mix(2).out()
else:
freqcent = (freqhigh + freqlow) / 2
bandwidth = freqhigh - freqlow
n = pyo.Noise(mul=noiseSoundObj)
masker = pyo.IRWinSinc(n, freq=freqcent, bw=bandwidth, type=3,
order=400).mix(2).out()
soundParams.update({'amplitude': [0.1, 0.1]})
risetime = 0.02
falltime = 0.02
duration = 0.1
case = 1
soundWaveObjs = []
if SOUND_SYNC_CHANNEL is not None:
#Add the sync signal to the list of soundWaveObjs
soundParams['amplitude'][
SOUND_SYNC_CHANNEL] = 0 #Silence all other sounds in the sync channel
soundAmp = soundParams['amplitude']
if case == 0:
soundObj = pyo.Fader(fadein=risetime, fadeout=falltime, dur=duration)
soundWaveObjs.append(pyo.Sine(2000, mul=soundObj * soundAmp).out())
if case == 1:
soundObj = pyo.Fader(fadein=risetime,
fadeout=falltime,
dur=duration,
mul=soundAmp)
soundWaveObjs.append(pyo.Sine(2000, mul=soundObj).out())
if case == 2:
modFreq = 8
halfAmp = [0.5 * x for x in soundParams['amplitude']]
envelope = pyo.Sine(freq=modFreq, mul=halfAmp, add=halfAmp, phase=0.75)
soundObj = pyo.Fader(fadein=risetime, fadeout=falltime, dur=duration)
