X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Froute.cc;h=6519980b684c6e53b1a11dde447cd9bbea2f1c19;hb=f8d065d0306b0399e9f5a53771df3c90a872510d;hp=8549bb34a64096512720b07a7266a9e1472dc5f0;hpb=c79243c8052883057b18569816917c5dea73ec31;p=ardour.git

diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index 8549bb34a6..6519980b68 100644
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -57,6 +57,7 @@
 #include "ardour/pannable.h"
 #include "ardour/panner.h"
 #include "ardour/panner_shell.h"
+#include "ardour/parameter_descriptor.h"
 #include "ardour/plugin_insert.h"
 #include "ardour/port.h"
 #include "ardour/port_insert.h"
@@ -114,6 +115,7 @@ Route::Route (Session& sess, string name, Flag flg, DataType default_type)
 	, _track_number (0)
 	, _in_configure_processors (false)
 	, _initial_io_setup (false)
+	, _strict_io (false)
 	, _custom_meter_position_noted (false)
 {
 	processor_max_streams.reset();
@@ -138,6 +140,9 @@ Route::init ()
 	_mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
 	_phase_control.reset (new PhaseControllable (X_("phase"), shared_from_this ()));
 
+	_solo_isolate_control.reset (new SoloIsolateControllable (X_("solo-iso"), shared_from_this ()));
+	_solo_safe_control.reset (new SoloSafeControllable (X_("solo-safe"), shared_from_this ()));
+
 	_solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
 	_mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
 	_phase_control->set_flags (Controllable::Flag (_phase_control->flags() | Controllable::Toggle));
@@ -659,7 +664,7 @@ Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
 			break;
 		}
 
-		/* if we're not exporting, stop processing if we come across a routing processor. */
+		/* if we're *not* exporting, stop processing if we come across a routing processor. */
 		if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 			break;
 		}
@@ -667,8 +672,20 @@ Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
 			break;
 		}
 
-		/* don't run any processors that does routing.
-		 * oh, and don't bother with the peak meter either.
+		/* special case the panner (export outputs)
+		 * Ideally we'd only run the panner, not the delivery itself...
+		 * but panners need separate input/output buffers and some context
+		 * (panshell, panner type, etc). AFAICT there is no ill side effect
+		 * of re-using the main delivery when freewheeling/exporting a region.
+		 */
+		if ((*i) == _main_outs) {
+			assert ((*i)->does_routing());
+			(*i)->run (buffers, start - latency, start - latency + nframes, nframes, true);
+			buffers.set_count ((*i)->output_streams());
+		}
+
+		/* don't run any processors that do routing.
+		 * Also don't bother with metering.
 		 */
 		if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 			(*i)->run (buffers, start - latency, start - latency + nframes, nframes, true);
@@ -791,7 +808,7 @@ Route::set_listen (bool yn, Controllable::GroupControlDisposition group_override
 	}
 
 	if (use_group (group_override, &RouteGroup::is_solo)) {
-		_route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, Controllable::NoGroup));
+		_route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, Controllable::ForGroup));
 		return;
 	}
 
@@ -826,7 +843,8 @@ Route::set_solo_safe (bool yn, Controllable::GroupControlDisposition /* group_ov
 {
 	if (_solo_safe != yn) {
 		_solo_safe = yn;
-		solo_safe_changed ();
+		solo_safe_changed (); /* EMIT SIGNAL */
+		_solo_safe_control->Changed(); /* EMIT SIGNAL */
 	}
 }
 
@@ -875,6 +893,9 @@ Route::clear_all_solo_state ()
 void
 Route::set_solo (bool yn, Controllable::GroupControlDisposition group_override)
 {
+	DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, grp ? %3 currently self-soloed ? %4\n",
+	                                          name(), yn, enum_2_string(group_override), self_soloed()));
+
 	if (_solo_safe) {
 		DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 ignore solo change due to solo-safe\n", name()));
 		return;
@@ -886,13 +907,10 @@ Route::set_solo (bool yn, Controllable::GroupControlDisposition group_override)
 	}
 
 	if (use_group (group_override, &RouteGroup::is_solo)) {
-		_route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, Controllable::NoGroup));
+		_route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, Controllable::ForGroup));
 		return;
 	}
 
