key = int(k[1])
current_fingering.add_addition_key(pattern_number, course, key)
pattern_number += 1
pattern_number = 0
for pattern in f[3]:
needed_polyphony += 1
current_fingering.add_polyphony_pattern(pattern_number,
pattern[0][0])
for k in pattern[1]:
course = int(k[0])
key = int(k[1])
current_fingering.add_polyphony_key(pattern_number, course,
key)
pattern_number += 1
if (f[4]):
current_fingering.set_open()
current_fingering.evaluate_table()
current_fingering.set_poly(needed_polyphony)
self.finger.set_fingering(self.current_fingering)
return
class Upgrader(upgrade.Upgrader):
pass
agent.main(Agent, Upgrader)
import piw
from pi.logic.shortcuts import T
from pi import agent,atom,domain,bundles,action,async,utils,upgrade,policy
from . import clarinet_oscillator_version as version,stk_native
def filtered_policy():
return policy.LopassStreamPolicy(1000,0.98)
class Agent(agent.Agent):
def __init__(self, address, ordinal):
agent.Agent.__init__(self, signature=version,names='panpipe oscillator',ordinal=ordinal)
self.domain = piw.clockdomain_ctl()
self[1] = bundles.Output(1,True,names="audio output")
self.output = bundles.Splitter(self.domain, self[1])
self.inst = stk_native.panpipe(self.output.cookie(),self.domain)
self.input = bundles.VectorInput(self.inst.cookie(), self.domain,signals=(2,3,4,5,6,7))
param=(T('stageinc',0.01),T('inc',0.02),T('biginc',0.2),T('control','updown'))
self[2] = atom.Atom()
self[2][2] = atom.Atom(names='frequency input', domain=domain.BoundedFloat(1,96000), policy=self.input.vector_policy(2,filtered_policy()))
self[2][3] = atom.Atom(names='pressure input', domain=domain.BoundedFloat(0,1), policy=self.input.merge_policy(3,False))
self[2][4] = atom.Atom(names='reed stiffness input', domain=domain.BoundedFloat(0,1,hints=param), init=0.5, policy=self.input.merge_policy(4,False))
self[2][5] = atom.Atom(names='noise gain input', domain=domain.BoundedFloat(0,1,hints=param), init=0.2, policy=self.input.merge_policy(5,False))
self[2][6] = atom.Atom(names='vibrato frequency input', domain=domain.BoundedFloat(0,1,hints=param), init=0.2, policy=self.input.merge_policy(6,False), protocols='explicit')
self[2][7] = atom.Atom(names='vibrato gain input', domain=domain.BoundedFloat(0,1,hints=param), init=0, policy=self.input.merge_policy(7,False))
agent.main(Agent)
def server_closed(self):
self.load_enumerator.stop()
self.enumerator.stop()
agent.Agent.server_closed(self)
def download_keyboard(self, usbname):
firmware = ezload.firmware(ezload.vendor, ezload.product)
if firmware:
print 'loading firmware'
ezload.download(usbname, firmware)
def next_keyboard(self):
i = 0
for ss in self.iter_subsystem():
i = max(i, int(ss))
return i + 1
def add_keyboard(self, usbname):
i = self.next_keyboard()
k = Keyboard(usbname, i, self.domain, lambda: self.del_keyboard(i))
self.add_subsystem(str(i), k)
print 'added keyboard', i, k.name()
def del_keyboard(self, i):
print 'removed keyboard', i
self.remove_subsystem(str(i))
agent.main(KeyboardAgent)
root.ensure_node(1).erase_children()
rig_list = root.ensure_node(255,6,2)
rigs = [ n.get_data().as_string() for n in rig_list.iter() ]
for ss in rigs:
print 'upgrading',ss
ssr = tools.root(ss)
ssr.ensure_node(1).erase_children()
return True
def postupgrade(self,tools,agent):
return self.upgrade_rigs(tools,tools.oldrversion(agent))
def upgrade_rigs(self,tools,v):
od = resource.user_resource_dir(resource.instrument_dir,version=v)
nd = resource.user_resource_dir(resource.instrument_dir)
for r in os.listdir(od):
nr = os.path.join(nd,r)
if not os.path.exists(nr):
print 'upgrading rig',r,'from',od,'to',nd
if not tools.upgrade_trunk(os.path.join(od,r),nr):
print 'upgrading rig',r,'failed'
return False
return True
agent.main(Manager,Upgrader)
def upgrade_2_0_to_3_0(self,tools,address):
plist = tools.root(address).get_node(4)
if plist is None:
return True
index = 1
for p in plist.iter():
priv = p.get_node(255,6)
if priv is None:
continue
p.ensure_node(1).set_data(priv.get_data())
p.setmetalong(const.meta_ordinal,index)
p.setmeta(const.meta_names,'parameter')
if index!=p.path[-1]:
plist.ensure_node(index).copy(p)
p.erase()
index += 1
return True
def upgrade_1_0_to_2_0(self,tools,address):
tools.root(address).ensure_node(99,255,const.meta_names).set_string('zzz')
return True
def upgrade_0_0_to_1_0(self,tools,address):
tools.root(address).ensure_node(99,255,const.meta_names).set_string('plugin')
return True
agent.main(Agent,Upgrader,gui=True)
self[5] = bundles.Output(2, False, names='sensor output 2')
self[6] = bundles.Output(3, False, names='sensor output 3')
self[7] = bundles.Output(4, False, names='sensor output 4')
self.__output = bundles.Splitter(self.__agent.domain, self[4], self[5], self[6], self[7])
self.__inputcookie = self.__agent.audiocubes.create_audiocube(self.__index, self.__output.cookie())
self.__input = bundles.VectorInput(self.__inputcookie, self.__agent.domain, signals=(1,2,3))
self[1] = atom.Atom(domain=domain.BoundedFloat(0,1), init=1.0, names='red input', policy=self.__input.local_policy(1,False))
self[2] = atom.Atom(domain=domain.BoundedFloat(0,1), init=1.0, names='green input', policy=self.__input.local_policy(2,False))
self[3] = atom.Atom(domain=domain.BoundedFloat(0,1), init=1.0, names='blue input', policy=self.__input.local_policy(3,False))
class Agent(agent.Agent):
def __init__(self, address, ordinal):
agent.Agent.__init__(self, signature=version, names='audiocubes', ordinal=ordinal)
self.domain = piw.clockdomain_ctl()
self[2] = bundles.Output(1, False, names='topology output')
self.__output = bundles.Splitter(self.domain, self[2])
self.audiocubes = audiocubes_native.audiocubes(self.domain, self.__output.cookie())
self[1] = atom.Atom(names='audiocubes')
for i in range(1,16):
self[1][i] = AudioCube(self,i)
agent.main(Agent)
#
# Copyright 2009 Eigenlabs Ltd. http://www.eigenlabs.com
#
# This file is part of EigenD.
#
# EigenD is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# EigenD is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with EigenD. If not, see <http://www.gnu.org/licenses/>.
#
from pi import agent
from keyboard_X import *
import os
"""
if os.getenv('PI_ALPHA2') is not None:
from keyboard2 import *
else:
from keyboard1 import *
"""
agent.main(KeyboardFactory, Upgrader)
trim[2] = val
if trim[1]<=trim[2]:
trim[3]=False
else:
trim[3]=True
a=trim[1]
trim[1]=trim[2]
trim[2]=a
self.set_trim(*trim)
def rpc_resolve_ideal(self,arg):
(type,arg) = action.unmarshal(arg)
print 'resolving',arg
if type=='midiport':
return self[5].resolve_name(' '.join(arg))
return action.marshal(())
def __chooseport(self,subj,arg):
print 'choose port',arg
print action.arg_objects(arg)[0]
(type,thing) = action.crack_ideal(action.arg_objects(arg)[0])
print type,thing
self[5].set_port(thing)
agent.main(Agent,gui=True)
i = max(i, int(ss))
return i + 1
def add_keyboard(self, usbname):
print 'add keyboard', usbname
i = self.next_keyboard()
k = Keyboard(usbname, i, self.domain, lambda: self.del_keyboard(i))
self.add_subsystem(str(i), k)
print 'added keyboard', i, k.name()
def del_keyboard(self, i):
print 'removed keyboard', i
self.remove_subsystem(str(i))
class Upgrader(upgrade.Upgrader):
def upgrade_0_0_to_1_0(self, tools, address):
return True
def upgrade_1_0_to_2_0(self, tools, address):
return True
def upgrade_2_0_to_3_0(self, tools, address):
for ss in tools.get_subsystems(address):
ssr = tools.root(ss)
ssr.rename(names='keyboard pico')
return True
agent.main(KeyboardAgent, Upgrader)
self.add_verb2(1,'set([],None,role(None,[abstract,matches([icon])]),role(of,[concrete,singular]),role(to,[ideal([~server,icon]),singular]) )',self.__do_icon)
self[2]=Icon(self)
def rpc_icon(self,arg):
return self[2].getIcon(arg)
def rpc_resolve_ideal(self,arg):
(type,arg) = action.unmarshal(arg)
print 'resolving',type,arg
if type=='icon':
return self[2].resolve_name(' '.join(arg))
return action.marshal(())
def __do_icon(self,a,b,c,d):
print 'icon_manager:__do_icon',a,b,c,d
(type,thing) = action.crack_ideal(action.arg_objects(d)[0])
print 'crack', type,thing
iconstring=self[2].getIconString(thing)
id=action.concrete_object(c)
print 'set the icon string on ',id, 'to',iconstring
rpc.invoke_rpc(id,'set_icon',logic.render_term(iconstring))
agent.main(Manager)
yield r
print 'rig load errors', r.args()[0]
def agent_presave(self, filename):
print 'starting presave', filename
return self.__inner_agent.save(self.rig_file(filename))
def agent_postload(self, filename):
rig_file = self.rig_file(filename)
agent.Agent.agent_postload(self, filename)
return self.__inner_agent.post_load(rig_file)
def agent_preload(self, filename):
agent.Agent.agent_preload(self, filename)
def server_opened(self):
agent.Agent.server_opened(self)
piw.tsd_server(paths.to_absolute('<eigend1>', self.inner_name),
self.__inner_agent)
self.__inner_agent.set_owner("'%s'" % paths.to_absolute(self.id()))
def close_server(self):
agent.Agent.close_server(self)
self.__inner_agent.close_server()
def on_quit(self):
self.__inner_agent.on_quit()
agent.main(OuterAgent, gui=True)
