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 __init__(self, update_rate, tick_nb, init_funct):
#Rate at which events are called.
self.update_rate = update_rate
#Metronome ticking at the update rate.
self.master_metro = pyo.Metro(self.update_rate)
#Signal equal to the current position in the piece.
self.counter = pyo.Counter(self.master_metro, min=0, max=tick_nb)
#Calls the events at the current counter position every update tick
self.event_tf = pyo.TrigFunc(self.master_metro, self._call_event)
#Calls the init function as soo as .
self.init_tf = pyo.TrigFunc(pyo.Select(self.counter, value=0),
init_funct)
#Dictionary containing lists of tuples (function_to_call, args*) at [tick_nb].
self.structure = {}
self.master_metro.play()
def out(self, freq: float, velocity: float, channel: int):
def set_fader_mul():
self.fader.mul = self.mul
self._mul_trig_func = pyo.TrigFunc(self._mul_setter, set_fader_mul)
self.generator.setFreq(freq)
# randomize parameters for a more lively sound
fadein_time = random.uniform(0.35, 1.5)
self.lfoo0.freq = random.uniform(0.01, 0.6)
self.lfoo1.freq = random.uniform(0.01, 0.5)
self.lfoo0.mul = random.uniform(0.5, 1.2)
self.lfoo1.mul = random.uniform(0.5, 1.2)
self.lfo.mul = random.uniform(0.5, 1)
self.fader.setFadein(fadein_time)
self._mul_setter.play()
# start all lfo and fader
self.fader.play()
self.lfoo0.play()
self.lfoo1.play()
self.lfo.play()
# return & start actual generator
self.generator.mul = [
self.fader if idx == channel else 0 for idx in range(3)
]
self.generator.play()
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,
strings: tuple,
midi_synth: midi.MidiSynth,
spat_maker: spat.BalancedSpatMaker,
n_voices: int = 4,
):
super().__init__()
self._mixer = pyo.Mixer(outs=4, chnls=1, time=0.025)
self._markov_chains = self._make_markov_chains()
self._midi_synth = midi_synth
self.strings = strings
self._generators = [GenderGenerator() for _ in range(n_voices)]
self._generator_idx_cycle = infit.Cycle(range(n_voices))
self._spatialised_generators = [
spat_maker.make_spatialised_signal(gen, n_voices=4)
for gen in self._generators
]
self._summed_generators = sum(self._spatialised_generators)
self._previous_played_pitches = collections.deque([], maxlen=15)
self._trig_func = pyo.TrigFunc(
tuple(self.strings.values())[0].attack_detector, self.trigger_events
)
self._trig_func.stop()
self._add_summed_generators_to_mixer()
def __init__(self, no_patterns: int, steps: int, bpm: float):
"""
:param no_patterns: number of patterns (number of samples to trigger)
:param steps: number of steps
:param bpm: beats per minute
"""
self.time_per_step = 1. / bpm * 60 / 4
self.duration = steps * self.time_per_step
self.offsets = [[0.] * steps for _ in range(no_patterns + 1)]
self.pattern = [[False] * steps for _ in range(no_patterns + 1)]
self.pattern_tables = [
pyo.NewTable(self.duration) for _ in range(no_patterns + 1)
]
self.trigger_tables = [
pyo.TableRead(table, freq=1. / self.duration, interp=1, loop=1)
for table in self.pattern_tables
]
self.trigger_functions = [
pyo.TrigFunc(trigger, lambda: None)
for trigger in self.trigger_tables
]
self.sampling_rate = self.trigger_tables[0].getSamplingRate()
# the last pattern is always on to implement a callback at each step
for step in range(steps):
self.activate(no_patterns, step)
def set_trigger(self, trig_fn):
"""
Args:
trig_fn:
"""
# Using table triggers, call trig_fn when table finishes playing
self.trigger = pyo.TrigFunc(self.table['trig'], trig_fn)
def __init__(self, extractor):
self.extractor = extractor
self.table = pyo.NewTable(extractor.table.length)
self.player = pyo.TableRead(self.table, freq=self.table.getRate())
self.metro = pyo.Metro()
self.trig = pyo.Percent(self.metro)
self.trig_play = pyo.TrigFunc(self.trig, self.play)
self.samples = np.asarray(self.table.getBuffer())
def __init__(self, inp):
self.inp = inp
self.rec = False
self.chain_data = np.zeros((CHAIN_LEN, 3))
self.last_pitch = 0
self.iw = 0
self.ir = 0
self.pitch_track = pyo.Yin(self.inp)
self.vol_track = pyo.Clip(pyo.Follower(self.inp) * 500, 0.1, 1)
self.pitch_table = pyo.NewTable(MAX_NOTE_LEN)
self.vol_table = pyo.NewTable(MAX_NOTE_LEN)
self.pitch_rec = pyo.TableRec(self.pitch_track, self.pitch_table)
self.vol_rec = pyo.TableRec(self.vol_track, self.vol_table)
self.pitch_samples = np.asarray(self.pitch_table.getBuffer())
self.vol_samples = np.asarray(self.vol_table.getBuffer())
self.note_detector = pyo.AttackDetector(self.inp)
self.trig_rec = pyo.TrigFunc(self.note_detector, self.start_rec)
self.trig_stop = pyo.TrigFunc(self.pitch_rec['trig'], self.stop_rec)
def __init__(self, inp):
self.inp = inp
self.sounds = np.zeros((N_SEGMENTS, pyo.secToSamps(MAX_NOTE_LEN)))
self.lens = np.zeros(N_SEGMENTS, dtype=np.int32)
self.iw = 0
self.on = False
self.thresh = pyo.Sig(0.01)
self.follower = pyo.Follower(self.inp, freq=10)
self.up = pyo.Thresh(self.follower, self.thresh, dir=0)
self.down = pyo.Thresh(self.follower, self.thresh, dir=1)
self.table = pyo.NewTable(MAX_NOTE_LEN)
self.rec = pyo.TableRec(self.inp, self.table)
self.trig_start = pyo.TrigFunc(self.up, self.start_rec)
self.trig_save = pyo.TrigFunc(self.down, self.save_sound)
self.trig_drop = pyo.TrigFunc(self.rec['trig'], self.drop_rec)
self.samples = np.asarray(self.table.getBuffer())
def __init__(self, voices):
self.voices = voices
self.nvoices = len(self.voices)
self.freeVoices = range(self.nvoices)
self.queue = range(self.nvoices)
self.freeTrigs = []
for voice in self.voices:
amplitude = pyo.Follower(voice.output[0])
self.freeTrigs.append(pyo.Thresh(amplitude, 0.01, dir=1)) # set the threshold lower?
self.callbacks = []
for vn in range(self.nvoices):
self.callbacks.append(pyo.TrigFunc(self.freeTrigs[vn], self.freeVoice, arg=vn))
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, 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 walker(graph, args, length=10):
"""Random walk through a component of the sound graph, playing as we go"""
num, component = args
start = np.random.choice(list(component))
files = islice(random_walk(graph, start), max(5, len(component) // length))
print('{}--{}'.format(num, len(component)))
files = printer(files, '~~~~{}~'.format(num))
samples = (os.path.join(os.path.dirname(sys.argv[1]), path)
for path in files)
player = pyo.SfPlayer(next(samples), mul=0.1)
trig = pyo.TrigFunc(player['trig'], make_looper(samples, player))
player.out()
while player.isPlaying():
time.sleep(1)
def play(self):
if not self._sig:
self._sig = pyo.Sig(value=self._bpm)
if not self._met:
tpb = 2.5 / (pyo.Clip(pyo.Round(self._sig), 30, 360))
self._met = pyo.Metro(time=tpb)
self._met.play()
if self._callback:
self._callback(b'\xfa')
if not self._met.isPlaying():
self._met.play()
if self._callback:
self._callback(b'\xfb')
if not self._trg:
self._trg = pyo.TrigFunc(self._met, self._trig_callback)
def __init__(self,
input,
mode='straight',
update_time=0.1,
max_memory=8192,
t_resolution=-1,
buf_size=8192,
overlap=-1,
n_resolution=-1):
super().__init__()
self.gl_node_manual_init("audio_feature")
self.gl_node_set_idle_callback(self.update_geometry, update_time)
self.input = input
self.mode = mode
self.max_memory = max_memory
self.t_resolution = t_resolution
self.n_resolution = n_resolution
self.buf_size = buf_size
self.resolution_warning = False
self.overlap = overlap
self.playing = False
self.last_thread = None
self.root = Transform(name="audio_feature_root")
self.geometry = None
if self.mode == 'straight':
if self.t_resolution < 1: self.t_resolution = self.buf_size
if self.overlap < 0: self.overlap = 0
elif self.mode == 'mel_spec':
if self.n_resolution < 1: self.n_resolution = 128
if self.t_resolution < 1: self.t_resolution = 8
self.hop_length = self.buf_size // self.t_resolution
if self.overlap < 0: self.overlap = self.hop_length // 2
self.n_fft = self.hop_length + self.overlap
else:
print("invalid feature mode >:(")
self.data = None
self.np_emitter = NpBuffer(self.input,
buf_size=self.buf_size,
overlap=self.overlap)
#self.pat = pyo.Pattern(function=self.update_geometry, time=update_time)
self.trig = pyo.TrigFunc(self.np_emitter['trig'],
self.extract_feature_rt)
self._base_objs = self.input.getBaseObjects()
def _add_thresh_button(self,
nano_control_button: str,
called_method,
arg=None) -> None:
midibutton_name = "_mididata_{}".format(nano_control_button)
trigger_name = "_trigger_{}".format(nano_control_button)
trigfunc_name = "_trigfunc_{}".format(nano_control_button)
chnl, ctrl = settings.KORG_NANOCONTROL2CONTROL_NUMBER[
nano_control_button]
setattr(self, midibutton_name,
pyo.Midictl(ctrl, 0, 1, init=0, channel=chnl))
setattr(self, trigger_name,
pyo.Thresh(getattr(self, midibutton_name), 0.95, 0))
setattr(
self,
trigfunc_name,
pyo.TrigFunc(getattr(self, trigger_name), called_method, arg=arg),
)
def build(self):
self.barCount = -1
self.n_beats_bar = len(self.pheno.triggers)
self.pitch_seq = self.pheno.sequences.get(
self.data.pitch_seq_id).data.seq
self.pitch_map = self.pheno.notes.get(self.data.pitch_map_id).data.map
self.amp_seq = self.pheno.sequences.get(self.data.amp_seq_id).data.seq
self.amp_map = self.pheno.amps.get(self.data.amp_map_id).data.map
self.pitch = pyo.Sig(0)
self.amp = pyo.Sig(0)
self.callback(0)
self.trigFuncs = []
for i, g in enumerate(self.pheno.triggers):
self.trigFuncs.append(pyo.TrigFunc(g.trigger, self.callback,
arg=i))
def __init__(self, input, buf_size=SAMPLE_RATE, overlap=0, mul=1, add=0):
pyo.PyoObject.__init__(self, mul, add)
self.input = input
self.buf_size = buf_size
self.overlap = overlap
self.block_generator = NpBuffer(self.input,
buf_size=self.buf_size,
buffer_count=4,
overlap=self.overlap)
self.block_player = NpFIFOPlayer(buf_size=self.buf_size,
overlap=self.overlap,
patience=0,
buffer_count=4,
mul=mul,
add=add)
self.load_block = pyo.TrigFunc(self.block_generator['trig'],
self._put_block)
self._base_objs = self.block_player.getBaseObjects()
def __init__(self, obj, path, chnls):
# instance variables
self._chnls = chnls
self._path = path # root path for recordings
self._table_dur = 120.0 # min 5 sec.
self._current_table_index = -1
self._table_count = 2
self._table_list = [
pyo.NewTable(self._table_dur, self._chnls)
for i in range(self._table_count)
]
self._total_count = 0
# pyo objects
self._getNextTable()
self._rec_obj = pyo.TableRec(
obj, self._table_list[self._current_table_index])
self._tswitch_trig = pyo.TrigFunc(
self._rec_obj['trig'],
self._switchNextTable,
arg=[i for i in range(self._table_count)])
def __init__(self, cue_organiser):
self._cue_organiser = cue_organiser
self._path = settings.ACTIVE_MODULE_LOGGING_FILE
self._title = "ACTIVE-MODULES-LOGGING"
self._rewrite()
self._process = utility.logfile(
self._path,
x=40,
y=len(self.modules) + 1,
xoff="+0",
yoff="-650",
title=self._title,
)
self._rewrite_func = pyo.TrigFunc(
[
self._cue_organiser.trigger_play_cue,
self._cue_organiser.trigger_stop_cue,
],
self._rewrite,
)
def __init__(self, cue_organiser):
self._cue_organiser = cue_organiser
self._path = settings.CUE_LOGGING_FILE
self._title = "CUE-LOGGING"
self._rewrite()
self._process = utility.logfile(
self._path,
x=20,
y=3,
xoff="+0",
yoff="-280",
title=self._title,
)
self._rewrite_func = pyo.TrigFunc(
[
self._cue_organiser.trigger_play_cue,
self._cue_organiser.trigger_stop_cue,
self._cue_organiser.trigger_choosen_cue,
],
self._rewrite,
)
def __init__(self, input, buf_size=SAMPLE_RATE, buffer_count=2, overlap=0):
"""
Parameters
----------
input : PyoObject
Parent PyoObject
length : int
Number of samples per buffer
buffer_count : int
Number of buffers used to record (min 2)
overlap : int
Number of overlapping samples between adjacent buffers
"""
self.buf_size = buf_size
duration = (buf_size - overlap) / SAMPLE_RATE
self.last_thread = None
self.data_ready = pyo.Trig()
self.rec_triggers = []
self.tables = []
self.ends = []
self.overlap = overlap
self.overlap_buffer = np.zeros(self.overlap)
self.buffer_count = buffer_count
self.curr_buf = 0
self.playing = False
self.np_buffer = None
for i in range(buffer_count):
self.rec_triggers.append(pyo.Trig())
self.tables.append(pyo.NewTable(duration))
table_rec = pyo.TrigTableRec(input, self.rec_triggers[i],
self.tables[i])
self.ends.append(pyo.TrigFunc(table_rec['trig'], self._table_full))
self._base_objs = self.data_ready.getBaseObjects()
self._trig_objs = self._base_objs
def trighandler(id):
print id
on.setValue(id)
dur = 1.0
delay1 = 0.2
trigs = []
trigs.append(pyo.Metro(dur))
trigs.append(pyo.SDelay(trigs[0], delay=delay1))
trigFuncs = []
for i in range(len(trigs)):
trigFuncs.append(pyo.TrigFunc(trigs[i], trighandler, arg=i))
freq = pyo.Sig(400)
on = pyo.Sig(0)
e = pyo.MidiAdsr(on, attack=0.001, decay=0.005, sustain=0.70, release=0.010)
hifreq = srate
b1 = pyo.LFO(freq=freq, mul=e)
v = pyo.Biquad(input=b1, freq=1000, q=2, type=2).out()
#
#f1.ctrl()
def __init__(self, server: pyo.Server, midi_data_logger):
self.midi_data_logger = midi_data_logger
self.server = server
self.previous_hauptstimme_instrument = set([])
self.instrument_change_trigger = pyo.Trig()
self.pianoteq_trigger = pyo.Trig()
self.sine_mixer = pyo.Mixer(outs=3, chnls=1, mul=0.3)
self.sine_radio_mixer = pyo.Mixer(outs=4, chnls=1, mul=0.3)
self.gong_mixer = pyo.Mixer(outs=4, chnls=1, time=0.05, mul=1)
self.transducer_synth = TransducerSynth(
self._n_voices_for_transducer_synth)
self.gong_synth = GongSynth(self._n_voices_for_gong_synth)
self.kenong_synth = KenongSynth(self._n_voices_for_kenong_synth)
self.pitch_stack = PitchStack()
# sending transducer outputs to sine mixer & sine radio mixer
for n in range(3):
signal = self.transducer_synth.mixer[0][n]
self.sine_mixer.addInput(n, signal)
self.sine_mixer.setAmp(n, n, 1)
self.sine_radio_mixer.addInput(n, signal)
for m in range(4):
# TODO(which amp?)
self.sine_mixer.setAmp(n, m, 1)
self.sine_radio_mixer.setAmp(n, m, 1)
# sending gong outputs and kenong outputs to gong mixer
for n, mixer in enumerate(
(self.kenong_synth.mixer, self.gong_synth.mixer)):
added = 4 * n
for n in range(4):
signal = mixer[0][n]
self.gong_mixer.addInput(n + added, signal)
self.gong_mixer.setAmp(n + added, n, 1)
# sending all transducer and gong inputs out
for mixer, mixer2channel_mapping in (
(self.sine_mixer, settings.SINE_MIXER_INSTRUMENT2CHANNEL_MAPPING),
(
self.sine_radio_mixer,
settings.SINE_TO_RADIO_MIXER_INSTRUMENT2CHANNEL_MAPPING,
),
(self.gong_mixer, settings.GONG_MIXER2CHANNEL_MAPPING),
):
[mixer[i][0].play() for i in mixer2channel_mapping.values()]
self.notes = pyo.Notein(
poly=self._n_voices,
last=self._last_midi_note,
channel=0,
)
self.trigger_on = pyo.TrigFunc(
self.notes["trigon"],
self._trigger_on_function,
arg=list(range(self._n_voices)),
)
self.trigger_off = pyo.TrigFunc(
self.notes["trigoff"],
self._trigger_off_function,
arg=list(range(self._n_voices)),
)
self.sustain_pedal = pyo.Midictl(
settings.KEYBOARD_PEDAL_CTRL_NUMBER,
0,
1,
init=0,
channel=settings.KEYBOARD_CHANNEL,
)
def __init__(
self, trigger: pyo.Trig, server: pyo.Server, max_pitch_bend_size: int = 250
):
def pitch_bend_trigger():
gliss_duration = random.randint(24, 190) # in miliseconds
gliss_size = random.randint(
self._no_pitch_bending - max_pitch_bend_size,
self._no_pitch_bending + max_pitch_bend_size,
)
self.interpolation_trigger(
gliss_size,
self._no_pitch_bending,
gliss_duration,
lambda value, time_stamp: self.server.bendout(
value, channel=0, timestamp=time_stamp
),
)
def make_ctl_trigger(
attribute_name: str,
minval: int,
maxval: int,
mindur: int,
maxdur: int,
ctl_number: int,
):
duration = random.randint(mindur, maxdur) # in miliseconds
value1 = random.randint(minval, maxval)
self.interpolation_trigger(
getattr(self, attribute_name),
value1,
duration,
lambda value, time_stamp: self.server.ctlout(
ctl_number, value, channel=0, timestamp=time_stamp
),
)
setattr(self, attribute_name, value1)
def make_pedal_trigger(attribute_name: str, likelihood: float, ctl_number: int):
if random.random() <= likelihood:
value1 = 127
else:
value1 = 0
self.interpolation_trigger(
getattr(self, attribute_name),
value1,
1,
lambda value, time_stamp: self.server.ctlout(
ctl_number, value, channel=0, timestamp=time_stamp
),
)
setattr(self, attribute_name, value1)
def modulator():
pitch_bend_trigger()
make_ctl_trigger("blooming_energy", 10, 60, 50, 100, 41)
make_ctl_trigger("blooming_inerita", 30, 100, 5, 10, 42)
make_ctl_trigger("impedance", 80, 115, 3, 5, 23)
make_ctl_trigger("cut_off", 95, 126, 3, 5, 24)
make_ctl_trigger("q_factor", 10, 36, 1, 2, 25)
make_ctl_trigger("hammer_hard_piano", 7, 11, 1, 2, 9)
make_ctl_trigger("hammer_hard_mezzo", 48, 50, 1, 2, 94)
make_ctl_trigger("hammer_hard_forte", 88, 93, 1, 2, 95)
make_pedal_trigger("rattle_pedal", 0.02, 57)
make_pedal_trigger("buff_stop_pedal", 0.05, 58)
make_pedal_trigger("mozart_rail", 0.1, 67)
self.blooming_energy = 10
self.blooming_inerita = 30
self.impedance = 60
self.cut_off = 80
self.q_factor = 3
self.hammer_hard_piano = 0
self.hammer_hard_mezzo = 8
self.hammer_hard_forte = 15
self.rattle_pedal = 0
self.buff_stop_pedal = 0
self.mozart_rail = 0
self.trigger = trigger
self.server = server
# turning off sustain pedal
self.server.ctlout(53, 127, channel=0, timestamp=0)
# setting high string length
self.server.ctlout(26, 105, channel=0, timestamp=0)
# set less aggressive dynamic parameter
self.server.ctlout(118, 32, channel=0, timestamp=0)
self.modulator = pyo.TrigFunc(self.trigger, modulator)
import pyo s = pyo.Server().boot() s.start() #audioIn = pyo.Input(chnl=[0,1], mul=0.7) a = pyo.Noise(.25) fft = pyo.FFT(a, size=1024, overlaps=1, wintype=2) re = fft['real'] im = fft['imag'] bin = fft['bin'] mag = pyo.Sqrt(re * re + im * im) magTable = pyo.NewTable(1024) tablerec = pyo.TableRec(mag, magTable) refreshTrig = pyo.Select(bin, value=0) pyo.TrigFunc(refreshTrig, tablerec.play) value = pyo.TableIndex(magTable, bin) s.gui(locals())
def __init__(self, master=None, experiment=[], logger=None):
###########################
# INIT EXPERIMENT
###########################
self.experiment=experiment
###########################
# INIT LOGGING
###########################
self.logger=logger
self.currentTrial = 0
self.currentBlock = 0
self.blockType = 0
self.mouse = 0
###########################
# INIT TIMING
###########################
#self.t = timr(1, self.runexperiment) #placeholder to make sure the variable exists
self.timers = []
###########################
# INIT VISUAL
###########################
self.waitForRatingAnswer = False
self.waitForRatingAnswer2 = False
self.numRects = 4
self.rects=range(self.numRects)
self.screenWidth = 640
self.screenHeight = 480
Frame.__init__(self,master)
self.grid()
self.userPrompt = StringVar()
# moved these up here so they only happen once
pianoimage = Image.open(KEYBOARD_IMAGE)
self.pianoImage = ImageTk.PhotoImage(pianoimage)
sliderimage = Image.open(SLIDER_IMAGE)
self.sliderImage = ImageTk.PhotoImage(sliderimage)
self.fingerString = StringVar()
self.qString = StringVar()
self.countString = StringVar()
self.create_GUI()
###########################
# INIT AUDI
###########################
self.s = pyo.Server(buffersize = 8, nchnls = 1)
# before booting the server, I'll prompt the user to choose an input device
# NOTE: This can be hard-coded later if you always want it to choose a specific MIDI input device
# pyo.pm_list_devices()
# self.choice = input("Which device will you choose?")
# self.s.setMidiInputDevice(int(self.choice))
self.s.setMidiInputDevice(int(3))
self.s.boot()
self.s.start()
# test = pyo.LFO(freq=440.0).out()
time.sleep(1) # settling time
# test.stop()
# MIDI Stuff
self.refnote = 72
self.polynum = 4
self.pianosound = range(self.polynum)
self.notes = pyo.Notein(poly=self.polynum, scale=0, mul=0.5)
self.enablePlayback = False
self.enableNoteLogging = False
self.noteTrig = pyo.TrigFunc(self.notes['trigon'],self.onNoteon,range(self.polynum))
#for p in range(polynum):
# note trigger mixer
self.trigmix = pyo.Mixer(1,self.polynum)
for p in range(self.polynum):
self.trigmix.addInput(p,self.notes['trigon'][p])
self.trigmix.setAmp(p,0,1.0)
self.polyNoteTrig = self.trigmix[0]
global midikeymapping # needs to be visible everywhere
midikeymapping = 1 # set mapping to 1 to start with
# preload sound files
self.melodies = []
self.extract = []
for i in range(self.polynum):
self.pianosound[i] = pyo.SfPlayer(EXTRACT_DIR + PIANO_FILE[0], speed=1, loop=False, offset=0, interp=2, mul=1, add=0)
for fname in STIM_FILES:
self.melodies.append(pyo.SfPlayer(STIM_DIR + fname, mul=0.5))
for fname in EXTRACT_FILES:
self.extract.append(pyo.SfPlayer(EXTRACT_DIR + fname, mul=0.5))
self.metronome = pyo.SfPlayer(EXTRACT_DIR + METRO_FILE[0], mul=0.5)
# prepare sequence and timing triggers
# metroSeq launches the metronome
self.trialMetroSeq = pyo.Seq(time=NOTEDUR/1000.0, seq=[3,3,3,1], poly=1, onlyonce=True, speed=1)
self.expectedKeySeq = pyo.Seq(time=NOTEDUR/1000.0, seq=[9,1,1,1,1], poly=1, onlyonce=True, speed=1)
# trialStartTrigger will be manually launched when we want to start a trial
self.trialStartTrigger = pyo.Trig().stop()
self.warmuptrialStartTrigger = pyo.Trig().stop()
self.dummyTrigger = pyo.Trig().stop()
self.timerLogsEnabled = False
# eventTimer will measure the time between trial events
# eventTimer is initially triggered by the trial start, but will later be switched to measure between note events
self.trialEventTimer = pyo.Timer(self.polyNoteTrig,self.trialStartTrigger)
self.expectedEventTimer = pyo.Timer(self.expectedKeySeq,self.expectedKeySeq)
self.timerMeasurement = pyo.DataTable(1)
self.lastTimerMeasurement = 0.0
self.expectedMeasurement = pyo.DataTable(1)
self.lastExpectedMeasurement = 0.0
self.measurementRecorder = pyo.TablePut(self.trialEventTimer, self.timerMeasurement).play()
self.expectedRecorder = pyo.TablePut(self.expectedEventTimer, self.expectedMeasurement).play()
self.resetAtStim = False
# triggers for the optimized stim delivery
self.t1 = pyo.TrigFunc(self.trialStartTrigger,self.playAudioExtract)
self.t2 = pyo.TrigFunc(self.trialStartTrigger,self.trialMetroSeq.out)
self.t2b = pyo.TrigFunc(self.trialStartTrigger,self.expectedKeySeq.out)
self.t3 = pyo.TrigFunc(self.trialMetroSeq,self.playMetronome)
# self.t3 = pyo.TrigFunc(self.trialMetroSeq,self.metronome.out)
self.t4 = pyo.TrigFunc(self.polyNoteTrig,self.noteTiming)
self.t5 = pyo.TrigFunc(self.expectedKeySeq,self.expectedTiming)
# triggers for the optimized stim delivery in training
#self.t1 = pyo.TrigFunc(self.warmuptrialStartTrigger,self.playAudioExtract)
self.t6 = pyo.TrigFunc(self.warmuptrialStartTrigger,self.trialMetroSeq.out)
self.t7 = pyo.TrigFunc(self.warmuptrialStartTrigger,self.expectedKeySeq.out)
# self.t3 = pyo.TrigFunc(self.trialMetroSeq,self.playMetronome)
# self.t3 = pyo.TrigFunc(self.trialMetroSeq,self.metronome.out)
# self.t4 = pyo.TrigFunc(self.notes['trigon'],self.noteTiming)
# self.t5 = pyo.TrigFunc(self.expectedKeySeq,self.expectedTiming)
###########################
# INIT INPUT DEVICES
###########################
self.set_keybinds()
self.waitForSpacebar = True
############################
self.enableAudioFeedback = False
self.QUIT = False
self.pause = False