-	DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, grp ? %3 currently self-soloed ? %4\n",
-	                                          name(), yn, enum_2_string(group_override), self_soloed()));
-
 	if (self_soloed() != yn) {
 		set_self_solo (yn);
 		solo_changed (true, group_override); /* EMIT SIGNAL */
@@ -1037,7 +1055,7 @@ Route::set_solo_isolated (bool yn, Controllable::GroupControlDisposition group_o
 	}
 
 	if (use_group (group_override, &RouteGroup::is_solo)) {
-		_route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, Controllable::NoGroup));
+		_route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, Controllable::ForGroup));
 		return;
 	}
 
@@ -1082,6 +1100,7 @@ Route::set_solo_isolated (bool yn, Controllable::GroupControlDisposition group_o
 	/* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
 
 	solo_isolated_changed (); /* EMIT SIGNAL */
+	_solo_isolate_control->Changed(); /* EMIT SIGNAL */
 }
 
 bool
@@ -1106,7 +1125,7 @@ void
 Route::set_mute (bool yn, Controllable::GroupControlDisposition group_override)
 {
 	if (use_group (group_override, &RouteGroup::is_mute)) {
-		_route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, Controllable::NoGroup));
+		_route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, Controllable::ForGroup));
 		return;
 	}
 
@@ -1239,6 +1258,13 @@ Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<
 		return 1;
 	}
 
+	if (_strict_io) {
+		boost::shared_ptr<PluginInsert> pi;
+		if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
+			pi->set_strict_io (true);
+		}
+	}
+
 	{
 		Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 		Glib::Threads::RWLock::WriterLock lm (_processor_lock);
@@ -1437,7 +1463,8 @@ Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor>
 			boost::shared_ptr<PluginInsert> pi;
 
 			if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
-				pi->set_count (1);
+				pi->set_count (1); // why? configure_processors_unlocked() will re-do this
+				pi->set_strict_io (_strict_io);
 			}
 
 			_processors.insert (loc, *i);
@@ -1795,6 +1822,104 @@ Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStream
 	return 0;
 }
 
