XMLNode n (**niter);
Send::make_unique (n, *_session);
- p.reset (new Send (*_session, _route->mute_master(), n));
+ Send* s = new Send (*_session, _route->mute_master());
+ if (s->set_state (n, Stateful::loading_state_version)) {
+ delete s;
+ return;
+ }
+
+ p.reset (s);
+
} else if (type->value() == "return") {
XMLNode n (**niter);
Return::make_unique (n, *_session);
- p.reset (new Return (*_session, **niter));
+ Return* r = new Return (*_session);
+
+ if (r->set_state (n, Stateful::loading_state_version)) {
+ delete r;
+ return;
+ }
+
+ p.reset (r);
} else {
/* XXX its a bit limiting to assume that everything else
is a plugin.
*/
+
p.reset (new PluginInsert (*_session, **niter));
}
/* Delivery to an existing output */
Delivery (Session& s, boost::shared_ptr<IO> io, boost::shared_ptr<MuteMaster> mm, const std::string& name, Role);
- Delivery (Session& s, boost::shared_ptr<IO> io, boost::shared_ptr<MuteMaster> mm, const XMLNode&);
/* Delivery to a new output owned by this object */
Delivery (Session& s, boost::shared_ptr<MuteMaster> mm, const std::string& name, Role);
- Delivery (Session&, boost::shared_ptr<MuteMaster> mm, const XMLNode&);
~Delivery ();
bool set_name (const std::string& name);
{
public:
InternalReturn (Session&);
- InternalReturn (Session&, const XMLNode&);
bool visible() const;
{
public:
InternalSend (Session&, boost::shared_ptr<MuteMaster>, boost::shared_ptr<Route> send_to, Delivery::Role role);
- InternalSend (Session&, boost::shared_ptr<MuteMaster>, const XMLNode&);
virtual ~InternalSend ();
std::string display_name() const;
boost::shared_ptr<Route> _send_to;
PBD::ID _send_to_id;
PBD::ScopedConnection connect_c;
+ PBD::ScopedConnectionList target_connections;
void send_to_going_away ();
void send_to_property_changed (const PBD::PropertyChange&);
int connect_when_legal ();
int set_our_state (XMLNode const &, int);
+ int use_target (boost::shared_ptr<Route>);
};
} // namespace ARDOUR
class PeakMeter : public Processor {
public:
PeakMeter(Session& s) : Processor(s, "Meter") {}
- PeakMeter(Session&s, const XMLNode& node);
void meter();
void reset ();
{
public:
MonitorProcessor (Session&);
- MonitorProcessor (Session&, const XMLNode& name);
bool display_to_user() const;
CycleStart.connect_same_thread (*this, boost::bind (&Delivery::cycle_start, this, _1));
}
-/* deliver to a new IO object, reconstruct from XML */
-
-Delivery::Delivery (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
- : IOProcessor (s, false, true, "reset")
- , _role (Role (0))
- , _output_buffers (new BufferSet())
- , _current_gain (1.0)
- , _output_offset (0)
- , _no_outs_cuz_we_no_monitor (false)
- , _solo_level (0)
- , _solo_isolated (false)
- , _mute_master (mm)
- , no_panner_reset (false)
-{
- _panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
- _display_to_user = false;
-
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor ();
- }
-
- if (_output) {
- _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
- }
-
- CycleStart.connect_same_thread (*this, boost::bind (&Delivery::cycle_start, this, _1));
-}
-
-/* deliver to an existing IO object, reconstruct from XML */
-
-Delivery::Delivery (Session& s, boost::shared_ptr<IO> out, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
- : IOProcessor (s, boost::shared_ptr<IO>(), out, "reset")
- , _role (Role (0))
- , _output_buffers (new BufferSet())
- , _current_gain (1.0)
- , _output_offset (0)
- , _no_outs_cuz_we_no_monitor (false)
- , _solo_level (0)
- , _solo_isolated (false)
- , _mute_master (mm)
- , no_panner_reset (false)
-{
- _panner = boost::shared_ptr<Panner>(new Panner (_name, _session));
- _display_to_user = false;
-
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor ();
- }
-
- if (_output) {
- _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
- }
-
- CycleStart.connect_same_thread (*this, boost::bind (&Delivery::cycle_start, this, _1));
-}
Delivery::~Delivery()
{
CycleStart.connect_same_thread (*this, boost::bind (&InternalReturn::cycle_start, this, _1));
}
-InternalReturn::InternalReturn (Session& s, const XMLNode& node)
- : Return (s, node, true)
- , user_count (0)
-{
- CycleStart.connect_same_thread (*this, boost::bind (&InternalReturn::cycle_start, this, _1));
-}
-
void
InternalReturn::run (BufferSet& bufs, sframes_t /*start_frame*/, sframes_t /*end_frame*/, nframes_t nframes, bool)
{
InternalSend::InternalSend (Session& s, boost::shared_ptr<MuteMaster> mm, boost::shared_ptr<Route> sendto, Delivery::Role role)
: Send (s, mm, role)
- , _send_to (sendto)
{
- if ((target = _send_to->get_return_buffer ()) == 0) {
- throw failed_constructor();
- }
-
- set_name (sendto->name());
-
- _send_to->DropReferences.connect_same_thread (*this, boost::bind (&InternalSend::send_to_going_away, this));
- _send_to->PropertyChanged.connect_same_thread (*this, boost::bind (&InternalSend::send_to_property_changed, this, _1));;
-}
-
-InternalSend::InternalSend (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node)
- : Send (s, mm, node, Stateful::loading_state_version, Delivery::Aux /* will be reset in set_state() */),
- target (0)
-{
- /* Send constructor will set its state, so here we just need to set up our own */
- set_our_state (node, Stateful::loading_state_version);
+ if (sendto) {
+ if (use_target (sendto)) {
+ throw failed_constructor();
+ }
+ }
}
InternalSend::~InternalSend ()
if (_send_to) {
_send_to->release_return_buffer ();
}
+}
- connect_c.disconnect ();
+int
+InternalSend::use_target (boost::shared_ptr<Route> sendto)
+{
+ _send_to = sendto;
+
+ if ((target = _send_to->get_return_buffer ()) == 0) {
+ return -1;
+ }
+
+ set_name (sendto->name());
+ _send_to_id = _send_to->id();
+
+ target_connections.drop_connections ();
+
+ _send_to->DropReferences.connect_same_thread (target_connections, boost::bind (&InternalSend::send_to_going_away, this));
+ _send_to->PropertyChanged.connect_same_thread (target_connections, boost::bind (&InternalSend::send_to_property_changed, this, _1));;
+
+ return 0;
}
+
void
InternalSend::send_to_going_away ()
{
target = 0;
+ target_connections.drop_connections ();
_send_to.reset ();
_send_to_id = "0";
}
return 0;
}
- if ((_send_to = _session.route_by_id (_send_to_id)) == 0) {
- error << X_("cannot find route to connect to") << endmsg;
- return -1;
- }
+ boost::shared_ptr<Route> sendto;
- if ((target = _send_to->get_return_buffer ()) == 0) {
- error << X_("target for internal send has no return buffer") << endmsg;
+ if ((sendto = _session.route_by_id (_send_to_id)) == 0) {
+ error << X_("cannot find route to connect to") << endmsg;
return -1;
}
- return 0;
+ return use_target (sendto);
}
bool
PBD::Signal0<void> Metering::Meter;
-PeakMeter::PeakMeter (Session& s, const XMLNode& node)
- : Processor (s, node)
-{
-
-}
-
/** Get peaks from @a bufs
* Input acceptance is lenient - the first n buffers from @a bufs will
* be metered, where n was set by the last call to setup(), excess meters will
_solo_boost_level = 1.0;
}
-MonitorProcessor::MonitorProcessor (Session& s, const XMLNode& node)
- : Processor (s, node)
-{
- set_state (node, Stateful::loading_state_version);
-}
-
void
MonitorProcessor::allocate_channels (uint32_t size)
{
ProcessorCreated (this); /* EMIT SIGNAL */
}
-Return::Return (Session& s, const XMLNode& node, bool internal)
- : IOProcessor (s, (internal ? false : true), false, "return")
- , _metering (false)
-{
- /* never muted */
-
- _amp.reset (new Amp (_session, boost::shared_ptr<MuteMaster>()));
- _meter.reset (new PeakMeter (_session));
-
- if (set_state (node, Stateful::loading_state_version)) {
- throw failed_constructor();
- }
-
- ProcessorCreated (this); /* EMIT SIGNAL */
-}
-
Return::~Return ()
{
}
}
assert (bufs.count() == (*i)->input_streams());
- cerr << _name << " run processor " << (*i)->name() << " with " << bufs.count() << endl;
-
(*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
bufs.set_count ((*i)->output_streams());
}
}
+ /* is this the monitor send ? if so, make sure we keep track of it */
+
+ boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
+
+ if (isend && _session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
+ _monitor_send = isend;
+
+ if (_monitor_send->active()) {
+ _monitor_send->set_solo_level (1);
+ } else {
+ _monitor_send->set_solo_level (0);
+ }
+ }
+
if (activation_allowed && (processor != _monitor_send)) {
processor->activate ();
}
boost::shared_ptr<Processor> processor;
- if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
- prop->value() == "lv2" ||
- prop->value() == "vst" ||
- prop->value() == "audiounit") {
-
- processor.reset (new PluginInsert(_session, node));
-
- } else if (prop->value() == "port") {
-
- processor.reset (new PortInsert (_session, _mute_master, node));
-
- } else if (prop->value() == "send") {
-
- processor.reset (new Send (_session, _mute_master, node));
-
- } else if (prop->value() == "meter") {
+ /* meter, amp, monitor and intreturn are all singletons, deal with them first */
+
+ if (prop->value() == "meter") {
if (_meter) {
if (_meter->set_state (node, Stateful::loading_state_version)) {
}
}
- _meter.reset (new PeakMeter (_session, node));
+ PeakMeter* pm = new PeakMeter (_session);
+
+ if (pm->set_state (node, Stateful::loading_state_version)) {
+ delete pm;
+ return false;
+ }
+
+ _meter.reset (pm);
_meter->set_display_to_user (_meter_point == MeterCustom);
+
processor = _meter;
} else if (prop->value() == "monitor") {
return true;
}
}
-
- _monitor_control.reset (new MonitorProcessor (_session));
- _monitor_control->set_state (node, Stateful::loading_state_version);
- processor = _monitor_control;
-
- } else if (prop->value() == "amp") {
- /* amp always exists */
+ MonitorProcessor* mp = new MonitorProcessor (_session);
+ if (mp->set_state (node, Stateful::loading_state_version)) {
+ delete mp;
+ return false;
+ }
- processor = _amp;
- if (processor->set_state (node, Stateful::loading_state_version)) {
- return false;
- } else {
- /* never any reason to add it */
- return true;
- }
+ _monitor_control.reset (mp);
+ processor = _monitor_control;
- } else if (prop->value() == "intsend") {
+ } else if (prop->value() == "amp") {
- InternalSend* isend = new InternalSend (_session, _mute_master, node);
-
- if (_session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
- _monitor_send.reset (isend);
- if (_monitor_send->active()) {
- _monitor_send->set_solo_level (1);
+ if (_amp) {
+ processor = _amp;
+ if (processor->set_state (node, Stateful::loading_state_version)) {
+ return false;
} else {
- _monitor_send->set_solo_level (0);
+ /* no reason to add it */
+ return true;
}
}
- processor.reset (isend);
+ Amp* a = new Amp (_session, _mute_master);
+ if (_amp->set_state (node, Stateful::loading_state_version)) {
+ delete a;
+ return false;
+ }
+
+ _amp.reset (a);
+ processor = _amp;
} else if (prop->value() == "intreturn") {
return true;
}
}
- _intreturn.reset (new InternalReturn (_session, node));
+
+ InternalReturn* iret = new InternalReturn (_session);
+ if (iret->set_state (node, Stateful::loading_state_version)) {
+ delete iret;
+ return false;
+ }
+
+ _intreturn.reset (iret);
processor = _intreturn;
} else if (prop->value() == "main-outs") {
}
}
- _main_outs.reset (new Delivery (_session, _output, _mute_master, node));
+ Delivery* del = new Delivery (_session, _output, _mute_master, X_("toBeResetFroXML"), Delivery::Role (0));
+ if (del->set_state (node, Stateful::loading_state_version)) {
+ delete del;
+ return false;
+ }
+
+ _main_outs.reset (del);
processor = _main_outs;
+ } else if (prop->value() == "intsend") {
+
+ InternalSend* isend = new InternalSend (_session, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0));
+ if (isend->set_state (node, Stateful::loading_state_version)) {
+ delete isend;
+ return false;
+ }
+
+ processor.reset (isend);
+
+ } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
+ prop->value() == "lv2" ||
+ prop->value() == "vst" ||
+ prop->value() == "audiounit") {
+
+ processor.reset (new PluginInsert(_session, node));
+
+ } else if (prop->value() == "port") {
+
+ processor.reset (new PortInsert (_session, _mute_master, node));
+
+ } else if (prop->value() == "send") {
+
+ processor.reset (new Send (_session, _mute_master, node));
+
} else {
error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
return false;
projects / ardour.git / commitdiff