def upgrade_5_0_to_6_0(self, tools, address):
root = tools.root(address)
root.ensure_node(2, 253, 254).set_long(2)
root.ensure_node(2, 253, 255.1)
root.ensure_node(2, 253, 255.3)
root.ensure_node(2, 253, 255.4).set_string('channel')
root.ensure_node(2, 253, 255.8).set_string('count')
root.ensure_node(2, 1, 255, 8).set_string('')
root.ensure_node(3, 253, 254).set_long(2)
root.ensure_node(3, 253, 255.1)
root.ensure_node(3, 253, 255.3)
root.ensure_node(3, 253, 255.4).set_string('channel')
root.ensure_node(3, 253, 255.8).set_string('count')
root.ensure_node(3, 1, 255, 8).set_string('')
pmap = []
for p in range(1, 17):
pnode = root.ensure_node(4, p)
for n in pnode.iter():
pbits = n.get_string().split(',')
pmap.append(logic.make_term('m', p, int(pbits[2]), 1.0))
pnode.ensure_node(255, 17)
# replace 0 tail time (meaning, plugin value) with a sensible default
n = root.ensure_node(10, 254)
if n.get_data().is_float() and n.get_data().as_float() == 0.0:
n.set_data(piw.makefloat(30.0, 0))
root.ensure_node(14, 255.1)
root.ensure_node(14, 255.3)
root.ensure_node(14, 255.8).set_string('midi input')
root.ensure_node(15, 255.1)
root.ensure_node(15, 255.3)
root.ensure_node(15, 255.8).set_string('midi output')
id_bits = root.ensure_node(255, 6).get_string().split('|')
plug_id = id_bits[0]
plug_name = id_bits[1] if len(id_bits) > 1 else ''
au_bits = plug_id[0:4], plug_id[4:8], plug_id[8:12]
what = ''
if au_bits[0] == 'aumu': what = 'Synths'
if au_bits[0] == 'aumf' or au_bits[0] == 'aufx': what = 'Effects'
if what:
desc = host_native.plugin_description(
'AudioUnit:%s/%s' % (what, ','.join(au_bits)), plug_name)
root.ensure_node(255, 6, 3).set_string(urllib.quote(desc.to_xml()))
root.ensure_node(255, 6,
4).set_data(root.get_node(9, 254).get_data())
root.ensure_node(255, 6, 5).set_string(
logic.render_term(logic.make_term('mapping', *tuple(pmap))))
root.remove(99)
return True
def disconnect(self, srcid, dstid, u, f, c):
proxy = self.__database.find_item(dstid)
if proxy:
if u == 0:
u = None
if f == '':
f = None
if c == '':
c = None
r = proxy.invoke_rpc(
'disconnect',
logic.render_term(logic.make_term('conn', u, None, srcid, f,
c)))
yield (r)
if not r.status():
print 'disconnect failed', srcid, dstid, u, f, c
self.__frontend.report_error(
'eigenD could not disconnect wire ' + srcid + ':' + dstid,
r.args()[0])
yield async .Coroutine.failure('rpc_disconnect failed')
yield async .Coroutine.success()
else:
print 'proxy not found'
def mimic_connections(self,fr,to,name,argstocopy=(0,1,3)):
from_input = self.get_node(*fr)
if from_input:
input_name = from_input.get_name()
input_connections = from_input.get_meta('master')
if input_connections and input_connections.is_string() and input_connections.as_string():
input_connections_parsed = logic.parse_termlist(input_connections.as_string())
output_connections = []
if input_connections_parsed:
for input_conn in input_connections_parsed:
upstream_addr,upstream_path = paths.breakid_list(input_conn.args[2])
upstream_root = self.tools.get_root(upstream_addr)
if upstream_root:
upstream_node = upstream_root
for n in upstream_path[:-1]:
c = upstream_node.get_node(n)
if c:
upstream_node = c
for c in upstream_node.iter():
if name == c.get_name():
conn = logic.make_term('conn',input_conn.args[0] if 0 in argstocopy else None,input_conn.args[1] if 1 in argstocopy else None,c.id(),input_conn.args[3] if 3 in argstocopy else None)
output_connections.append(conn)
if len(output_connections):
conn_txt = logic.render_termlist(output_connections)
c = self.ensure_node(*to)
c.set_meta_string('master', conn_txt)
print 'connected',name,'for',c.id(),'from',conn_txt
def rpc_dinfo(self, a):
path = logic.parse_clause(a)
l = []
l.append(('dinfo_id', self.__selected or path))
if self.__selected:
x = self.read_script(self.__selected)
if x:
(n, d, sc, rn) = x
if rn:
l.append(('name', "%s (%s)" % (n, rn)))
else:
l.append(('name', n))
l.append(('', ''))
for (i, di) in enumerate(d):
l.append(('description' if i == 0 else '', di))
if self.__status:
l.append(('', ''))
l.append(('status', self.__status))
return logic.render_term(logic.make_term('keyval', tuple(l)))
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='labeler',
ordinal=ordinal)
self.domain = piw.clockdomain_ctl()
self[1] = atom.Atom(
domain=domain.Aniso(hints=(logic.make_term('continuous'), )),
names='controller output',
policy=atom.readonly_policy())
self[2] = atom.Atom(domain=domain.String(),
init='Label',
names='label category',
policy=atom.default_policy(self.__set_category))
self[3] = atom.Atom(domain=domain.String(),
init='',
names='label',
policy=atom.default_policy(self.__set_label))
self.ctl_functor = piw.functor_backend(1, True)
self.ctl_input = bundles.VectorInput(self.ctl_functor.cookie(),
self.domain,
signals=(1, ))
self[4] = atom.Atom(domain=domain.Aniso(),
policy=self.ctl_input.vector_policy(1, False),
names='controller input')
self.ctl_functor.set_functor(
piw.pathnull(0),
utils.make_change_nb(
piw.slowchange(utils.changify(self.__controller_input))))
self.__ctl = []
def attach(self,*args):
c = []
for i,a in enumerate(args):
(id,ch) = a.args
c.append(logic.make_term('conn',i,self.__key.index,id,ch))
self[1].set_connections(logic.render_termlist(c))
def destroy(self):
# remove this widget from the targets controllers
address = self.get_property_string('target-id')
myrid = paths.to_relative(self.id(), scope=paths.id2scope(address))
cs = logic.render_term(
logic.make_term('conn', None, None, myrid, None, 'ctl'))
if address != '':
rpc.invoke_rpc(address, 'disconnect', cs)
def __init__(self, source, sample_rate, buffer_size, hints=()):
Domain.__init__(self, hints)
self.sample_rate = int(sample_rate)
self.buffer_size = int(buffer_size)
self.source = source
self.name = str(
logic.make_term('iso', self.source, self.sample_rate,
self.buffer_size, hints))
def upgrade_1_0_1_to_1_0_2(self, tools, address):
# assign canonical ordinals to agents
n2 = tools.get_root(address).get_node(2)
old_plugins = logic.parse_termlist(
n2.get_data().as_dict_lookup('agents').as_string())
plugs_by_type = {}
for old_term in old_plugins:
(paddress, plugin, pversion, pcversion) = old_term.args
pmeta = tools.get_root(paddress).get_data()
pname = pmeta.as_dict_lookup('name')
pordinal = pmeta.as_dict_lookup('ordinal')
if not pname.is_string() or not pname.as_string():
pname = plugin
else:
pname = pname.as_string()
pname = pname.split()
try:
pname.remove('agent')
except:
pass
pname = '_'.join(pname)
if not pordinal.is_long() or not pordinal.as_long():
pordinal = 0
else:
pordinal = pordinal.as_long()
plugs_by_type.setdefault(plugin, []).append(
[paddress, plugin, pversion, pcversion, pname, pordinal, 0])
plugins = []
for (ptype, plist) in plugs_by_type.iteritems():
ords_used = set()
max_ord = 0
for p in plist:
if ptype == p[4] and p[5] and p[5] not in ords_used:
p[6] = p[5]
ords_used.add(p[5])
max_ord = max(max_ord, p[5])
for p in plist:
if not p[6]:
max_ord += 1
p[6] = max_ord
new_term = logic.make_term('a', p[0], p[1], p[2], p[3], p[6])
plugins.append(new_term)
n2.set_data(
piw.dictset(piw.dictnull(0), 'agents',
piw.makestring(logic.render_termlist(plugins), 0)))
def setup(self,address,name):
self.set_property_long('ref-count',1)
self.set_property_string('target-name',name)
self.set_property_string('target-id',address)
cs = logic.render_term(logic.make_term('ctl',self.id(),None))
if address!='':
return rpc.invoke_rpc(address,'control',cs)
else:
return False
def setup(self, address, name):
myrid = paths.to_relative(self.id(), scope=paths.id2scope(address))
self.set_property_long('ref-count', 1)
self.set_property_string('target-name', name)
self.set_property_string('target-id', address)
cs = logic.render_term(
logic.make_term('conn', None, None, myrid, None, 'ctl'))
if address != '':
return rpc.invoke_rpc(address, 'connect', cs)
else:
return False
def rpc_lexicon(self,arg):
l = self.database.get_lexicon()
t = l.get_timestamp()
d = [ x for x in l.lexicon_iter() ]
nd = len(d)
i = int(arg)
if i<0 or i>=nd:
return async.success('%s:%d:' % (t,nd))
d = d[i:i+100]
ds = logic.render_termlist([logic.make_term(e,m,c) for (e,(m,c)) in d])
return '%s:%d:%s' % (t,nd,ds)
def move_connection(self,old_id,new_id):
print self.id(),'replacing',old_id,'with',new_id
conn = self.get_meta('master')
if conn and conn.is_string() and conn.as_string():
conn_parsed = logic.parse_termlist(conn.as_string())
conn_replaced = []
for c in conn_parsed:
if c.args[2] == old_id:
conn_replaced.append(logic.make_term(c.pred,c.args[0],c.args[1],new_id,c.args[3]))
else:
conn_replaced.append(c)
conn_new = logic.render_termlist(conn_replaced)
self.set_meta_string('master',conn_new)
print self.id(),'replaced',conn,'with',conn_new
def upgrade_plugins_v0(tools, address):
n2 = tools.root(address).get_node(2)
for n in n2.iter(extension=253):
n3 = n.get_node(255, 6)
old_term = logic.parse_term(n3.get_string())
(address, plugin, version, cversion) = old_term.args
map = tools.mapping.get(address)
if map:
(nplugin, nversion, ncversion) = map[1].split(':')
new_term = logic.make_term(old_term.pred, address, plugin,
nversion, ncversion)
n3.set_string(str(new_term))
return True
def __init__(self, signal, iso, continuous=False, **kwds):
assert 'domain' not in kwds
self.signal = signal
self.iso = iso
if continuous:
self.hints = (logic.make_term('continuous'),)
else:
self.hints = ()
if iso:
dom = domain.Null(hints=self.hints)
else:
dom = domain.Aniso(hints=self.hints)
atom.Atom.__init__(self, policy=BundleOutputPolicy(), domain=dom, **kwds)
def create_agent(self, agent, ordinal):
print 'backend create agent', agent, ordinal
plugin_def = logic.make_term('module', agent, ordinal)
r = rpc.invoke_rpc(self.__database.to_usable_id('<eigend1>'),
'addmodule', logic.render_term(plugin_def))
yield (r)
if not r.status():
print 'addmodule failed', agent, ordinal, r.args()[0]
self.__frontend.report_error(
'eigenD could not create agent ' + agent + ' ' + str(ordinal),
r.args()[0])
yield async .Coroutine.failure('rpc_addmodule failed')
yield async .Coroutine.success()
def upgrade_1_0_0_to_1_0_1(self, tools, address):
plugins = []
n2 = tools.get_root(address).get_node(2)
for n in n2.iter(extension=253, exclude=[254, 255]):
n3 = n.get_node(255)
old_term = logic.parse_term(n3.get_data().as_string())
(address, plugin, version, cversion) = old_term.args
ncversion = tools.newcversion(address)
nversion = tools.newrversion(address)
nplugin = tools.canonical_name(address)
new_term = logic.make_term('a', address, nplugin, nversion,
ncversion)
plugins.append(new_term)
n2.erase_children()
n2.set_data(
piw.dictset(piw.dictnull(0), 'agents',
piw.makestring(logic.render_termlist(plugins), 0)))
def upgrade_plugins_v1(tools, address):
n2 = tools.get_root(address).get_node(2)
old_plugins = logic.parse_termlist(
n2.get_data().as_dict_lookup('agents').as_string())
new_plugins = []
for old_term in old_plugins:
(address, plugin, version, cversion, ordinal) = old_term.args
ncversion = tools.newcversion(address)
nversion = tools.newrversion(address)
nplugin = tools.canonical_name(address)
new_term = logic.make_term(old_term.pred, address, nplugin, nversion,
ncversion, ordinal)
new_plugins.append(new_term)
n2.set_data(
piw.dictset(piw.dictnull(0), 'agents',
piw.makestring(logic.render_termlist(new_plugins), 0)))
def __substitute_connection(self, tgt, old_id, new_id):
(s, p) = paths.breakid_list(tgt)
root = self.root(s)
atom = root.get_node(*p)
if atom is None: return
conn = atom.get_node(255, 2)
if conn is None: return
old_conn = logic.parse_clauselist(conn.get_string_default(''))
new_conn = []
for c in old_conn:
if c.args[2] == old_id:
new_conn.append(
logic.make_term(c.pred, c.args[0], c.args[1], new_id,
c.args[3]))
else:
new_conn.append(c)
conn.set_string(logic.render_termlist(new_conn))
def __init__(self, address, ordinal):
agent.Agent.__init__(self,
signature=version,
names='audio unit',
container=100,
ordinal=ordinal)
self.__state = PluginState(self.__plugin_state_loaded)
self.set_private(self.__state)
self.__browser = PluginBrowser(self)
self.__domain = piw.clockdomain_ctl()
self.__audio_output = audio.AudioOutput(bundles.Splitter(
self.__domain),
1,
2,
names='channels')
self.__audio_output_channels = audio.AudioChannels(self.__audio_output)
self.__midi_output = bundles.Splitter(self.__domain)
self.__observer = PluginObserver(self.__state, self)
self.host = host_native.plugin_instance(
self.__observer, self.__domain, self.__audio_output.cookie(),
self.__midi_output.cookie(),
utils.statusify(self.__window_state_changed))
self.parameter_list = inputparameter.List(self.host,
self.host.clock_domain(),
self.verb_container())
self.__audio_input = audio.AudioInput(bundles.ScalarInput(
self.host.audio_input_cookie(),
self.__domain,
signals=range(1, 65)),
1,
2,
names='channels')
self.__audio_input_channels = audio.AudioChannels(self.__audio_input)
self.__key_input = bundles.VectorInput(
self.host.midi_from_belcanto_cookie(),
self.__domain,
signals=(1, 2))
self.__midi_input = bundles.ScalarInput(
self.host.midi_aggregator_cookie(), self.__domain, signals=(1, ))
self.__metronome_input = bundles.ScalarInput(
self.host.metronome_input_cookie(),
self.__domain,
signals=(1, 2, 3, 4))
self.host.set_bypassed(True)
# plugin browser
self[1] = self.__browser
# audio output
self[2] = atom.Atom(names='audio outputs')
self[2][1] = self.__audio_output
self[2][2] = self.__audio_output_channels
# audio input
self[3] = atom.Atom(names='audio inputs')
self[3][1] = self.__audio_input
self[3][2] = self.__audio_input_channels
# parameter mapping
self[4] = self.parameter_list
# metronome input
self[5] = atom.Atom(names='metronome inputs')
self[5][1] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
1, False),
names='song beat input')
self[5][2] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
2, False),
names='running input')
self[5][3] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
3, False),
names='tempo input')
self[5][4] = atom.Atom(domain=domain.Aniso(),
policy=self.__metronome_input.nodefault_policy(
4, False),
names='bar beat input')
# kbd/controller inputs
self[6] = atom.Atom(names='musical inputs')
self[6][1] = atom.Atom(domain=domain.Aniso(),
policy=self.__key_input.vector_policy(1, False),
names='pressure input')
self[6][2] = atom.Atom(domain=domain.Aniso(),
policy=self.__key_input.merge_nodefault_policy(
2, False),
names='frequency input')
# midi channel
self[7] = atom.Atom(domain=domain.BoundedInt(0, 20),
init=0,
names='midi channel',
policy=atom.default_policy(self.set_midi_channel))
# velocity curve control
vel = (T('stageinc', 0.1), T('inc', 0.1), T('biginc',
1), T('control', 'updown'))
self[8] = atom.Atom(names='velocity curve controls')
self[8][1] = atom.Atom(domain=domain.BoundedInt(1, 1000),
init=4,
names='velocity sample',
policy=atom.default_policy(
self.__set_velocity_samples))
self[8][2] = atom.Atom(domain=domain.BoundedFloat(0.1, 10, hints=vel),
init=4,
names='velocity curve',
policy=atom.default_policy(
self.__set_velocity_curve))
self[8][3] = atom.Atom(domain=domain.BoundedFloat(0.1, 10, hints=vel),
init=4,
names='velocity scale',
policy=atom.default_policy(
self.__set_velocity_scale))
self[9] = atom.Atom(domain=domain.Bool(),
init=True,
names='tail time enable',
policy=atom.default_policy(
self.__set_tail_time_enabled))
self[10] = atom.Atom(domain=domain.BoundedFloatOrNull(0, 100000),
init=10,
names='tail time',
policy=atom.default_policy(self.__set_tail_time))
self[11] = atom.Atom(domain=domain.BoundedInt(1, 16),
init=1,
names='minimum channel',
policy=atom.default_policy(self.set_min_channel))
self[12] = atom.Atom(domain=domain.BoundedInt(1, 16),
init=16,
names='maximum channel',
policy=atom.default_policy(self.set_max_channel))
# other global settings inputs
self[20] = atom.Atom(domain=domain.BoundedInt(0, 100),
init=0,
names="minimum decimation",
policy=atom.default_policy(
self.set_min_decimation))
self[21] = atom.Atom(domain=domain.Bool(),
init=True,
names="notes enable",
policy=atom.default_policy(self.set_midi_notes))
self[22] = atom.Atom(domain=domain.Bool(),
init=True,
names="pitch bend enable",
policy=atom.default_policy(
self.set_midi_pitchbend))
self[23] = atom.Atom(domain=domain.Bool(),
init=False,
names="high resolution velocity enable",
policy=atom.default_policy(
self.set_midi_hires_velocity))
self[24] = atom.Atom(domain=domain.BoundedInt(0, 96),
init=1,
names="pitch bend range upper",
policy=atom.default_policy(self.set_pitchbend_up))
self[25] = atom.Atom(domain=domain.BoundedInt(0, 96),
init=1,
names="pitch bend range lower",
policy=atom.default_policy(
self.set_pitchbend_down))
# status output to drive the talker lights
self[13] = bundles.Output(1, False, names='status output')
self.light_output = bundles.Splitter(self.__domain, self[13])
self.lights = piw.lightsource(piw.change_nb(), 0,
self.light_output.cookie())
self.lights.set_size(2)
self.set_light(1, True)
self.set_light(2, False)
# midi I/O
# midi input
self[14] = atom.Atom(domain=domain.Aniso(),
policy=self.__midi_input.nodefault_policy(
1, False),
names='midi input')
# midi output
self[15] = self.__midi_output.add_output(
bundles.Output(1, False, names='midi output'))
# controller input/output to add labels
self[16] = atom.Atom(
domain=domain.Aniso(hints=(logic.make_term('continuous'), )),
names='controller output',
policy=atom.readonly_policy())
self[17] = atom.Atom(domain=domain.String(),
init='Plugin',
names='label category',
policy=atom.default_policy(self.__set_category))
self[18] = atom.Atom(domain=domain.String(),
init='',
names='label',
policy=atom.default_policy(self.__set_label))
self.ctl_functor = piw.functor_backend(1, True)
self.ctl_input = bundles.VectorInput(self.ctl_functor.cookie(),
self.__domain,
signals=(1, ))
self[19] = atom.Atom(domain=domain.Aniso(),
policy=self.ctl_input.vector_policy(1, False),
names='controller input')
self.ctl_functor.set_functor(
piw.pathnull(0),
utils.make_change_nb(
piw.slowchange(utils.changify(self.__controller_input))))
self.__ctl = []
# verbs
self.add_verb2(1, 'show([],None)', callback=self.__show)
self.add_verb2(2, 'show([un],None)', callback=self.__unshow)
self.add_verb2(3, 'close([],None)', callback=self.__close)
self.add_verb2(4,
'bypass([toggle],None)',
callback=self.__tog_bypass,
status_action=self.__status_bypass)
self.add_verb2(5,
'show([toggle],None)',
callback=self.__tog_show,
status_action=self.__status_show)
self.add_verb2(6,
'open([],None,role(None,[abstract]))',
callback=self.__open)
self.add_verb2(7,
'scan([],None)',
callback=self.__browser.refresh_plugin_list)
self.add_verb2(8, 'bypass([],None)', callback=self.__bypass)
self.add_verb2(9, 'bypass([un],None)', callback=self.__unbypass)
# control change
self.add_verb2(
10,
'set([],~a,role(None,[matches([midi,program])]),role(to,[numeric]))',
create_action=self.__set_program_change)
self.add_verb2(
11,
'set([],~a,role(None,[matches([midi,bank])]),role(to,[numeric]))',
create_action=self.__set_bank_change)
self.add_verb2(
12,
'set([],~a,role(None,[mass([midi,controller])]),role(to,[numeric]))',
create_action=self.__set_midi_control)
self.set_ordinal(ordinal)
def phase2_1_0_1(self,tools,address):
print 'upgrading plugin host',address
root = tools.get_root(address)
freq_input = root.ensure_node(6,2)
scaler_conn = freq_input.get_master()
if not scaler_conn: return
scaler_addr = paths.id2server(scaler_conn[0])
scaler_root = tools.get_root(scaler_addr)
if not scaler_root: return
scaler_type = scaler_root.get_meta_string('plugin')
if scaler_type != 'scaler': return
print 'scaler is',scaler_addr
scaler_pressure_input = scaler_root.get_node(4,2)
recorder_conn = scaler_pressure_input.get_master()
if not recorder_conn: return
recorder_addr = paths.id2server(recorder_conn[0])
recorder_root = tools.get_root(recorder_addr)
if not recorder_root: return
recorder_type = recorder_root.get_meta_string('plugin')
if recorder_type != 'recorder': return
print 'recorder is',recorder_addr
canonical_names = {}
available_sources = {}
blocked_sources = []
available_sources['pressure'] = paths.makeid_list(scaler_addr,1,2)
available_sources['roll'] = paths.makeid_list(scaler_addr,1,3)
available_sources['yaw'] = paths.makeid_list(scaler_addr,1,4)
for (k,v) in available_sources.items():
canonical_names[v] = k
for i in range(5,15):
recorder_input = recorder_root.get_node(1,i)
if recorder_input:
input_name = recorder_input.get_name()
input_conn = recorder_input.get_master()
output_id = paths.makeid_list(recorder_addr,2,i)
if not input_conn:
blocked_sources.append(output_id)
print 'unavailable input',output_id
continue
upstream_addr,upstream_path = paths.breakid_list(input_conn[0])
upstream_root = tools.get_root(upstream_addr)
if not upstream_root: continue
upstream = upstream_root.get_node(*upstream_path)
if not upstream: continue
upstream_name = upstream.get_name().split()
if 'output' in upstream_name: upstream_name.remove('output')
upstream_name = ' '.join(upstream_name)
if upstream_name == 'controller': continue
print 'recorder output',i,'at',output_id,'called',input_name,'connected to',upstream_name
available_sources[upstream_name] = output_id
canonical_names[output_id] = upstream_name
for n,id in available_sources.items():
print 'source',n,'at',id
current_parms = {}
unused_parms = range(1,16)
existing_names = []
for k in range(1,16):
parm_node = root.get_node(4,k)
parm_name = parm_node.get_name()
if not parm_node: continue
parm_conn = parm_node.get_master()
if not parm_conn: continue
parm_master = parm_conn[0]
if parm_master in canonical_names:
parm_name = canonical_names[parm_master]
else:
split_name = parm_name.split()
kstr = str(k)
if split_name and split_name[-1]==kstr:
parm_name = ' '.join(split_name[:-1])
if parm_master not in current_parms:
current_parms[parm_master] = (k,parm_name)
existing_names.append(parm_name)
print 'existing source',k,'called',parm_name,'connected to',parm_master
unused_parms.remove(k)
for pname,pmaster in available_sources.items():
if pmaster not in current_parms and pname not in existing_names:
if unused_parms:
k = unused_parms[0]
unused_parms = unused_parms[1:]
current_parms[pmaster] = (k,pname)
print 'adding available source',k,pname,'from',pmaster
print 'parameter map:'
for pmaster,(k,pname) in current_parms.items():
print 'parameter',k,'called',pname,'connected to',pmaster
for k in range(1,17):
parm_node = root.ensure_node(4,k)
parm_node.set_meta('master',piw.data())
parm_node.set_name('parameter %d' % k)
for pmaster,(k,pname) in current_parms.items():
if pmaster in blocked_sources:
continue
conn = logic.make_term('conn',None,None,pmaster,None)
conn_txt = logic.render_term(conn)
parm_node = root.ensure_node(4,k)
parm_node.set_meta_string('master',conn_txt)
parm_node.set_name(pname)
print 'connected',parm_node.id(),'to',conn_txt,'called',pname,'parameter',k
conn = logic.make_term('conn',None,None,paths.makeid_list(scaler_addr,1,2),None)
conn_txt = logic.render_term(conn)
parm_node = root.ensure_node(4,16)
parm_node.set_meta_string('master',conn_txt)
parm_node.set_name('key position')
local_map = {}
self.check_midi_controller(root,(6,4),7,current_parms,local_map) # volume
self.check_midi_controller(root,(6,5),1,current_parms,local_map) # modwheel
self.check_midi_controller(root,(6,6),10,current_parms,local_map) # pan
self.check_midi_controller(root,(6,7),4,current_parms,local_map) # foot pedal
self.check_midi_controller(root,(6,8),11,current_parms,local_map) # expression
self.check_midi_controller(root,(6,9),130,current_parms,local_map) # channel pressure
self.check_midi_controller(root,(6,10),128,current_parms,local_map) # poly pressure
self.check_midi_controller(root,(6,11),131,current_parms,local_map) # pitch bend
self.check_midi_controller(root,(6,12),64,current_parms,local_map) # sustain pedal
print 'local map',local_map
map_node = root.ensure_node(255,5)
map_data = map_node.get_data()
map_list = []
if map_data.is_string() and map_data.as_string() and map_data.as_string() != '[]':
print 'map data',map_data.as_string()
map_term = logic.parse_term(map_data.as_string())
map_list = map_term.args
bits_14 = set([0x07,0x01,0x0a,0x04,0x0b])
for cc,p in local_map.items():
ccl = (cc+32) if cc<32 else -1
res = const.resolution_bits_7 if cc not in bits_14 else const.resolution_bits_14
map_list=list(map_list)
map_list.append(logic.make_term('c',p,cc,1.0,0,0,1.0,True,const.scope_pernote,res,ccl))
map_term = logic.make_term('mapping',*map_list)
map_node.set_data(piw.makestring(logic.render_term(map_term),0))
def phase2_1_0_2(self, tools, address):
print 'upgrading converter', address
root = tools.get_root(address)
freq_input = root.ensure_node(2, 2)
scaler_conn = freq_input.get_master()
if not scaler_conn: return
scaler_addr = paths.id2server(scaler_conn[0])
scaler_root = tools.get_root(scaler_addr)
if not scaler_root: return
scaler_type = scaler_root.get_meta_string('plugin')
if scaler_type != 'scaler': return
print 'scaler is', scaler_addr
scaler_pressure_input = scaler_root.get_node(4, 2)
recorder_conn = scaler_pressure_input.get_master()
if not recorder_conn: return
recorder_addr = paths.id2server(recorder_conn[0])
recorder_root = tools.get_root(recorder_addr)
if not recorder_root: return
recorder_type = recorder_root.get_meta_string('plugin')
if recorder_type != 'recorder': return
print 'recorder is', recorder_addr
available_sources = {}
available_sources['pressure'] = paths.makeid_list(scaler_addr, 1, 2)
available_sources['roll'] = paths.makeid_list(scaler_addr, 1, 3)
available_sources['yaw'] = paths.makeid_list(scaler_addr, 1, 4)
available_sources['key position'] = paths.makeid_list(
scaler_addr, 1, 2)
for i in range(5, 15):
recorder_input = recorder_root.get_node(1, i)
if recorder_input:
input_name = recorder_input.get_name()
input_conn = recorder_input.get_master()
if not input_conn: continue
upstream_addr, upstream_path = paths.breakid_list(
input_conn[0])
upstream_root = tools.get_root(upstream_addr)
if not upstream_root: continue
upstream = upstream_root.get_node(*upstream_path)
if not upstream: continue
upstream_name = upstream.get_name().split()
if 'output' in upstream_name: upstream_name.remove('output')
upstream_name = ' '.join(upstream_name)
if upstream_name == 'controller': continue
output_id = paths.makeid_list(recorder_addr, 2, i)
print 'recorder output', i, 'at', output_id, 'called', input_name, 'connected to', upstream_name
available_sources[upstream_name] = output_id
for n, id in available_sources.items():
print 'source', n, 'at', id
desired_sources = {
'pressure': 1,
'roll': 2,
'yaw': 3,
'breath': 4,
'strip position 1': 5,
'absolute strip 1': 6,
'strip position 2': 7,
'absolute strip 2': 8,
'pedal 1': 9,
'pedal 2': 10,
'pedal 3': 11,
'pedal 4': 12,
'key position': 16,
}
active_sources = {}
for k in range(1, 17):
parm_node = root.ensure_node(12, k)
parm_node.set_meta('master', piw.data())
parm_node.set_name('parameter %d' % k)
for k, v in desired_sources.items():
if k in available_sources:
conn = logic.make_term('conn', None, None,
available_sources[k], None)
conn_txt = logic.render_term(conn)
parm_node = root.ensure_node(12, v)
parm_node.set_meta_string('master', conn_txt)
parm_node.set_name(k)
if v < 16: # dont map anything to key position
active_sources[available_sources[k]] = v
print 'connected', parm_node.id(), 'to', conn_txt, 'called', k
print 'checking for midi output', active_sources
my_controller = None
all_agents = tools.get_agents()
for agent in all_agents:
agent_root = tools.get_root(agent)
if not agent_root: continue
agent_type = agent_root.get_meta_string('plugin')
if agent_type != 'midi_output': continue
agent_midi_input = agent_root.get_node(2)
if not agent_midi_input: continue
agent_conn = [
paths.id2server(i) for i in agent_midi_input.get_master()
]
print agent, 'is midi output', agent_conn, root.id()
if root.id() not in agent_conn: continue
print 'my midi output', agent
for i in agent_conn:
controller_root = tools.get_root(i)
controller_type = controller_root.get_meta_string('plugin')
if controller_type != 'midi_controller': continue
my_controller = controller_root
break
if my_controller: break
if not my_controller: return
cc1 = self.get_midi_cc(my_controller, 1)
cc2 = self.get_midi_cc(my_controller, 2)
cc3 = self.get_midi_cc(my_controller, 3)
cc4 = self.get_midi_cc(my_controller, 4)
print 'midi controller', my_controller.id(), cc1, cc2, cc3, cc4
global_map = {}
self.check_midi_controller(my_controller, (2, 1), 7, active_sources,
global_map) # volume
self.check_midi_controller(my_controller, (2, 2), 1, active_sources,
global_map) # modwheel
self.check_midi_controller(my_controller, (2, 3), 10, active_sources,
global_map) # pan
self.check_midi_controller(my_controller, (2, 4), 4, active_sources,
global_map) # foot pedal
self.check_midi_controller(my_controller, (2, 5), 11, active_sources,
global_map) # EXPRESSION
self.check_midi_controller(my_controller, (2, 6), 130, active_sources,
global_map) # channel pressure
self.check_midi_controller(my_controller, (2, 7), 131, active_sources,
global_map) # pitch bend
self.check_midi_controller(my_controller, (2, 8), 64, active_sources,
global_map) # sustain pedal
self.check_midi_controller(my_controller, (2, 9), cc1, active_sources,
global_map)
self.check_midi_controller(my_controller, (2, 10), cc2, active_sources,
global_map)
self.check_midi_controller(my_controller, (2, 11), cc3, active_sources,
global_map)
self.check_midi_controller(my_controller, (2, 12), cc4, active_sources,
global_map)
local_map = {}
self.check_midi_controller(root, (2, 4), 7, active_sources,
local_map) # volume
self.check_midi_controller(root, (2, 5), 1, active_sources,
local_map) # modwheel
self.check_midi_controller(root, (2, 6), 10, active_sources,
local_map) # pan
self.check_midi_controller(root, (2, 7), 4, active_sources,
local_map) # foot pedal
self.check_midi_controller(root, (2, 8), 11, active_sources,
local_map) # expression
self.check_midi_controller(root, (2, 9), 130, active_sources,
local_map) # channel pressure
self.check_midi_controller(root, (2, 10), 128, active_sources,
local_map) # poly pressure
self.check_midi_controller(root, (2, 11), 131, active_sources,
local_map) # pitch bend
self.check_midi_controller(root, (2, 12), 64, active_sources,
local_map) # sustain pedal
print 'per key mappings', local_map
print 'global mappings', global_map
map_node = root.ensure_node(255, 1)
map_data = map_node.get_data()
map_list = []
if map_data.is_string() and map_data.as_string(
) and map_data.as_string() != '[]':
print 'map data', map_data.as_string()
map_term = logic.parse_term(map_data.as_string())
map_list = map_term.args
bits_14 = set([0x07, 0x01, 0x0a, 0x04, 0x0b])
for cc, p in local_map.items():
ccl = (cc + 32) if cc < 32 else -1
res = const.resolution_bits_7 if cc not in bits_14 else const.resolution_bits_14
map_list = list(map_list)
map_list.append(
logic.make_term('c', p, cc, 1.0, 0, 0, 1.0, True,
const.scope_pernote, ccl, ccl))
for cc, p in global_map.items():
ccl = (cc + 32) if cc < 32 else -1
res = const.resolution_bits_7 if cc not in bits_14 else const.resolution_bits_14
map_list.append(
logic.make_term('c', p, cc, 1.0, 0, 0, 1.0, True,
const.scope_global, ccl, ccl))
map_term = logic.make_term('mapping', *map_list)
map_node.set_data(piw.makestring(logic.render_term(map_term), 0))
def create_echo(self,trigger,text):
print 'create echo for',text,'trigger',trigger
self.verb_defer(30,trigger,trigger,None,(logic.make_term('abstract',tuple(text.split(' '))),))
def destroy(self):
# remove this widget from the targets controllers
cs = logic.render_term(logic.make_term('ctl',self.id(),None))
address = self.get_property_string('target-id')
if address!='':
rpc.invoke_rpc(address,'uncontrol',cs)