+int
+Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
+{
+	/* these can never be removed */
+	if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
+		return 1;
+	}
+	/* and can't be used as substitute, either */
+	if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
+		return 1;
+	}
+
+	/* I/Os are out, too */
+	if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
+		return 1;
+	}
+
+	/* this function cannot be used to swap/reorder processors */
+	if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
+		return 1;
+	}
+
+	if (!AudioEngine::instance()->connected() || !old || !sub) {
+		return 1;
+	}
+
+	/* ensure that sub is not owned by another route */
+	if (sub->owner ()) {
+		return 1;
+	}
+
+	{
+		Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
+		Glib::Threads::RWLock::WriterLock lm (_processor_lock);
+		ProcessorState pstate (this);
+
+		assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
+
+		ProcessorList::iterator i;
+		bool replaced = false;
+		bool enable = old->active ();
+
+		for (i = _processors.begin(); i != _processors.end(); ) {
+			if (*i == old) {
+				i = _processors.erase (i);
+				_processors.insert (i, sub);
+				sub->set_owner (this);
+				replaced = true;
+				break;
+			} else {
+				++i;
+			}
+		}
+
+		if (!replaced) {
+			return 1;
+		}
+
+		if (_strict_io) {
+			boost::shared_ptr<PluginInsert> pi;
+			if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
+				pi->set_strict_io (true);
+			}
+		}
+
+		if (configure_processors_unlocked (err)) {
+			pstate.restore ();
+			configure_processors_unlocked (0);
+			return -1;
+		}
+
+		_have_internal_generator = false;
+
+		for (i = _processors.begin(); i != _processors.end(); ++i) {
+			boost::shared_ptr<PluginInsert> pi;
+			if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
+				if (pi->has_no_inputs ()) {
+					_have_internal_generator = true;
+					break;
+				}
+			}
+		}
+
+		if (enable) {
+			sub->activate ();
+		}
+
+		sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
+		_output->set_user_latency (0);
+	}
+
+	reset_instrument_info ();
+	old->drop_references ();
+	processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+	set_processor_positions ();
+	return 0;
+}
+
 int
 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
 {
@@ -2030,16 +2155,22 @@ Route::configure_processors_unlocked (ProcessorStreams* err)
 
 		if (!(*p)->configure_io(c->first, c->second)) {
 			DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
+			_in_configure_processors = false;
+			return -1;
 		}
 		processor_max_streams = ChanCount::max(processor_max_streams, c->first);
 		processor_max_streams = ChanCount::max(processor_max_streams, c->second);
 
 		boost::shared_ptr<PluginInsert> pi;
 		if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
-			/* plugins connected via Split Match may have more channels.
-			 * route/scratch buffers are needed for all of them*/
+			/* plugins connected via Split or Hide Match may have more channels.
+			 * route/scratch buffers are needed for all of them
+			 * The configuration may only be a subset (both input and output)
+			 */
 			processor_max_streams = ChanCount::max(processor_max_streams, pi->input_streams());
-			processor_max_streams = ChanCount::max(processor_max_streams, pi->natural_input_streams());
+			processor_max_streams = ChanCount::max(processor_max_streams, pi->output_streams());
+			processor_max_streams = ChanCount::max(processor_max_streams, pi->natural_input_streams() * pi->get_count());
+			processor_max_streams = ChanCount::max(processor_max_streams, pi->natural_output_streams() * pi->get_count());
 		}
 		out = c->second;
 
@@ -2272,6 +2403,108 @@ Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err
 	return 0;
 }
 
+bool
+Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
+{
+	ChanCount unused;
+	return customize_plugin_insert (proc, 0, unused);
+}
+
+bool
+Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs)
+{
+	boost::shared_ptr<PluginInsert> pi;
+	if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
+		return false;
+	}
+
+	{
+		bool found = false;
+		Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
+		for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
+			if (*p == proc) {
+				found = true;
+				break;
+			}
+		}
+		if (!found) {
+			return false;
+		}
+	}
+
+	{
+		Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
+		Glib::Threads::RWLock::WriterLock lm (_processor_lock);
+		ProcessorState pstate (this);
+
+		bool      old_cust = pi->custom_cfg ();
+		uint32_t  old_cnt  = pi->get_count ();
+		ChanCount old_chan = pi->output_streams ();
+
+		if (count == 0) {
+			pi->set_custom_cfg (false);
+		} else {
+			pi->set_custom_cfg (true);
+			pi->set_count (count);
+			pi->set_outputs (outs);
+		}
+
+		list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
+		if (c.empty()) {
+			/* not possible */
+
+			pi->set_count (old_cnt);
+			pi->set_outputs (old_chan);
+			pi->set_custom_cfg (old_cust);
+
+			return false;
+		}
+		configure_processors_unlocked (0);
+	}
+
+	processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+	_session.set_dirty ();
+	return true;
+}
+
+bool
+Route::set_strict_io (const bool enable)
+{
+	if (_strict_io != enable) {
+		_strict_io = enable;
+		Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
+		for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
+			boost::shared_ptr<PluginInsert> pi;
+			if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
+				pi->set_strict_io (_strict_io);
+			}
+		}
+
+		list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
+
+		if (c.empty()) {
+			// not possible
+			_strict_io = !enable; // restore old value
+			for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
+				boost::shared_ptr<PluginInsert> pi;
+				if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
+					pi->set_strict_io (_strict_io);
+				}
+			}
+			return false;
+		}
+		lm.release ();
+
+		{
+			Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
+			configure_processors (0);
+		}
+		processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
+		_session.set_dirty ();
+	}
+	return true;
+}
+
 XMLNode&
 Route::get_state()
 {
@@ -2300,6 +2533,7 @@ Route::state(bool full_state)
 	node->add_property("id", buf);
 	node->add_property ("name", _name);
 	node->add_property("default-type", _default_type.to_string());
+	node->add_property ("strict-io", _strict_io);
 
 	if (_flags) {
 		node->add_property("flags", enum_2_string (_flags));
@@ -2423,6 +2657,10 @@ Route::set_state (const XMLNode& node, int version)
 		_flags = Flag (0);
 	}
 
+	if ((prop = node.property (X_("strict-io"))) != 0) {
+		_strict_io = string_is_affirmative (prop->value());
+	}
+
 	if (is_master() || is_monitor() || is_auditioner()) {
 		_mute_master->set_solo_ignore (true);
 	}
@@ -2966,13 +3204,19 @@ Route::set_processor_state (const XMLNode& node)
 				} else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 				           prop->value() == "lv2" ||
 				           prop->value() == "windows-vst" ||
