the last (?) piece of the internal send/listen/monitor/control outs track/bus architecture puzzle: a send from the post-fader master bus to the control/listen/monitor bus inputs that is silent when something is soloed, but the rest of the time delivers the main mix to the control/listen/monitor bus. Tweaks to follow, surely ...

git-svn-id: svn://localhost/ardour2/branches/3.0@6740 d708f5d6-7413-0410-9779-e7cbd77b26cf

libs/ardour/ardour/delivery.h

@@ -45,7 +45,9 @@ public:
 		/* listen - internal send used only to deliver to control/monitor bus */
 		Listen = 0x8,
 		/* aux - internal send used to deliver to any bus, by user request */
-		Aux    = 0x10
+		Aux    = 0x10,
+                /* main listen - internal send used only to deliver from master to control/monitor bus */
+                MainListen = 0x20
 	};
 
 	static bool role_requires_output_ports (Role r) { return r == Main || r == Send || r == Insert; }

libs/ardour/delivery.cc

@@ -163,6 +163,7 @@ Delivery::display_name () const
 		return _("main outs");
 		break;
 	case Listen:
+        case MainListen:
 		return _("listen");
 		break;
 	case Send:
@@ -369,6 +370,8 @@ Delivery::state (bool full_state)
 		node.add_property("type", "main-outs");
 	} else if (_role & Listen) {
 		node.add_property("type", "listen");
+	} else if (_role & MainListen) {
+		node.add_property("type", "main-listen");
 	} else {
 		node.add_property("type", "delivery");
 	}
@@ -538,39 +541,58 @@ Delivery::target_gain ()
 		return 0.0;
 	}
 
-	gain_t desired_gain;
+	gain_t desired_gain = -1.0f;
 
+        if (_role == MainListen) {
+                
+                /* silent if anyone else soloing; unity gain otherwise */
+                
+                desired_gain = (_session.soloing() ? 0.0 : 1.0);
+
+        } else if (_solo_level) {
 
-	if (_solo_level) {
 		desired_gain = 1.0;
-	} else {
 
-		MuteMaster::MutePoint mp;
+        } else {
 
-		switch (_role) {
+                if (_role == Listen && _session.control_out() && !_session.soloing()) {
-		case Main:
-			mp = MuteMaster::Main;
-			break;
-		case Listen:
-			mp = MuteMaster::Listen;
-			break;
-		case Send:
-		case Insert:
-		case Aux:
-			/* XXX FIX ME this is wrong, we need per-delivery muting */
-			mp = MuteMaster::PreFader;
-			break;
-		}
-		
-		if (!_solo_isolated && _session.soloing()) {
-			desired_gain = min (Config->get_solo_mute_gain(), _mute_master->mute_gain_at (mp));
 
-		} else {
+                        /* nobody is soloed, so control/monitor/listen bus gets its
+                           signal from master out, we should be silent
+                        */
+                        desired_gain = 0.0;
 
-			desired_gain = _mute_master->mute_gain_at (mp);
+                } else {
-		}
+                
-
+                        MuteMaster::MutePoint mp;
-	}
+                
+                        switch (_role) {
+                        case Main:
+                                mp = MuteMaster::Main;
+                                break;
+                        case Listen:
+                                mp = MuteMaster::Listen;
+                                break;
+                        case Send:
+                        case Insert:
+                        case Aux:
+                                /* XXX FIX ME this is wrong, we need per-delivery muting */
+                                mp = MuteMaster::PreFader;
+                                break;
+                        case MainListen:
+                                /* we can't get here, see if() above */
+                                break;
+                        }
+                        
+                        if (!_solo_isolated && _session.soloing()) {
+                                desired_gain = min (Config->get_solo_mute_gain(), _mute_master->mute_gain_at (mp));
+                                
+                        } else {
+                                
+                                desired_gain = _mute_master->mute_gain_at (mp);
+                        }
+                }
+        }
 
 	return desired_gain;
 }

libs/ardour/enums.cc

@@ -514,6 +514,7 @@ setup_enum_writer ()
 	REGISTER_CLASS_ENUM (Delivery, Listen);
 	REGISTER_CLASS_ENUM (Delivery, Main);
 	REGISTER_CLASS_ENUM (Delivery, Aux);
+	REGISTER_CLASS_ENUM (Delivery, MainListen);
 	REGISTER_BITS (_Delivery_Role);
 
 	REGISTER_CLASS_ENUM (MuteMaster, PreFader);

libs/ardour/route.cc

@@ -2361,7 +2361,20 @@ Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*a
 	boost::shared_ptr<InternalSend> listener;
 
 	try {
-		listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
+
+                if (is_master()) {
+
+                        if (route == _session.control_out()) {
+                                listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::MainListen)));
+                        } else {
+                                listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
+                        }
+
+                } else {
+                        listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
+                        if (route == _session.control_out()) {
+                        }
+                }
 
 	} catch (failed_constructor& err) {
 		return -1;
@@ -2369,8 +2382,11 @@ Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*a
 
 	if (route == _session.control_out()) {
 		_control_outs = listener;
+                /* send to control/listen/monitor bus is active by default */
+                listener->activate ();
 	}
 
+
 	add_processor (listener, placement);
 
 	return 0;

libs/ardour/send.cc

@@ -260,9 +260,9 @@ Send::display_to_user () const
 {
 	/* we ignore Deliver::_display_to_user */
 
-	if (_role == Listen) {
+//	if (_role == Listen || _role == MainListen) {
-		return false;
+//		return false;
-	}
+//	}
 
 	return true;
 }

libs/ardour/session.cc

@@ -806,13 +806,20 @@ Session::hookup_io ()
 
 		for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
 
-			if ((*x)->is_control() || (*x)->is_master()) {
+			if ((*x)->is_control()) {
-				continue;
-			}
 
-			(*x)->listen_via (_control_out,
+				/* relax */
-					  (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+
-					  false, false);
+			} else if ((*x)->is_master()) {
+
+                                (*x)->listen_via (_control_out, PostFader, false, false);
+
+                        } else {
+
+                                (*x)->listen_via (_control_out,
+                                                  (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+                                                  false, false);
+                        }
 		}
 	}
 
@@ -2068,12 +2075,15 @@ Session::add_routes (RouteList& new_routes, bool save)
 	if (_control_out && IO::connecting_legal) {
 
 		for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
-			if ((*x)->is_control() || (*x)->is_master()) {
+			if ((*x)->is_control()) {
-				continue;
+                                /* relax */
-			}
+                        } else if ((*x)->is_master()) {
-			(*x)->listen_via (_control_out,
+                                (*x)->listen_via (_control_out, PostFader, false, false);
-					  (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+			} else {
-					  false, false);
+                                (*x)->listen_via (_control_out,
+                                                  (Config->get_listen_position() == AfterFaderListen ? PostFader : PreFader),
+                                                  false, false);
+                        }
 		}
 
 		resort_routes ();
@@ -2399,6 +2409,8 @@ Session::update_route_solo_state (boost::shared_ptr<RouteList> r)
 		}
 	}
 
+        cerr << "something soloed ? " << something_soloed << endl;
+
 	if (something_soloed != _non_soloed_outs_muted) {
 		_non_soloed_outs_muted = something_soloed;
 		SoloActive (_non_soloed_outs_muted); /* EMIT SIGNAL */