promote Playlist::RegionList to ARDOUR::RegionList; fix timefx on multiple regions...

[ardour.git] / libs / ardour / route.cc

diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index de2e801d31e87ef3475adaeda40ae83139840569..acc353f7dbb4e2526af14e872921c73e2c2b56de 100644 (file)
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -145,6 +145,8 @@ Route::init ()
        _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
        _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 
+       _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
+
        /* add amp processor  */
 
        _amp.reset (new Amp (_session));
@@ -511,18 +513,19 @@ Route::process_output_buffers (BufferSet& bufs,
 
        for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 
-               if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
-                       break;
+               if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
+                       /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
+                       continue;
                }
 
-               if (boost::dynamic_pointer_cast<PeakMeter> (*i) && meter_already_run) {
-                       /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
+               if (Config->get_plugins_stop_with_transport() && _session.transport_speed() == 0 && boost::dynamic_pointer_cast<PluginInsert> (*i)) {
+                       /* don't run plugins with the transport stopped, if configured this way */
                        continue;
                }
                
 #ifndef NDEBUG
                /* if it has any inputs, make sure they match */
-               if ((*i)->input_streams() != ChanCount::ZERO) {
+               if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
                        if (bufs.count() != (*i)->input_streams()) {
                                cerr << _name << " bufs = " << bufs.count()
                                     << " input for " << (*i)->name() << " = " << (*i)->input_streams()
@@ -1873,6 +1876,24 @@ Route::state(bool full_state)
        }
 
        for (i = _processors.begin(); i != _processors.end(); ++i) {
+               if (!full_state) {
+                       /* template save: do not include internal sends functioning as 
+                          aux sends because the chance of the target ID
+                          in the session where this template is used
+                          is not very likely.
+
+                          similarly, do not save listen sends which connect to
+                          the monitor section, because these will always be
+                          added if necessary.
+                       */
+                       boost::shared_ptr<InternalSend> is;
+
+                       if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
+                               if (is->role() == Delivery::Aux || is->role() == Delivery::Listen) {
+                                       continue;
+                               }
+                       }
+               }
                node->add_child_nocopy((*i)->state (full_state));
        }
 
@@ -2565,6 +2586,7 @@ Route::add_send_to_internal_return (InternalSend* send)
 void
 Route::remove_send_from_internal_return (InternalSend* send)
 {
+       Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
        Glib::RWLock::ReaderLock rm (_processor_lock);
 
        for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
@@ -2595,12 +2617,12 @@ Route::enable_monitor_send ()
        configure_processors (0);
 }
 
-/** Add an internal send to a route.
+/** Add an aux send to a route.
  *  @param route route to send to.
  *  @param placement placement for the send.
  */
 int
-Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
+Route::add_aux_send (boost::shared_ptr<Route> route, Placement placement)
 {
        assert (route != _session.monitor_out ());
 
@@ -2619,7 +2641,14 @@ Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
        }
 
        try {
-               boost::shared_ptr<InternalSend> listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
+
+               boost::shared_ptr<InternalSend> listener;
+
+               {
+                       Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+                       listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
+               }
+
                add_processor (listener, placement);
 
        } catch (failed_constructor& err) {
@@ -2630,7 +2659,7 @@ Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
 }
 
 void
-Route::drop_listen (boost::shared_ptr<Route> route)
+Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
 {
        ProcessorStreams err;
        ProcessorList::iterator tmp;
@@ -2793,15 +2822,61 @@ Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_lo
        _roll_delay = _initial_delay;
 }
 
-/** Called with the process lock held if change contains ConfigurationChanged */
 void
 Route::input_change_handler (IOChange change, void * /*src*/)
 {
+       bool need_to_queue_solo_change = true;
+
        if ((change.type & IOChange::ConfigurationChanged)) {
+               /* This is called with the process lock held if change 
+                  contains ConfigurationChanged 
+               */
+               need_to_queue_solo_change = false;
                configure_processors (0);
                _phase_invert.resize (_input->n_ports().n_audio ());
                io_changed (); /* EMIT SIGNAL */
        }
+
+       if (!_input->connected() && _soloed_by_others_upstream) {
+               if (need_to_queue_solo_change) {
+                       _session.cancel_solo_after_disconnect (shared_from_this(), true);
+               } else {
+                       cancel_solo_after_disconnect (true);
+               }
+       }
+}
+
+void
+Route::output_change_handler (IOChange change, void * /*src*/)
+{
+       bool need_to_queue_solo_change = true;
+
+       if ((change.type & IOChange::ConfigurationChanged)) {
+               /* This is called with the process lock held if change 
+                  contains ConfigurationChanged 
+               */
+               need_to_queue_solo_change = false;
+       }
+
+       if (!_output->connected() && _soloed_by_others_downstream) {
+               if (need_to_queue_solo_change) {
+                       _session.cancel_solo_after_disconnect (shared_from_this(), false);
+               } else {
+                       cancel_solo_after_disconnect (false);
+               }
+       }
+}
+
+void
+Route::cancel_solo_after_disconnect (bool upstream)
+{
+       if (upstream) {
+               _soloed_by_others_upstream = 0;
+       } else {
+               _soloed_by_others_downstream = 0;
+       }
+       set_mute_master_solo ();
+       solo_changed (false, this);
 }
 
 uint32_t