-					   prop->value() == "lxvst" ||
+				           prop->value() == "lxvst" ||
+				           prop->value() == "luaproc" ||
 				           prop->value() == "audiounit") {
 
 					if (_session.get_disable_all_loaded_plugins ()) {
 						processor.reset (new UnknownProcessor (_session, **niter));
 					} else {
 						processor.reset (new PluginInsert (_session));
+						if (_strict_io) {
+							boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
+							pi->set_strict_io (true);
+						}
+
 					}
 				} else if (prop->value() == "port") {
 
@@ -3884,264 +4128,6 @@ Route::set_latency_compensation (framecnt_t longest_session_latency)
 	}
 }
 
-void
-Route::set_control (AutomationType type, double val, PBD::Controllable::GroupControlDisposition group_override)
-{
-	boost::shared_ptr<RouteList> rl;
-
-	switch (type) {
-	case GainAutomation:
-		/* route must mediate group control */
-		set_gain (val, group_override);
-		return;
-		break;
-
-	case TrimAutomation:
-		/* route must mediate group control */
-		set_trim (val, group_override);
-		return;
-		break;
-
-	case RecEnableAutomation:
-		/* session must mediate group control */
-		rl.reset (new RouteList);
-		rl->push_back (shared_from_this());
-		_session.set_record_enabled (rl, val >= 0.5 ? true : false, Session::rt_cleanup, group_override);
-		return;
-		break;
-
-	case SoloAutomation:
-		/* session must mediate group control */
-		rl.reset (new RouteList);
-		rl->push_back (shared_from_this());
-		if (Config->get_solo_control_is_listen_control()) {
-			_session.set_listen (rl, val >= 0.5 ? true : false, Session::rt_cleanup, group_override);
-		} else {
-			_session.set_solo (rl, val >= 0.5 ? true : false);
-		}
-
-		return;
-		break;
-
-	case MuteAutomation:
-		/* session must mediate group control */
-		rl.reset (new RouteList);
-		rl->push_back (shared_from_this());
-		_session.set_mute (rl, !muted(), Session::rt_cleanup, group_override);
-		return;
-		break;
-
-	default:
-		/* Not a route automation control */
-		fatal << string_compose (_("programming error: %1%2\n"), X_("illegal type of route automation control passed to Route::set_control(): "), enum_2_string(type)) << endmsg;
-		/*NOTREACHED*/
-		return;
-	}
-}
-
-
-Route::RouteAutomationControl::RouteAutomationControl (const std::string& name,
-                                                       AutomationType atype,
-                                                       boost::shared_ptr<AutomationList> alist,
-                                                       boost::shared_ptr<Route> r)
-	: AutomationControl (r->session(), Evoral::Parameter (atype),
-	                     ParameterDescriptor (Evoral::Parameter (atype)),
-	                     alist, name)
-	, _route (r)
-{
-}
-
-Route::GainControllable::GainControllable (Session& s, AutomationType atype, boost::shared_ptr<Route> r)
-	: GainControl (s, Evoral::Parameter(atype))
-	, _route (r)
-{
-
-}
-
-Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
-	: RouteAutomationControl (name, SoloAutomation, boost::shared_ptr<AutomationList>(), r)
-{
-	boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
-	gl->set_interpolation(Evoral::ControlList::Discrete);
-	set_list (gl);
-}
-
-void
-Route::SoloControllable::set_value (double val, PBD::Controllable::GroupControlDisposition group_override)
-{
-	if (writable()) {
-		_set_value (val, group_override);
-	}
-}
-
-void
-Route::SoloControllable::_set_value (double val, PBD::Controllable::GroupControlDisposition group_override)
-{
-	const bool bval = ((val >= 0.5) ? true : false);
-
-	boost::shared_ptr<RouteList> rl (new RouteList);
-
-	boost::shared_ptr<Route> r = _route.lock ();
-	if (!r) {
-		return;
-	}
-
-	rl->push_back (r);
-
-	if (Config->get_solo_control_is_listen_control()) {
-		_session.set_listen (rl, bval, Session::rt_cleanup, group_override);
-	} else {
-		_session.set_solo (rl, bval, Session::rt_cleanup, group_override);
-	}
-}
-
-void
-Route::SoloControllable::set_value_unchecked (double val)
-{
-	/* Used only by automation playback */
-
-	_set_value (val, Controllable::NoGroup);
-}
-
-double
-Route::SoloControllable::get_value () const
-{
-	boost::shared_ptr<Route> r = _route.lock ();
-	if (!r) {
-		return 0;
-	}
-
-	if (Config->get_solo_control_is_listen_control()) {
-		return r->listening_via_monitor() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
-	} else {
-		return r->self_soloed() ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
-	}
-}
-
-Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
-	: RouteAutomationControl (name, MuteAutomation, boost::shared_ptr<AutomationList>(), r)
-	, _route (r)
-{
-	boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
-	gl->set_interpolation(Evoral::ControlList::Discrete);
-	set_list (gl);
-}
-
-void
-Route::MuteControllable::set_superficial_value(bool muted)
-{
-	/* Note we can not use AutomationControl::set_value here since it will emit
-	   Changed(), but the value will not be correct to the observer. */
-
-	const bool to_list = _list && ((AutomationList*)_list.get ())->automation_write ();
-	const double where = _session.audible_frame ();
-	if (to_list) {
-		/* Note that we really need this:
-		 *  if (as == Touch && _list->in_new_write_pass ()) {
-		 *       alist->start_write_pass (_session.audible_frame ());
-		 *  }
-		 * here in the case of the user calling from a GUI or whatever.
-		 * Without the ability to distinguish between user and
-		 * automation-initiated changes, we lose the "touch mute"
-		 * behaviour we have in AutomationController::toggled ().
-		 */
-		_list->set_in_write_pass (true, false, where);
-	}
-
-	Control::set_double (muted, where, to_list);
-}
-
-void
-Route::MuteControllable::set_value (double val, PBD::Controllable::GroupControlDisposition group_override)
-{
-	if (writable()) {
-		_set_value (val, group_override);
-	}
-}
-
-void
-Route::MuteControllable::set_value_unchecked (double val)
-{
-	/* used only automation playback */
-	_set_value (val, Controllable::NoGroup);
-}
-
-void
-Route::MuteControllable::_set_value (double val, Controllable::GroupControlDisposition group_override)
-{
-	const bool bval = ((val >= 0.5) ? true : false);
-
-	boost::shared_ptr<Route> r = _route.lock ();
-	if (!r) {
-		return;
-	}
-
-	if (_list && ((AutomationList*)_list.get())->automation_playback()) {
-		// Set superficial/automation value to drive controller (and possibly record)
-		set_superficial_value (bval);
-		// Playing back automation, set route mute directly
-		r->set_mute (bval, Controllable::NoGroup);
-	} else {
-		// Set from user, queue mute event
-		boost::shared_ptr<RouteList> rl (new RouteList);
-		rl->push_back (r);
-		_session.set_mute (rl, bval, Session::rt_cleanup, group_override);
-	}
-}
-
-double
-Route::MuteControllable::get_value () const
-{
-	if (_list && ((AutomationList*)_list.get())->automation_playback()) {
-		// Playing back automation, get the value from the list
-		return AutomationControl::get_value();
-	}
-
-	// Not playing back automation, get the actual route mute value
-	boost::shared_ptr<Route> r = _route.lock ();
-	return (r && r->muted()) ? GAIN_COEFF_UNITY : GAIN_COEFF_ZERO;
-}
-
-Route::PhaseControllable::PhaseControllable (std::string name, boost::shared_ptr<Route> r)
-	: RouteAutomationControl (name, PhaseAutomation, boost::shared_ptr<AutomationList>(), r)
-{
-	boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(PhaseAutomation)));
-	gl->set_interpolation(Evoral::ControlList::Discrete);
-	set_list (gl);
-}
-
-void
-Route::PhaseControllable::set_value (double v, PBD::Controllable::GroupControlDisposition /* group_override */)
-{
-	boost::shared_ptr<Route> r = _route.lock ();
-	if (r->phase_invert().size()) {
-		if (v == 0 || (v < 1 && v > 0.9) ) {
-			r->set_phase_invert (_current_phase, false);
-		} else {
-			r->set_phase_invert (_current_phase, true);
-		}
-	}
-}
-
-double
-Route::PhaseControllable::get_value () const
-{
-	boost::shared_ptr<Route> r = _route.lock ();
-	return (double) r->phase_invert (_current_phase);
-}
-
-void
-Route::PhaseControllable::set_channel (uint32_t c)
-{
-	_current_phase = c;
-}
-
-uint32_t
-Route::PhaseControllable::channel () const
-{
-	return _current_phase;
-}
-
 void
 Route::set_block_size (pframes_t nframes)
 {
@@ -4367,6 +4353,7 @@ Route::set_phase_invert (uint32_t c, bool yn)
 	if (_phase_invert[c] != yn) {
 		_phase_invert[c] = yn;
 		phase_invert_changed (); /* EMIT SIGNAL */
+		_phase_control->Changed(); /* EMIT SIGNAL */
 		_session.set_dirty ();
 	}
 }
