def __init__(self, *, channel_count=2):
self._channel_count = channel_count
self._scenes = SceneContainer()
self._scenes._parent = self
self._server = None
self._soloed_tracks = set()
self._transport = Transport()
self._tracks = TrackContainer()
self._return_tracks = TrackContainer(name="return track container")
self._master_track = Track(
device_types=(DeviceType.AUDIO, ),
channel_count=channel_count,
name="master track",
)
self._cue_track = Track(
device_types=(DeviceType.AUDIO, ),
channel_count=channel_count,
name="cue track",
)
UniqueTreeTuple.__init__(
self,
children=[
self._transport,
self._tracks,
self._return_tracks,
self._master_track,
self._cue_track,
],
)
self._node = Group(children=[_.node for _ in self], name="application")
def recurse(query_tree_node, node):
for query_tree_child in query_tree_node.children:
if isinstance(query_tree_child, QueryTreeGroup):
group = Group()
group._register_with_local_server(
node_id=query_tree_child.node_id, server=self)
node._children.append(group)
recurse(query_tree_child, group)
elif isinstance(query_tree_child, QueryTreeSynth):
synth = Synth()
synth._register_with_local_server(
node_id=query_tree_child.node_id, server=self)
node._children.append(synth)
for query_tree_control in query_tree_child.children:
pass
def recurse(query_tree_node, node):
for query_tree_child in query_tree_node.children:
if isinstance(query_tree_child, QueryTreeGroup):
group = Group()
group._register_with_local_server(
node_id=query_tree_child.node_id, server=self
)
node._children.append(group)
recurse(query_tree_child, group)
elif isinstance(query_tree_child, QueryTreeSynth):
synth = Synth()
synth._register_with_local_server(
node_id=query_tree_child.node_id, server=self
)
node._children.append(synth)
for query_tree_control in query_tree_child.children:
pass
def _handle_node_info_response(self, response):
from supriya.commands import NodeAction
from supriya.realtime import Group, Synth
with self._lock:
node_id = response.node_id
node = self._nodes.get(node_id)
if node is not None:
node._handle_response(response)
elif response.action == NodeAction.NODE_CREATED:
if response.is_group:
node = Group()
else:
node = Synth()
node._register_with_local_server(
server=self,
node_id=response.node_id,
)
parent = self._nodes[response.parent_group_id]
node._set_parent(parent)
if response.previous_node_id:
previous_child = self._nodes[response.previous_node_id]
index = parent.index(previous_child)
parent._children.insert(index + 1, node)
else:
parent._children.append(node)
def _apply_local(self, server):
from supriya.realtime import Group, Node
for item in self.items:
if isinstance(item.node_id, Group):
node_id = None
group = item.node_id
else:
node_id = item.node_id
group = Group()
if isinstance(item.target_node_id, Node):
target_node = item.target_node_id
else:
target_node = server._nodes[item.target_node_id]
group._register_with_local_server(
server,
node_id=node_id,
node_id_is_permanent=group.node_id_is_permanent)
target_node._move_node(add_action=item.add_action, node=group)
def __init__(self, channel_count=2):
RackDevice.__init__(self)
self._levels = dict(output=None)
self._osc_callbacks = dict(output=None)
self._bus_group = BusGroup.audio(bus_count=channel_count)
self._chains = ChainContainer(chain_class=AudioChain)
self._receive = RackReceive()
UniqueTreeTuple.__init__(self, children=[self.chains, self.receive])
self._rack_output_synth = Synth(
synthdef=build_rack_output_synthdef(channel_count), name="rack output"
)
self._node = Group(
children=[self.chains.node, self.rack_output_synth], name="audio rack"
)
def __init__(self, channel_count=2):
Chain.__init__(self)
self._levels = dict(prefader=None, postfader=None)
self._osc_callbacks = dict(active=None, prefader=None, postfader=None)
self._bus_group = BusGroup.audio(bus_count=channel_count)
self._output_synth = Synth(synthdef=build_chain_output_synthdef(channel_count))
self._sends = SendManager()
self._mutate([self.devices, self.sends])
self._node = Group(
children=[
self.devices.node,
self.sends.pre_fader_group,
self.output_synth,
self.sends.post_fader_group,
],
name="instrument chain",
)
def __init__(self, *, device_types=None, channel_count=2, name=None):
DawNode.__init__(self)
self._device_types = device_types or (
DeviceType.MIDI,
DeviceType.INSTRUMENT,
DeviceType.AUDIO,
)
self._bus_group = BusGroup.audio(bus_count=channel_count)
self._devices = DeviceContainer(device_types=self.device_types)
self._input_bus_group = BusGroup.audio(bus_count=channel_count)
self._input_synth = Synth(
synthdef=build_track_input_synthdef(channel_count))
self._levels = dict(input=None, prefader=None, postfader=None)
self._osc_callbacks = dict(input=None, prefader=None, postfader=None)
self._output_synth = Synth(
synthdef=build_track_output_synthdef(channel_count))
self._receive = TrackReceive()
self._sends = SendManager()
self._slots = ClipSlotContainer()
self._slots._parent = self
self._is_active = True
self._is_muted = False
self._is_soloed = False
self._soloed_tracks = set()
UniqueTreeTuple.__init__(
self, children=[self.receive, self.devices, self.sends])
self._node = Group(
children=[
self.input_synth,
self.devices.node,
self.sends.pre_fader_group,
self.output_synth,
self.sends.post_fader_group,
],
name=name
or " ".join(_.lower() for _ in delimit_words(type(self).__name__)),
)
def _handle_node_info_response(self, response):
from supriya.realtime import Group, Synth
with self._lock:
node_id = response.node_id
node = self._nodes.get(node_id)
if node is not None:
node._handle_response(response)
elif response.action == NodeAction.NODE_CREATED:
if response.is_group:
node = Group()
else:
node = Synth()
node._register_with_local_server(server=self, node_id=response.node_id)
parent = self._nodes[response.parent_group_id]
node._set_parent(parent)
if response.previous_node_id:
previous_child = self._nodes[response.previous_node_id]
index = parent.index(previous_child)
parent._children.insert(index + 1, node)
else:
parent._children.append(node)
def __init__(self):
DawNode.__init__(self)
UniqueTreeDict.__init__(self)
self._pre_fader_group = Group(name="pre-fader sends")
self._post_fader_group = Group(name="post-fader sends")
def __init__(self, *, channel_count=None, name=None):
Device.__init__(self, channel_count=channel_count, name=name)
self._node = Group(name=name or "audio device")
def __init__(self):
Device.__init__(self)
self._node = Group(name="instrument")
def __init__(self, chain_class, *, name=None):
DawContainer.__init__(self)
self._chain_class = chain_class
self._node = Group(name=name or "chain container")
def __init__(self, device_types):
DawContainer.__init__(self)
self._device_types = tuple(device_types)
self._node = Group(name="device container")
def __init__(self, name=None):
DawContainer.__init__(self)
self._pre_fader_group = Group(name="pre-fader sends")
self._post_fader_group = Group(name="post-fader sends")
def __init__(self, name=None):
DawContainer.__init__(self)
self._node = Group(name=name or "track container")
self._soloed_tracks = set()
class Application(UniqueTreeTuple, MixerContext):
"""
A DAW application.
"""
### INITIALIZER ###
def __init__(self, *, channel_count=2):
self._channel_count = channel_count
self._scenes = SceneContainer()
self._scenes._parent = self
self._server = None
self._soloed_tracks = set()
self._transport = Transport()
self._tracks = TrackContainer()
self._return_tracks = TrackContainer(name="return track container")
self._master_track = Track(
device_types=(DeviceType.AUDIO, ),
channel_count=channel_count,
name="master track",
)
self._cue_track = Track(
device_types=(DeviceType.AUDIO, ),
channel_count=channel_count,
name="cue track",
)
UniqueTreeTuple.__init__(
self,
children=[
self._transport,
self._tracks,
self._return_tracks,
self._master_track,
self._cue_track,
],
)
self._node = Group(children=[_.node for _ in self], name="application")
### PUBLIC METHODS ###
def add_scene(self):
scene = self._scenes.add_scene()
for child in self.depth_first():
if isinstance(child, Track):
child.slots.add_slot()
return scene
def add_track(self, channel_count=2, name=None) -> Track:
"""
Add a track.
"""
track = Track(channel_count=channel_count, name=name)
self.tracks.append(track)
track.add_send(Send.DEFAULT)
return track
def boot(self, server=None) -> None:
"""
Boot the DAW application.
"""
self._server = server or Server.default()
if not self._server.is_running:
self._server.boot()
for alloc_node in reversed(list(self)): # type: DawNode
alloc_node._pre_allocate(self._server)
self._node.allocate(target_node=self._server)
for post_alloc_node in reversed(list(self)): # type: DawNode
post_alloc_node._post_allocate()
def quit(self) -> None:
"""
Quit the DAW application.
"""
self._node.free()
for node in reversed(list(self)): # type: DawNode
node._free()
self._server.quit()
self._server = None
### PUBLIC PROPERTIES ###
@property
def channel_count(self) -> int:
"""
Get the application channel count.
"""
return self._channel_count
@property
def cue_track(self) -> Track:
"""
Get the application cue track.
"""
return self._cue_track
@property
def node(self) -> Group:
"""
Get the application's underlying server node.
"""
return self._node
@property
def master_track(self) -> Track:
"""
Get the application's master track.
"""
return self._master_track
@property
def server(self) -> Optional[Server]:
"""
Get the application's underlying server.
"""
return self._server
@property
def return_tracks(self) -> TrackContainer:
"""
Get the application's track container.
"""
return self._return_tracks
@property
def tracks(self) -> TrackContainer:
"""
Get the application's track container.
"""
return self._tracks
@property
def transport(self) -> Transport:
"""
Get the application's transport.
"""
return self._transport