@@ -4460,6 +4447,16 @@ Route::trim_control() const
 	return _trim_control;
 }
 
+boost::shared_ptr<Route::PhaseControllable>
+Route::phase_control() const
+{
+	if (phase_invert().size()) {
+		return _phase_control;
+	} else {
+		return boost::shared_ptr<PhaseControllable>();
+	}
+}
+
 boost::shared_ptr<AutomationControl>
 Route::get_control (const Evoral::Parameter& param)
 {
@@ -4491,10 +4488,10 @@ Route::get_control (const Evoral::Parameter& param)
 }
 
 boost::shared_ptr<Processor>
-Route::nth_plugin (uint32_t n)
+Route::nth_plugin (uint32_t n) const
 {
 	Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
-	ProcessorList::iterator i;
+	ProcessorList::const_iterator i;
 
 	for (i = _processors.begin(); i != _processors.end(); ++i) {
 		if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
@@ -4508,13 +4505,21 @@ Route::nth_plugin (uint32_t n)
 }
 
 boost::shared_ptr<Processor>
-Route::nth_send (uint32_t n)
+Route::nth_send (uint32_t n) const
 {
 	Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
-	ProcessorList::iterator i;
+	ProcessorList::const_iterator i;
 
 	for (i = _processors.begin(); i != _processors.end(); ++i) {
 		if (boost::dynamic_pointer_cast<Send> (*i)) {
+
+			if ((*i)->name().find (_("Monitor")) == 0) {
+				/* send to monitor section is not considered
+				   to be an accessible send.
+				*/
+				continue;
+			}
+
 			if (n-- == 0) {
 				return *i;
 			}
@@ -5143,7 +5148,9 @@ Route::pan_azimuth_control() const
 {
 #ifdef MIXBUS
 	boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
-	assert (plug);
+	if (!plug) {
+		return boost::shared_ptr<AutomationControl>();
+	}
 	const uint32_t port_channel_post_pan = 2; // gtk2_ardour/mixbus_ports.h
 	return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
 #else
@@ -5471,6 +5478,8 @@ Route::comp_mode_name (uint32_t mode) const
 		return _("Compressor");
 	case 2:
 		return _("Limiter");
+	case 3:
+		return mixbus() ? _("Sidechain") : _("Limiter");
 	}
 
 	return _("???");
@@ -5489,6 +5498,7 @@ Route::comp_speed_name (uint32_t mode) const
 	case 1:
 		return _("Ratio");
 	case 2:
+	case 3:
 		return _("Rels");
 	}
 	return _("???");
@@ -5502,7 +5512,9 @@ Route::send_level_controllable (uint32_t n) const
 {
 #ifdef  MIXBUS
 	boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
-	assert (plug);
+	if (!plug) {
+		return boost::shared_ptr<AutomationControl>();
+	}
 
 	if (n >= 8) {
 		/* no such bus */
@@ -5512,7 +5524,11 @@ Route::send_level_controllable (uint32_t n) const
 	const uint32_t port_id = port_channel_post_aux1_level + (2*n); // gtk2_ardour/mixbus_ports.h
 	return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
 #else
-	return boost::shared_ptr<AutomationControl>();
+	boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
+	if (!s) {
+		return boost::shared_ptr<AutomationControl>();
+	}
+	return s->gain_control ();
 #endif
 }
 
@@ -5521,7 +5537,9 @@ Route::send_enable_controllable (uint32_t n) const
 {
 #ifdef  MIXBUS
 	boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
-	assert (plug);
+	if (!plug) {
+		return boost::shared_ptr<AutomationControl>();
+	}
 
 	if (n >= 8) {
 		/* no such bus */
@@ -5530,6 +5548,45 @@ Route::send_enable_controllable (uint32_t n) const
 
 	const uint32_t port_id = port_channel_post_aux1_asgn + (2*n); // gtk2_ardour/mixbus_ports.h
 	return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
+#else
+	/* although Ardour sends have enable/disable as part of the Processor
+	   API, it is not exposed as a controllable.
+
+	   XXX: we should fix this.
+	*/
+	return boost::shared_ptr<AutomationControl>();
+#endif
+}
+
+string
+Route::send_name (uint32_t n) const
+{
+#ifdef MIXBUS
+	if (n >= 8) {
+		return string();
+	}
+	boost::shared_ptr<Route> r = _session.get_mixbus (n);
+	assert (r);
+	return r->name();
+#else
+	boost::shared_ptr<Processor> p = nth_send (n);
+	if (p) {
+		return p->name();
+	} else {
+		return string();
+	}
+#endif
+}
+
+boost::shared_ptr<AutomationControl>
+Route::master_send_enable_controllable () const
+{
+#ifdef  MIXBUS
+	boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
+	if (!plug) {
+		return boost::shared_ptr<AutomationControl>();
+	}
+	return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
 #else
 	return boost::shared_ptr<AutomationControl>();
 #endif