libs/ardour/route.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "libardour-config.h"
  22 #endif
  23
  24 #include <cmath>
  25 #include <cassert>
  26 #include <algorithm>
  27
  28 #include <glibmm.h>
  29 #include <boost/algorithm/string.hpp>
  30
  31 #include "pbd/xml++.h"
  32 #include "pbd/enumwriter.h"
  33 #include "pbd/locale_guard.h"
  34 #include "pbd/memento_command.h"
  35 #include "pbd/stacktrace.h"
  36 #include "pbd/types_convert.h"
  37 #include "pbd/unwind.h"
  38
  39 #include "ardour/amp.h"
  40 #include "ardour/audio_buffer.h"
  41 #include "ardour/audio_track.h"
  42 #include "ardour/audio_port.h"
  43 #include "ardour/audioengine.h"
  44 #include "ardour/boost_debug.h"
  45 #include "ardour/buffer.h"
  46 #include "ardour/buffer_set.h"
  47 #include "ardour/capturing_processor.h"
  48 #include "ardour/debug.h"
  49 #include "ardour/delivery.h"
  50 #include "ardour/event_type_map.h"
  51 #include "ardour/gain_control.h"
  52 #include "ardour/internal_return.h"
  53 #include "ardour/internal_send.h"
  54 #include "ardour/meter.h"
  55 #include "ardour/delayline.h"
  56 #include "ardour/midi_buffer.h"
  57 #include "ardour/midi_port.h"
  58 #include "ardour/monitor_processor.h"
  59 #include "ardour/pannable.h"
  60 #include "ardour/panner.h"
  61 #include "ardour/panner_shell.h"
  62 #include "ardour/parameter_descriptor.h"
  63 #include "ardour/phase_control.h"
  64 #include "ardour/plugin_insert.h"
  65 #include "ardour/port.h"
  66 #include "ardour/port_insert.h"
  67 #include "ardour/processor.h"
  68 #include "ardour/profile.h"
  69 #include "ardour/route.h"
  70 #include "ardour/route_group.h"
  71 #include "ardour/send.h"
  72 #include "ardour/session.h"
  73 #include "ardour/solo_control.h"
  74 #include "ardour/solo_isolate_control.h"
  75 #include "ardour/types_convert.h"
  76 #include "ardour/unknown_processor.h"
  77 #include "ardour/utils.h"
  78 #include "ardour/vca.h"
  79
  80 #include "pbd/i18n.h"
  81
  82 using namespace std;
  83 using namespace ARDOUR;
  84 using namespace PBD;
  85
  86 PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, Route::PluginSetupOptions > Route::PluginSetup;
  87
  88 /** Base class for all routable/mixable objects (tracks and busses) */
  89 Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType default_type)
  90         : Stripable (sess, name, PresentationInfo (flag))
  91         , GraphNode (sess._process_graph)
  92         , Muteable (sess, name)
  93         , _active (true)
  94         , _signal_latency (0)
  95         , _signal_latency_at_amp_position (0)
  96         , _signal_latency_at_trim_position (0)
  97         , _initial_delay (0)
  98         , _roll_delay (0)
  99         , _pending_process_reorder (0)
 100         , _pending_signals (0)
 101         , _pending_declick (true)
 102         , _meter_point (MeterPostFader)
 103         , _pending_meter_point (MeterPostFader)
 104         , _meter_type (MeterPeak)
 105         , _denormal_protection (false)
 106         , _recordable (true)
 107         , _silent (false)
 108         , _declickable (false)
 109         , _have_internal_generator (false)
 110         , _default_type (default_type)
 111         , _track_number (0)
 112         , _in_configure_processors (false)
 113         , _initial_io_setup (false)
 114         , _in_sidechain_setup (false)
 115         , _strict_io (false)
 116         , _custom_meter_position_noted (false)
 117         , _pinmgr_proxy (0)
 118 {
 119         processor_max_streams.reset();
 120 }
 121
 122 boost::weak_ptr<Route>
 123 Route::weakroute () {
 124         return boost::weak_ptr<Route> (boost::dynamic_pointer_cast<Route> (shared_from_this ()));
 125 }
 126
 127 int
 128 Route::init ()
 129 {
 130         /* set default meter type */
 131         if (is_master()) {
 132                 _meter_type = Config->get_meter_type_master ();
 133         }
 134         else if (dynamic_cast<Track*>(this)) {
 135                 _meter_type = Config->get_meter_type_track ();
 136         } else {
 137                 _meter_type = Config->get_meter_type_bus ();
 138         }
 139
 140         /* add standard controls */
 141
 142         _gain_control.reset (new GainControl (_session, GainAutomation));
 143         _trim_control.reset (new GainControl (_session, TrimAutomation));
 144         /* While the route has-a gain-control for consistency with Stripable and VCA
 145          * ownership is handed over to the Amp Processor which manages the
 146          * state of the Control and AutomationList as part of its
 147          * Automatable API. -- Don't call add_control () here.
 148          */
 149
 150         _solo_control.reset (new SoloControl (_session, X_("solo"), *this, *this));
 151         add_control (_solo_control);
 152         _solo_control->Changed.connect_same_thread (*this, boost::bind (&Route::solo_control_changed, this, _1, _2));
 153
 154         _mute_control.reset (new MuteControl (_session, X_("mute"), *this));
 155         add_control (_mute_control);
 156
 157         _phase_control.reset (new PhaseControl (_session, X_("phase")));
 158         add_control (_phase_control);
 159
 160         _solo_isolate_control.reset (new SoloIsolateControl (_session, X_("solo-iso"), *this, *this));
 161         add_control (_solo_isolate_control);
 162
 163         _solo_safe_control.reset (new SoloSafeControl (_session, X_("solo-safe")));
 164         add_control (_solo_safe_control);
 165
 166         /* panning */
 167
 168         if (!(_presentation_info.flags() & PresentationInfo::MonitorOut)) {
 169                 _pannable.reset (new Pannable (_session));
 170         }
 171
 172         /* input and output objects */
 173
 174         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 175         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 176
 177         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
 178         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 179
 180         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
 181         _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1));
 182
 183         /* add the amp/fader processor.
 184          * it should be the first processor to be added on every route.
 185          */
 186
 187         _amp.reset (new Amp (_session, X_("Fader"), _gain_control, true));
 188         add_processor (_amp, PostFader);
 189
 190         if (is_monitor ()) {
 191                 _amp->set_display_name (_("Monitor"));
 192         }
 193
 194 #if 0 // not used - just yet
 195         if (!is_master() && !is_monitor() && !is_auditioner()) {
 196                 _delayline.reset (new DelayLine (_session, _name));
 197                 add_processor (_delayline, PreFader);
 198         }
 199 #endif
 200
 201         /* and input trim */
 202
 203         _trim.reset (new Amp (_session, X_("Trim"), _trim_control, false));
 204         _trim->set_display_to_user (false);
 205
 206         if (dynamic_cast<AudioTrack*>(this)) {
 207                 /* we can't do this in the AudioTrack's constructor
 208                  * because _trim does not exit then
 209                  */
 210                 _trim->activate();
 211         }
 212         else if (!dynamic_cast<Track*>(this) && ! ( is_monitor() || is_auditioner() )) {
 213                 /* regular bus */
 214                 _trim->activate();
 215         }
 216
 217         /* create standard processors: meter, main outs, monitor out;
 218            they will be added to _processors by setup_invisible_processors ()
 219         */
 220
 221         _meter.reset (new PeakMeter (_session, _name));
 222         _meter->set_owner (this);
 223         _meter->set_display_to_user (false);
 224         _meter->activate ();
 225
 226         _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
 227         _main_outs->activate ();
 228
 229         if (is_monitor()) {
 230                 /* where we listen to tracks */
 231                 _intreturn.reset (new InternalReturn (_session));
 232                 _intreturn->activate ();
 233
 234                 /* the thing that provides proper control over a control/monitor/listen bus
 235                    (such as per-channel cut, dim, solo, invert, etc).
 236                 */
 237                 _monitor_control.reset (new MonitorProcessor (_session));
 238                 _monitor_control->activate ();
 239         }
 240
 241         /* now that we have _meter, its safe to connect to this */
 242
 243         {
 244                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 245                 configure_processors (0);
 246         }
 247
 248         return 0;
 249 }
 250
 251 Route::~Route ()
 252 {
 253         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
 254
 255         /* do this early so that we don't get incoming signals as we are going through destruction
 256          */
 257
 258         drop_connections ();
 259
 260         /* don't use clear_processors here, as it depends on the session which may
 261            be half-destroyed by now
 262         */
 263
 264         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 265         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 266                 (*i)->drop_references ();
 267         }
 268
 269         _processors.clear ();
 270 }
 271
 272 string
 273 Route::ensure_track_or_route_name(string name, Session &session)
 274 {
 275         string newname = name;
 276
 277         while (!session.io_name_is_legal (newname)) {
 278                 newname = bump_name_once (newname, ' ');
 279         }
 280
 281         return newname;
 282 }
 283
 284 void
 285 Route::set_trim (gain_t val, Controllable::GroupControlDisposition /* group override */)
 286 {
 287         // TODO route group, see set_gain()
 288         // _trim_control->route_set_value (val);
 289 }
 290
 291 void
 292 Route::maybe_declick (BufferSet&, framecnt_t, int)
 293 {
 294         /* this is the "bus" implementation and they never declick.
 295          */
 296         return;
 297 }
 298
 299 /** Process this route for one (sub) cycle (process thread)
 300  *
 301  * @param bufs Scratch buffers to use for the signal path
 302  * @param start_frame Initial transport frame
 303  * @param end_frame Final transport frame
 304  * @param nframes Number of frames to output (to ports)
 305  *
 306  * Note that (end_frame - start_frame) may not be equal to nframes when the
 307  * transport speed isn't 1.0 (eg varispeed).
 308  */
 309 void
 310 Route::process_output_buffers (BufferSet& bufs,
 311                                framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
 312                                int declick, bool gain_automation_ok)
 313 {
 314         /* Caller must hold process lock */
 315         assert (!AudioEngine::instance()->process_lock().trylock());
 316
 317         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 318         if (!lm.locked()) {
 319                 // can this actually happen? functions calling process_output_buffers()
 320                 // already take a reader-lock.
 321                 bufs.silence (nframes, 0);
 322                 return;
 323         }
 324
 325         _mute_control->automation_run (start_frame, nframes);
 326
 327         /* figure out if we're going to use gain automation */
 328         if (gain_automation_ok) {
 329                 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
 330                 _amp->setup_gain_automation (
 331                                 start_frame + _signal_latency_at_amp_position,
 332                                 end_frame + _signal_latency_at_amp_position,
 333                                 nframes);
 334
 335                 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
 336                 _trim->setup_gain_automation (
 337                                 start_frame + _signal_latency_at_trim_position,
 338                                 end_frame + _signal_latency_at_trim_position,
 339                                 nframes);
 340         } else {
 341                 _amp->apply_gain_automation (false);
 342                 _trim->apply_gain_automation (false);
 343         }
 344
 345         /* Tell main outs what to do about monitoring.  We do this so that
 346            on a transition between monitoring states we get a de-clicking gain
 347            change in the _main_outs delivery, if config.get_use_monitor_fades()
 348            is true.
 349
 350            We override this in the case where we have an internal generator.
 351         */
 352         bool silence = _have_internal_generator ? false : (monitoring_state () == MonitoringSilence);
 353
 354         _main_outs->no_outs_cuz_we_no_monitor (silence);
 355
 356         /* -------------------------------------------------------------------------------------------
 357            GLOBAL DECLICK (for transport changes etc.)
 358            ----------------------------------------------------------------------------------------- */
 359
 360         maybe_declick (bufs, nframes, declick);
 361         _pending_declick = 0;
 362
 363         /* -------------------------------------------------------------------------------------------
 364            DENORMAL CONTROL/PHASE INVERT
 365            ----------------------------------------------------------------------------------------- */
 366
 367         if (!_phase_control->none()) {
 368
 369                 int chn = 0;
 370
 371                 if (_denormal_protection || Config->get_denormal_protection()) {
 372
 373                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 374                                 Sample* const sp = i->data();
 375
 376                                 if (_phase_control->inverted (chn)) {
 377                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 378                                                 sp[nx]  = -sp[nx];
 379                                                 sp[nx] += 1.0e-27f;
 380                                         }
 381                                 } else {
 382                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 383                                                 sp[nx] += 1.0e-27f;
 384                                         }
 385                                 }
 386                         }
 387
 388                 } else {
 389
 390                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 391                                 Sample* const sp = i->data();
 392
 393                                 if (_phase_control->inverted (chn)) {
 394                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 395                                                 sp[nx] = -sp[nx];
 396                                         }
 397                                 }
 398                         }
 399                 }
 400
 401         } else {
 402
 403                 if (_denormal_protection || Config->get_denormal_protection()) {
 404
 405                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 406                                 Sample* const sp = i->data();
 407                                 for (pframes_t nx = 0; nx < nframes; ++nx) {
 408                                         sp[nx] += 1.0e-27f;
 409                                 }
 410                         }
 411
 412                 }
 413         }
 414
 415         /* -------------------------------------------------------------------------------------------
 416            and go ....
 417            ----------------------------------------------------------------------------------------- */
 418
 419         /* set this to be true if the meter will already have been ::run() earlier */
 420         bool const meter_already_run = metering_state() == MeteringInput;
 421
 422         framecnt_t latency = 0;
 423         const double speed = _session.transport_speed ();
 424
 425         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 426
 427                 if (meter_already_run && boost::dynamic_pointer_cast<PeakMeter> (*i)) {
 428                         /* don't ::run() the meter, otherwise it will have its previous peak corrupted */
 429                         continue;
 430                 }
 431
 432 #ifndef NDEBUG
 433                 /* if it has any inputs, make sure they match */
 434                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
 435                         if (bufs.count() != (*i)->input_streams()) {
 436                                 DEBUG_TRACE (
 437                                         DEBUG::Processors, string_compose (
 438                                                 "input port mismatch %1 bufs = %2 input for %3 = %4\n",
 439                                                 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
 440                                                 )
 441                                         );
 442                         }
 443                 }
 444 #endif
 445
 446                 /* should we NOT run plugins here if the route is inactive?
 447                    do we catch route != active somewhere higher?
 448                 */
 449
 450                 if (boost::dynamic_pointer_cast<Send>(*i) != 0) {
 451                         boost::dynamic_pointer_cast<Send>(*i)->set_delay_in(_signal_latency - latency);
 452                 }
 453                 if (boost::dynamic_pointer_cast<PluginInsert>(*i) != 0) {
 454                         const framecnt_t longest_session_latency = _initial_delay + _signal_latency;
 455                         boost::dynamic_pointer_cast<PluginInsert>(*i)->set_sidechain_latency (
 456                                         _initial_delay + latency, longest_session_latency - latency);
 457                 }
 458
 459                 (*i)->run (bufs, start_frame - latency, end_frame - latency, speed, nframes, *i != _processors.back());
 460                 bufs.set_count ((*i)->output_streams());
 461
 462                 if ((*i)->active ()) {
 463                         latency += (*i)->signal_latency ();
 464                 }
 465         }
 466 }
 467
 468 void
 469 Route::bounce_process (BufferSet& buffers, framepos_t start, framecnt_t nframes,
 470                 boost::shared_ptr<Processor> endpoint,
 471                 bool include_endpoint, bool for_export, bool for_freeze)
 472 {
 473         /* If no processing is required, there's no need to go any further. */
 474         if (!endpoint && !include_endpoint) {
 475                 return;
 476         }
 477
 478         framecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
 479         _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
 480         _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
 481
 482         /* trim is always at the top, for bounce no latency compensation is needed */
 483         _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
 484         _trim->setup_gain_automation (start, start + nframes, nframes);
 485
 486         latency = 0;
 487         const double speed = _session.transport_speed ();
 488         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 489
 490                 if (!include_endpoint && (*i) == endpoint) {
 491                         break;
 492                 }
 493
 494                 /* if we're *not* exporting, stop processing if we come across a routing processor. */
 495                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 496                         break;
 497                 }
 498                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 499                         break;
 500                 }
 501
 502                 /* special case the panner (export outputs)
 503                  * Ideally we'd only run the panner, not the delivery itself...
 504                  * but panners need separate input/output buffers and some context
 505                  * (panshell, panner type, etc). AFAICT there is no ill side effect
 506                  * of re-using the main delivery when freewheeling/exporting a region.
 507                  */
 508                 if ((*i) == _main_outs) {
 509                         assert ((*i)->does_routing());
 510                         (*i)->run (buffers, start - latency, start - latency + nframes, speed, nframes, true);
 511                         buffers.set_count ((*i)->output_streams());
 512                 }
 513
 514                 /* don't run any processors that do routing.
 515                  * Also don't bother with metering.
 516                  */
 517                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 518                         (*i)->run (buffers, start - latency, start - latency + nframes, 1.0, nframes, true);
 519                         buffers.set_count ((*i)->output_streams());
 520                         latency += (*i)->signal_latency ();
 521                 }
 522
 523                 if ((*i) == endpoint) {
 524                         break;
 525                 }
 526         }
 527 }
 528
 529 framecnt_t
 530 Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
 531                 bool include_endpoint, bool for_export, bool for_freeze) const
 532 {
 533         framecnt_t latency = 0;
 534         if (!endpoint && !include_endpoint) {
 535                 return latency;
 536         }
 537
 538         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 539                 if (!include_endpoint && (*i) == endpoint) {
 540                         break;
 541                 }
 542                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 543                         break;
 544                 }
 545                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 546                         break;
 547                 }
 548                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 549                         latency += (*i)->signal_latency ();
 550                 }
 551                 if ((*i) == endpoint) {
 552                         break;
 553                 }
 554         }
 555         return latency;
 556 }
 557
 558 ChanCount
 559 Route::bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint,
 560                 bool include_endpoint, bool for_export, bool for_freeze) const
 561 {
 562         if (!endpoint && !include_endpoint) {
 563                 return cc;
 564         }
 565
 566         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 567                 if (!include_endpoint && (*i) == endpoint) {
 568                         break;
 569                 }
 570                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 571                         break;
 572                 }
 573                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 574                         break;
 575                 }
 576                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 577                         cc = (*i)->output_streams();
 578                 }
 579                 if ((*i) == endpoint) {
 580                         break;
 581                 }
 582         }
 583         return cc;
 584 }
 585
 586 ChanCount
 587 Route::n_process_buffers ()
 588 {
 589         return max (_input->n_ports(), processor_max_streams);
 590 }
 591
 592 void
 593 Route::monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 594 {
 595         assert (is_monitor());
 596         BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
 597         fill_buffers_with_input (bufs, _input, nframes);
 598         passthru (bufs, start_frame, end_frame, nframes, declick);
 599 }
 600
 601 void
 602 Route::passthru (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 603 {
 604         _silent = false;
 605
 606         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
 607
 608                 /* control/monitor bus ignores input ports when something is
 609                    feeding the listen "stream". data will "arrive" into the
 610                    route from the intreturn processor element.
 611                 */
 612
 613                 bufs.silence (nframes, 0);
 614         }
 615
 616         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 617         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, true);
 618 }
 619
 620 void
 621 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 622 {
 623         BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
 624
 625         bufs.set_count (_input->n_ports());
 626         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 627         process_output_buffers (bufs, start_frame, end_frame, nframes, declick, false);
 628 }
 629
 630 void
 631 Route::set_listen (bool yn)
 632 {
 633         if (_monitor_send) {
 634                 if (_monitor_send->active() == yn) {
 635                         return;
 636                 }
 637                 if (yn) {
 638                         _monitor_send->activate ();
 639                 } else {
 640                         _monitor_send->deactivate ();
 641                 }
 642         }
 643 }
 644
 645 void
 646 Route::solo_control_changed (bool, Controllable::GroupControlDisposition)
 647 {
 648         /* nothing to do if we're not using AFL/PFL. But if we are, we need
 649            to alter the active state of the monitor send.
 650         */
 651
 652         if (Config->get_solo_control_is_listen_control ()) {
 653                 set_listen (_solo_control->self_soloed() || _solo_control->get_masters_value());
 654         }
 655 }
 656
 657 void
 658 Route::push_solo_isolate_upstream (int32_t delta)
 659 {
 660         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
 661
 662         boost::shared_ptr<RouteList> routes = _session.get_routes ();
 663         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 664
 665                 if ((*i).get() == this || !(*i)->can_solo()) {
 666                         continue;
 667                 }
 668
 669                 bool sends_only;
 670                 bool does_feed = feeds (*i, &sends_only);
 671
 672                 if (does_feed && !sends_only) {
 673                         (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (delta);
 674                 }
 675         }
 676 }
 677
 678 void
 679 Route::push_solo_upstream (int delta)
 680 {
 681         DEBUG_TRACE (DEBUG::Solo, string_compose("\t ... INVERT push from %1\n", _name));
 682         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
 683                 if (i->sends_only) {
 684                         continue;
 685                 }
 686                 boost::shared_ptr<Route> sr (i->r.lock());
 687                 if (sr) {
 688                         sr->solo_control()->mod_solo_by_others_downstream (-delta);
 689                 }
 690         }
 691 }
 692
 693 #if 0
 694 static void
 695 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 696 {
 697         cerr << name << " {" << endl;
 698         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 699                         p != procs.end(); ++p) {
 700                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
 701         }
 702         cerr << "}" << endl;
 703 }
 704 #endif
 705
 706 /** Supposing that we want to insert a Processor at a given Placement, return
 707  *  the processor to add the new one before (or 0 to add at the end).
 708  */
 709 boost::shared_ptr<Processor>
 710 Route::before_processor_for_placement (Placement p)
 711 {
 712         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 713
 714         ProcessorList::iterator loc;
 715
 716         if (p == PreFader) {
 717                 /* generic pre-fader: insert immediately before the amp */
 718                 loc = find (_processors.begin(), _processors.end(), _amp);
 719         } else {
 720                 /* generic post-fader: insert right before the main outs */
 721                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 722         }
 723
 724         return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
 725 }
 726
 727 /** Supposing that we want to insert a Processor at a given index, return
 728  *  the processor to add the new one before (or 0 to add at the end).
 729  */
 730 boost::shared_ptr<Processor>
 731 Route::before_processor_for_index (int index)
 732 {
 733         if (index == -1) {
 734                 return boost::shared_ptr<Processor> ();
 735         }
 736
 737         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 738
 739         ProcessorList::iterator i = _processors.begin ();
 740         int j = 0;
 741         while (i != _processors.end() && j < index) {
 742                 if ((*i)->display_to_user()) {
 743                         ++j;
 744                 }
 745
 746                 ++i;
 747         }
 748
 749         return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
 750 }
 751
 752 /** Add a processor either pre- or post-fader
 753  *  @return 0 on success, non-0 on failure.
 754  */
 755 int
 756 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
 757 {
 758         return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
 759 }
 760
 761
 762 /** Add a processor to a route such that it ends up with a given index into the visible processors.
 763  *  @param index Index to add the processor at, or -1 to add at the end of the list.
 764  *  @return 0 on success, non-0 on failure.
 765  */
 766 int
 767 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
 768 {
 769         return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
 770 }
 771
 772 /** Add a processor to the route.
 773  *  @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
 774  *  @return 0 on success, non-0 on failure.
 775  */
 776 int
 777 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
 778 {
 779         assert (processor != _meter);
 780         assert (processor != _main_outs);
 781
 782         DEBUG_TRACE (DEBUG::Processors, string_compose (
 783                              "%1 adding processor %2\n", name(), processor->name()));
 784
 785         ProcessorList pl;
 786
 787         pl.push_back (processor);
 788         int rv = add_processors (pl, before, err);
 789
 790         if (rv) {
 791                 return rv;
 792         }
 793
 794         if (activation_allowed && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user ())) {
 795                 processor->activate ();
 796         }
 797
 798         return 0;
 799 }
 800
 801 void
 802 Route::processor_selfdestruct (boost::weak_ptr<Processor> wp)
 803 {
 804         /* We cannot destruct the processor here (usually RT-thread
 805          * with various locks held - in case of sends also io_locks).
 806          * Queue for deletion in low-priority thread.
 807          */
 808         Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
 809         selfdestruct_sequence.push_back (wp);
 810 }
 811
 812 bool
 813 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
 814 {
 815         XMLProperty const * prop;
 816
 817         try {
 818                 boost::shared_ptr<Processor> processor;
 819
 820                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
 821                    so that we can add the processor in the right place (pre/post-fader)
 822                 */
 823
 824                 XMLNodeList const & children = node.children ();
 825                 XMLNodeList::const_iterator i = children.begin ();
 826
 827                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
 828                         ++i;
 829                 }
 830
 831                 Placement placement = PreFader;
 832
 833                 if (i != children.end()) {
 834                         if ((prop = (*i)->property (X_("placement"))) != 0) {
 835                                 placement = Placement (string_2_enum (prop->value(), placement));
 836                         }
 837                 }
 838
 839                 if (node.name() == "Insert") {
 840
 841                         if ((prop = node.property ("type")) != 0) {
 842
 843                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 844                                                 prop->value() == "lv2" ||
 845                                                 prop->value() == "windows-vst" ||
 846                                                 prop->value() == "mac-vst" ||
 847                                                 prop->value() == "lxvst" ||
 848                                                 prop->value() == "audiounit") {
 849
 850                                         if (_session.get_disable_all_loaded_plugins ()) {
 851                                                 processor.reset (new UnknownProcessor (_session, node));
 852                                         } else {
 853                                                 processor.reset (new PluginInsert (_session));
 854                                                 processor->set_owner (this);
 855                                         }
 856
 857                                 } else {
 858
 859                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
 860                                 }
 861
 862                         }
 863
 864                 } else if (node.name() == "Send") {
 865
 866                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
 867                         processor.reset (new Send (_session, sendpan, _mute_master));
 868
 869                 } else {
 870
 871                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
 872                         return false;
 873                 }
 874
 875                 if (processor->set_state (node, version)) {
 876                         return false;
 877                 }
 878
 879                 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
 880                 if (i != children.end()) {
 881                         if ((prop = (*i)->property (X_("active"))) != 0) {
 882                                 if ( string_to<bool> (prop->value()) && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user () ) )
 883                                         processor->activate();
 884                                 else
 885                                         processor->deactivate();
 886                         }
 887                 }
 888
 889                 return (add_processor (processor, placement, 0, false) == 0);
 890         }
 891
 892         catch (failed_constructor &err) {
 893                 warning << _("processor could not be created. Ignored.") << endmsg;
 894                 return false;
 895         }
 896 }
 897
 898
 899 inline Route::PluginSetupOptions operator|= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
 900         return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) | static_cast<int> (b));
 901 }
 902
 903 inline Route::PluginSetupOptions operator&= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
 904         return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) & static_cast<int> (b));
 905 }
 906
 907 int
 908 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
 909 {
 910         ProcessorList::iterator loc;
 911         boost::shared_ptr <PluginInsert> fanout;
 912
 913         if (g_atomic_int_get (&_pending_process_reorder)) {
 914                 /* we need to flush any pending re-order changes */
 915                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 916                 apply_processor_changes_rt ();
 917         }
 918
 919         if (before) {
 920                 loc = find(_processors.begin(), _processors.end(), before);
 921                 if (loc == _processors.end ()) {
 922                         return 1;
 923                 }
 924         } else {
 925                 /* nothing specified - at end */
 926                 loc = _processors.end ();
 927         }
 928
 929         if (!AudioEngine::instance()->connected()) {
 930                 return 1;
 931         }
 932
 933         if (others.empty()) {
 934                 return 0;
 935         }
 936
 937         ProcessorList to_skip;
 938
 939         // check if there's an instrument to replace or configure
 940         for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 941                 boost::shared_ptr<PluginInsert> pi;
 942                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) == 0) {
 943                         continue;
 944                 }
 945                 if (!pi->plugin ()->get_info ()->is_instrument ()) {
 946                         continue;
 947                 }
 948                 boost::shared_ptr<Processor> instrument = the_instrument ();
 949                 ChanCount in (DataType::MIDI, 1);
 950                 ChanCount out (DataType::AUDIO, 2); // XXX route's out?!
 951
 952                 PluginSetupOptions flags = None;
 953                 if (instrument) {
 954                         flags |= CanReplace;
 955                         in = instrument->input_streams ();
 956                         out = instrument->output_streams ();
 957                 }
 958                 if (pi->has_output_presets (in, out)) {
 959                         flags |= MultiOut;
 960                 }
 961
 962                 pi->set_strict_io (_strict_io);
 963
 964                 PluginSetupOptions mask = None;
 965                 if (Config->get_ask_replace_instrument ()) {
 966                         mask |= CanReplace;
 967                 }
 968                 if (Config->get_ask_setup_instrument ()) {
 969                         mask |= MultiOut;
 970                 }
 971
 972                 flags &= mask;
 973
 974                 if (flags != None) {
 975                         boost::optional<int> rv = PluginSetup (boost::dynamic_pointer_cast<Route>(shared_from_this ()), pi, flags);  /* EMIT SIGNAL */
 976                         int mode = rv.get_value_or (0);
 977                         switch (mode & 3) {
 978                                 case 1:
 979                                         to_skip.push_back (*i); // don't add this one;
 980                                         break;
 981                                 case 2:
 982                                         replace_processor (instrument, *i, err);
 983                                         to_skip.push_back (*i);
 984                                         break;
 985                                 default:
 986                                         break;
 987                         }
 988                         if ((mode & 5) == 4) {
 989                                 fanout = pi;
 990                         }
 991                 }
 992         }
 993
 994         {
 995                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 996                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 997                 ProcessorState pstate (this);
 998
 999                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1000
1001                         if (*i == _meter) {
1002                                 continue;
1003                         }
1004                         ProcessorList::iterator check = find (to_skip.begin(), to_skip.end(), *i);
1005                         if (check != to_skip.end()) {
1006                                 continue;
1007                         }
1008
1009                         boost::shared_ptr<PluginInsert> pi;
1010
1011                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1012                                 pi->set_strict_io (_strict_io);
1013                         }
1014
1015                         if (*i == _amp) {
1016                                 /* Ensure that only one amp is in the list at any time */
1017                                 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), *i);
1018                                 if (check != _processors.end()) {
1019                                         if (before == _amp) {
1020                                                 /* Already in position; all is well */
1021                                                 continue;
1022                                         } else {
1023                                                 _processors.erase (check);
1024                                         }
1025                                 }
1026                         }
1027
1028                         assert (find (_processors.begin(), _processors.end(), *i) == _processors.end ());
1029
1030                         _processors.insert (loc, *i);
1031                         (*i)->set_owner (this);
1032
1033                         {
1034                                 if (configure_processors_unlocked (err, &lm)) {
1035                                         pstate.restore ();
1036                                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
1037                                         return -1;
1038                                 }
1039                         }
1040
1041                         if (pi && pi->has_sidechain ()) {
1042                                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
1043                         }
1044
1045                         if ((*i)->active()) {
1046                                 // emit ActiveChanged() and latency_changed() if needed
1047                                 (*i)->activate ();
1048                         }
1049
1050                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1051
1052                         boost::shared_ptr<Send> send;
1053                         if ((send = boost::dynamic_pointer_cast<Send> (*i))) {
1054                                 send->SelfDestruct.connect_same_thread (*this,
1055                                                 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (*i)));
1056                         }
1057                 }
1058
1059                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1060                         boost::shared_ptr<PluginInsert> pi;
1061
1062                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1063                                 if (pi->has_no_inputs ()) {
1064                                         _have_internal_generator = true;
1065                                         break;
1066                                 }
1067                         }
1068                 }
1069
1070                 _output->set_user_latency (0);
1071         }
1072
1073         reset_instrument_info ();
1074         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1075         set_processor_positions ();
1076
1077         if (fanout && fanout->configured ()
1078                         && fanout->output_streams().n_audio() > 2
1079                         && boost::dynamic_pointer_cast<PluginInsert> (the_instrument ()) == fanout) {
1080                 fan_out (); /* EMIT SIGNAL */
1081         }
1082         return 0;
1083 }
1084
1085 void
1086 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1087 {
1088         if (p == PreFader) {
1089                 start = _processors.begin();
1090                 end = find(_processors.begin(), _processors.end(), _amp);
1091         } else {
1092                 start = find(_processors.begin(), _processors.end(), _amp);
1093                 ++start;
1094                 end = _processors.end();
1095         }
1096 }
1097
1098 /** Turn off all processors with a given placement
1099  * @param p Placement of processors to disable
1100  */
1101 void
1102 Route::disable_processors (Placement p)
1103 {
1104         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1105
1106         ProcessorList::iterator start, end;
1107         placement_range(p, start, end);
1108
1109         for (ProcessorList::iterator i = start; i != end; ++i) {
1110                 (*i)->enable (false);
1111         }
1112
1113         _session.set_dirty ();
1114 }
1115
1116 /** Turn off all redirects
1117  */
1118 void
1119 Route::disable_processors ()
1120 {
1121         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1122
1123         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1124                 (*i)->enable (false);
1125         }
1126
1127         _session.set_dirty ();
1128 }
1129
1130 /** Turn off all redirects with a given placement
1131  * @param p Placement of redirects to disable
1132  */
1133 void
1134 Route::disable_plugins (Placement p)
1135 {
1136         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1137
1138         ProcessorList::iterator start, end;
1139         placement_range(p, start, end);
1140
1141         for (ProcessorList::iterator i = start; i != end; ++i) {
1142                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1143                         (*i)->enable (false);
1144                 }
1145         }
1146
1147         _session.set_dirty ();
1148 }
1149
1150 /** Turn off all plugins
1151  */
1152 void
1153 Route::disable_plugins ()
1154 {
1155         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1156
1157         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1158                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1159                         (*i)->enable (false);
1160                 }
1161         }
1162
1163         _session.set_dirty ();
1164 }
1165
1166
1167 void
1168 Route::ab_plugins (bool forward)
1169 {
1170         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1171
1172         if (forward) {
1173
1174                 /* forward = turn off all active redirects, and mark them so that the next time
1175                    we go the other way, we will revert them
1176                 */
1177
1178                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1179                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1180                                 continue;
1181                         }
1182                         if (!(*i)->display_to_user ()) {
1183                                 continue;
1184                         }
1185 #ifdef MIXBUS
1186                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1187                                 continue;
1188                         }
1189 #endif
1190
1191                         if ((*i)->enabled ()) {
1192                                 (*i)->enable (false);
1193                                 (*i)->set_next_ab_is_active (true);
1194                         } else {
1195                                 (*i)->set_next_ab_is_active (false);
1196                         }
1197                 }
1198
1199         } else {
1200
1201                 /* backward = if the redirect was marked to go active on the next ab, do so */
1202
1203                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1204                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1205                                 continue;
1206                         }
1207                         if (!(*i)->display_to_user ()) {
1208                                 continue;
1209                         }
1210 #ifdef MIXBUS
1211                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1212                                 continue;
1213                         }
1214 #endif
1215
1216                         (*i)->enable ((*i)->get_next_ab_is_active ());
1217                 }
1218         }
1219
1220         _session.set_dirty ();
1221 }
1222
1223
1224 /** Remove processors with a given placement.
1225  * @param p Placement of processors to remove.
1226  */
1227 void
1228 Route::clear_processors (Placement p)
1229 {
1230         if (!_session.engine().connected()) {
1231                 return;
1232         }
1233
1234         bool already_deleting = _session.deletion_in_progress();
1235         if (!already_deleting) {
1236                 _session.set_deletion_in_progress();
1237         }
1238
1239         {
1240                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1241                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1242                 ProcessorList new_list;
1243                 ProcessorStreams err;
1244                 bool seen_amp = false;
1245
1246                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1247
1248                         if (*i == _amp) {
1249                                 seen_amp = true;
1250                         }
1251
1252                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1253
1254                                 /* you can't remove these */
1255
1256                                 new_list.push_back (*i);
1257
1258                         } else {
1259                                 if (seen_amp) {
1260
1261                                         switch (p) {
1262                                         case PreFader:
1263                                                 new_list.push_back (*i);
1264                                                 break;
1265                                         case PostFader:
1266                                                 (*i)->drop_references ();
1267                                                 break;
1268                                         }
1269
1270                                 } else {
1271
1272                                         switch (p) {
1273                                         case PreFader:
1274                                                 (*i)->drop_references ();
1275                                                 break;
1276                                         case PostFader:
1277                                                 new_list.push_back (*i);
1278                                                 break;
1279                                         }
1280                                 }
1281                         }
1282                 }
1283
1284                 _processors = new_list;
1285                 configure_processors_unlocked (&err, &lm); // this can't fail
1286         }
1287
1288         processor_max_streams.reset();
1289         _have_internal_generator = false;
1290         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1291         set_processor_positions ();
1292
1293         reset_instrument_info ();
1294
1295         if (!already_deleting) {
1296                 _session.clear_deletion_in_progress();
1297         }
1298 }
1299
1300 int
1301 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1302 {
1303         // TODO once the export point can be configured properly, do something smarter here
1304         if (processor == _capturing_processor) {
1305                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1306                 if (need_process_lock) {
1307                         lx.acquire();
1308                 }
1309
1310                 _capturing_processor.reset();
1311
1312                 if (need_process_lock) {
1313                         lx.release();
1314                 }
1315         }
1316
1317         /* these can never be removed */
1318
1319         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1320                 return 0;
1321         }
1322
1323         if (!_session.engine().connected()) {
1324                 return 1;
1325         }
1326
1327         processor_max_streams.reset();
1328
1329         {
1330                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1331                 if (need_process_lock) {
1332                         lx.acquire();
1333                 }
1334
1335                 /* Caller must hold process lock */
1336                 assert (!AudioEngine::instance()->process_lock().trylock());
1337
1338                 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1339
1340                 ProcessorState pstate (this);
1341
1342                 ProcessorList::iterator i;
1343                 bool removed = false;
1344
1345                 for (i = _processors.begin(); i != _processors.end(); ) {
1346                         if (*i == processor) {
1347
1348                                 /* move along, see failure case for configure_processors()
1349                                    where we may need to reconfigure the processor.
1350                                 */
1351
1352                                 /* stop redirects that send signals to JACK ports
1353                                    from causing noise as a result of no longer being
1354                                    run.
1355                                 */
1356
1357                                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1358                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
1359
1360                                 if (pi != 0) {
1361                                         assert (iop == 0);
1362                                         iop = pi->sidechain();
1363                                 }
1364
1365                                 if (iop != 0) {
1366                                         iop->disconnect ();
1367                                 }
1368
1369                                 i = _processors.erase (i);
1370                                 removed = true;
1371                                 break;
1372
1373                         } else {
1374                                 ++i;
1375                         }
1376
1377                         _output->set_user_latency (0);
1378                 }
1379
1380                 if (!removed) {
1381                         /* what? */
1382                         return 1;
1383                 }
1384
1385                 if (configure_processors_unlocked (err, &lm)) {
1386                         pstate.restore ();
1387                         /* we know this will work, because it worked before :) */
1388                         configure_processors_unlocked (0, &lm);
1389                         return -1;
1390                 }
1391
1392                 _have_internal_generator = false;
1393
1394                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1395                         boost::shared_ptr<PluginInsert> pi;
1396
1397                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1398                                 if (pi->has_no_inputs ()) {
1399                                         _have_internal_generator = true;
1400                                         break;
1401                                 }
1402                         }
1403                 }
1404                 if (need_process_lock) {
1405                         lx.release();
1406                 }
1407         }
1408
1409         reset_instrument_info ();
1410         processor->drop_references ();
1411         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1412         set_processor_positions ();
1413
1414         return 0;
1415 }
1416
1417 int
1418 Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
1419 {
1420         /* these can never be removed */
1421         if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
1422                 return 1;
1423         }
1424         /* and can't be used as substitute, either */
1425         if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
1426                 return 1;
1427         }
1428
1429         /* I/Os are out, too */
1430         if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
1431                 return 1;
1432         }
1433
1434         /* this function cannot be used to swap/reorder processors */
1435         if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
1436                 return 1;
1437         }
1438
1439         if (!AudioEngine::instance()->connected() || !old || !sub) {
1440                 return 1;
1441         }
1442
1443         /* ensure that sub is not owned by another route */
1444         if (sub->owner ()) {
1445                 return 1;
1446         }
1447
1448         {
1449                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1450                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1451                 ProcessorState pstate (this);
1452
1453                 assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
1454
1455                 ProcessorList::iterator i;
1456                 bool replaced = false;
1457                 bool enable = old->enabled ();
1458
1459                 for (i = _processors.begin(); i != _processors.end(); ) {
1460                         if (*i == old) {
1461                                 i = _processors.erase (i);
1462                                 _processors.insert (i, sub);
1463                                 sub->set_owner (this);
1464                                 replaced = true;
1465                                 break;
1466                         } else {
1467                                 ++i;
1468                         }
1469                 }
1470
1471                 if (!replaced) {
1472                         return 1;
1473                 }
1474
1475                 if (_strict_io) {
1476                         boost::shared_ptr<PluginInsert> pi;
1477                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
1478                                 pi->set_strict_io (true);
1479                         }
1480                 }
1481
1482                 if (configure_processors_unlocked (err, &lm)) {
1483                         pstate.restore ();
1484                         configure_processors_unlocked (0, &lm);
1485                         return -1;
1486                 }
1487
1488                 _have_internal_generator = false;
1489
1490                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1491                         boost::shared_ptr<PluginInsert> pi;
1492                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1493                                 if (pi->has_no_inputs ()) {
1494                                         _have_internal_generator = true;
1495                                         break;
1496                                 }
1497                         }
1498                 }
1499
1500                 if (enable) {
1501                         sub->enable (true);
1502                 }
1503
1504                 sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1505                 _output->set_user_latency (0);
1506         }
1507
1508         reset_instrument_info ();
1509         old->drop_references ();
1510         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1511         set_processor_positions ();
1512         return 0;
1513 }
1514
1515 int
1516 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1517 {
1518         ProcessorList deleted;
1519
1520         if (!_session.engine().connected()) {
1521                 return 1;
1522         }
1523
1524         processor_max_streams.reset();
1525
1526         {
1527                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1528                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1529                 ProcessorState pstate (this);
1530
1531                 ProcessorList::iterator i;
1532                 boost::shared_ptr<Processor> processor;
1533
1534                 for (i = _processors.begin(); i != _processors.end(); ) {
1535
1536                         processor = *i;
1537
1538                         /* these can never be removed */
1539
1540                         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1541                                 ++i;
1542                                 continue;
1543                         }
1544
1545                         /* see if its in the list of processors to delete */
1546
1547                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1548                                 ++i;
1549                                 continue;
1550                         }
1551
1552                         /* stop IOProcessors that send to JACK ports
1553                            from causing noise as a result of no longer being
1554                            run.
1555                         */
1556
1557                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(processor);
1558                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
1559                         if (pi != 0) {
1560                                 assert (iop == 0);
1561                                 iop = pi->sidechain();
1562                         }
1563
1564                         if (iop != 0) {
1565                                 iop->disconnect ();
1566                         }
1567
1568                         deleted.push_back (processor);
1569                         i = _processors.erase (i);
1570                 }
1571
1572                 if (deleted.empty()) {
1573                         /* none of those in the requested list were found */
1574                         return 0;
1575                 }
1576
1577                 _output->set_user_latency (0);
1578
1579                 if (configure_processors_unlocked (err, &lm)) {
1580                         pstate.restore ();
1581                         /* we know this will work, because it worked before :) */
1582                         configure_processors_unlocked (0, &lm);
1583                         return -1;
1584                 }
1585                 //lx.unlock();
1586
1587                 _have_internal_generator = false;
1588
1589                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1590                         boost::shared_ptr<PluginInsert> pi;
1591
1592                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1593                                 if (pi->has_no_inputs ()) {
1594                                         _have_internal_generator = true;
1595                                         break;
1596                                 }
1597                         }
1598                 }
1599         }
1600
1601         /* now try to do what we need to so that those that were removed will be deleted */
1602
1603         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1604                 (*i)->drop_references ();
1605         }
1606
1607         reset_instrument_info ();
1608         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1609         set_processor_positions ();
1610
1611         return 0;
1612 }
1613
1614 void
1615 Route::reset_instrument_info ()
1616 {
1617         boost::shared_ptr<Processor> instr = the_instrument();
1618         if (instr) {
1619                 _instrument_info.set_internal_instrument (instr);
1620         }
1621 }
1622
1623 /** Caller must hold process lock */
1624 int
1625 Route::configure_processors (ProcessorStreams* err)
1626 {
1627 #ifndef PLATFORM_WINDOWS
1628         assert (!AudioEngine::instance()->process_lock().trylock());
1629 #endif
1630
1631         if (!_in_configure_processors) {
1632                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1633                 return configure_processors_unlocked (err, &lm);
1634         }
1635
1636         return 0;
1637 }
1638
1639 ChanCount
1640 Route::input_streams () const
1641 {
1642         return _input->n_ports ();
1643 }
1644
1645 list<pair<ChanCount, ChanCount> >
1646 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1647 {
1648         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1649
1650         return try_configure_processors_unlocked (in, err);
1651 }
1652
1653 list<pair<ChanCount, ChanCount> >
1654 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1655 {
1656         // Check each processor in order to see if we can configure as requested
1657         ChanCount out;
1658         list<pair<ChanCount, ChanCount> > configuration;
1659         uint32_t index = 0;
1660
1661         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1662         DEBUG_TRACE (DEBUG::Processors, "{\n");
1663
1664         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1665
1666                 if ((*p)->can_support_io_configuration(in, out)) {
1667
1668                         if (boost::dynamic_pointer_cast<Delivery> (*p)
1669                                         && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main
1670                                         && !is_auditioner()
1671                                         && (is_monitor() || _strict_io || Profile->get_mixbus ())) {
1672                                 /* with strict I/O the panner + output are forced to
1673                                  * follow the last processor's output.
1674                                  *
1675                                  * Delivery::can_support_io_configuration() will only add ports,
1676                                  * but not remove excess ports.
1677                                  *
1678                                  * This works because the delivery only requires
1679                                  * as many outputs as there are inputs.
1680                                  * Delivery::configure_io() will do the actual removal
1681                                  * by calling _output->ensure_io()
1682                                  */
1683                                 if (!is_master() && _session.master_out () && in.n_audio() > 0) {
1684                                         /* ..but at least as many as there are master-inputs, if
1685                                          * the delivery is dealing with audio */
1686                                         // XXX this may need special-casing for mixbus (master-outputs)
1687                                         // and should maybe be a preference anyway ?!
1688                                         out = ChanCount::max (in, _session.master_out ()->n_inputs ());
1689                                 } else {
1690                                         out = in;
1691                                 }
1692                         }
1693
1694                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1695                         configuration.push_back(make_pair(in, out));
1696
1697                         if (is_monitor()) {
1698                                 // restriction for Monitor Section Processors
1699                                 if (in.n_audio() != out.n_audio() || out.n_midi() > 0) {
1700                                         /* Note: The Monitor follows the master-bus and has no panner.
1701                                          *
1702                                          * The general idea is to only allow plugins that retain the channel-count
1703                                          * and plugins with MIDI in (e.g VSTs with control that will remain unconnected).
1704                                          * Then again 5.1 in, monitor stereo is a valid use-case.
1705                                          *
1706                                          * and worse: we only refuse adding plugins *here*.
1707                                          *
1708                                          * 1) stereo-master, stereo-mon, add a stereo-plugin, OK
1709                                          * 2) change master-bus, add a channel
1710                                          * 2a) monitor-secion follows
1711                                          * 3) monitor processors fail to re-reconfigure (stereo plugin)
1712                                          * 4) re-load session, monitor-processor remains unconfigured, crash.
1713                                          */
1714                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: Channel configuration change.\n");
1715                                 }
1716                                 if (boost::dynamic_pointer_cast<InternalSend> (*p)) {
1717                                         // internal sends make no sense, only feedback
1718                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1719                                         return list<pair<ChanCount, ChanCount> > ();
1720                                 }
1721                                 if (boost::dynamic_pointer_cast<PortInsert> (*p)) {
1722                                         /* External Sends can be problematic. one can add/remove ports
1723                                          * there signal leaves the DAW to external monitors anyway, so there's
1724                                          * no real use for allowing them here anyway.
1725                                          */
1726                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No External Sends allowed.\n");
1727                                         return list<pair<ChanCount, ChanCount> > ();
1728                                 }
1729                                 if (boost::dynamic_pointer_cast<Send> (*p)) {
1730                                         // ditto
1731                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1732                                         return list<pair<ChanCount, ChanCount> > ();
1733                                 }
1734                         }
1735                         in = out;
1736                 } else {
1737                         if (err) {
1738                                 err->index = index;
1739                                 err->count = in;
1740                         }
1741                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1742                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1743                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1744                         return list<pair<ChanCount, ChanCount> > ();
1745                 }
1746         }
1747
1748         DEBUG_TRACE (DEBUG::Processors, "}\n");
1749
1750         return configuration;
1751 }
1752
1753 /** Set the input/output configuration of each processor in the processors list.
1754  *  Caller must hold process lock.
1755  *  Return 0 on success, otherwise configuration is impossible.
1756  */
1757 int
1758 Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLock::WriterLock* lm)
1759 {
1760 #ifndef PLATFORM_WINDOWS
1761         assert (!AudioEngine::instance()->process_lock().trylock());
1762 #endif
1763
1764         if (_in_configure_processors) {
1765                 return 0;
1766         }
1767
1768         /* put invisible processors where they should be */
1769         setup_invisible_processors ();
1770
1771         _in_configure_processors = true;
1772
1773         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1774
1775         if (configuration.empty ()) {
1776                 _in_configure_processors = false;
1777                 return -1;
1778         }
1779
1780         ChanCount out;
1781         bool seen_mains_out = false;
1782         processor_out_streams = _input->n_ports();
1783         processor_max_streams.reset();
1784
1785         /* processor configure_io() may result in adding ports
1786          * e.g. Delivery::configure_io -> ARDOUR::IO::ensure_io ()
1787          *
1788          * with jack2 adding ports results in a graph-order callback,
1789          * which calls Session::resort_routes() and eventually
1790          * Route::direct_feeds_according_to_reality()
1791          * which takes a ReaderLock (_processor_lock).
1792          *
1793          * so we can't hold a WriterLock here until jack2 threading
1794          * is fixed.
1795          *
1796          * NB. we still hold the process lock
1797          *
1798          * (ardour's own engines do call graph-order from the
1799          * process-thread and hence do not have this issue; besides
1800          * merely adding ports won't trigger a graph-order, only
1801          * making connections does)
1802          */
1803         lm->release ();
1804
1805         // TODO check for a potential ReaderLock after ReaderLock ??
1806         Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
1807
1808         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1809         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1810
1811                 if (!(*p)->configure_io(c->first, c->second)) {
1812                         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
1813                         _in_configure_processors = false;
1814                         lr.release ();
1815                         lm->acquire ();
1816                         return -1;
1817                 }
1818                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1819                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1820
1821                 boost::shared_ptr<IOProcessor> iop;
1822                 boost::shared_ptr<PluginInsert> pi;
1823                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1824                         /* plugins connected via Split or Hide Match may have more channels.
1825                          * route/scratch buffers are needed for all of them
1826                          * The configuration may only be a subset (both input and output)
1827                          */
1828                         processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
1829                 }
1830                 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
1831                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
1832                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
1833                 }
1834                 out = c->second;
1835
1836                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1837                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1838                         /* main delivery will increase port count to match input.
1839                          * the Delivery::Main is usually the last processor - followed only by
1840                          * 'MeterOutput'.
1841                          */
1842                         seen_mains_out = true;
1843                 }
1844                 if (!seen_mains_out) {
1845                         processor_out_streams = out;
1846                 }
1847         }
1848
1849         lr.release ();
1850         lm->acquire ();
1851
1852
1853         if (_meter) {
1854                 _meter->set_max_channels (processor_max_streams);
1855         }
1856
1857         /* make sure we have sufficient scratch buffers to cope with the new processor
1858            configuration
1859         */
1860         _session.ensure_buffers (n_process_buffers ());
1861
1862         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1863
1864         _in_configure_processors = false;
1865         return 0;
1866 }
1867
1868 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1869  *  @param state New active state for those processors.
1870  */
1871 void
1872 Route::all_visible_processors_active (bool state)
1873 {
1874         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1875
1876         if (_processors.empty()) {
1877                 return;
1878         }
1879
1880         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1881                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1882                         continue;
1883                 }
1884 #ifdef MIXBUS
1885                 boost::shared_ptr<PluginInsert> pi;
1886                 if (0 != (pi = boost::dynamic_pointer_cast<PluginInsert>(*i))) {
1887                         if (pi->is_channelstrip ()) {
1888                                 continue;
1889                         }
1890                 }
1891 #endif
1892                 (*i)->enable (state);
1893         }
1894
1895         _session.set_dirty ();
1896 }
1897
1898 bool
1899 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
1900 {
1901         /* check if re-order requires re-configuration of any processors
1902          * -> compare channel configuration for all processors
1903          */
1904         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1905         ChanCount c = input_streams ();
1906
1907         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
1908                 bool found = false;
1909                 if (c != (*j)->input_streams()) {
1910                         return true;
1911                 }
1912                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1913                         if (*i == *j) {
1914                                 found = true;
1915                                 if ((*i)->input_streams() != c) {
1916                                         return true;
1917                                 }
1918                                 c = (*i)->output_streams();
1919                                 break;
1920                         }
1921                 }
1922                 if (!found) {
1923                         return true;
1924                 }
1925         }
1926         return false;
1927 }
1928
1929 #ifdef __clang__
1930 __attribute__((annotate("realtime")))
1931 #endif
1932 void
1933 Route::apply_processor_order (const ProcessorList& new_order)
1934 {
1935         /* need to hold processor_lock; either read or write lock
1936          * and the engine process_lock.
1937          * Due to r/w lock ambiguity we can only assert the latter
1938          */
1939         assert (!AudioEngine::instance()->process_lock().trylock());
1940
1941
1942         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1943          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1944          * processors in the current actual processor list that are hidden. Any visible processors
1945          *  in the current list but not in "new_order" will be assumed to be deleted.
1946          */
1947
1948         /* "as_it_will_be" and "_processors" are lists of shared pointers.
1949          * actual memory usage is small, but insert/erase is not actually rt-safe :(
1950          * (note though that  ::processors_reorder_needs_configure() ensured that
1951          * this function will only ever be called from the rt-thread if no processor were removed)
1952          *
1953          * either way, I can't proove it, but an x-run due to re-order here is less likley
1954          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
1955          */
1956
1957         ProcessorList as_it_will_be;
1958         ProcessorList::iterator oiter;
1959         ProcessorList::const_iterator niter;
1960
1961         oiter = _processors.begin();
1962         niter = new_order.begin();
1963
1964         while (niter !=  new_order.end()) {
1965
1966                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1967                    then append it to the temp list.
1968
1969                    Otherwise, see if the next processor in the old list is in the new list. if not,
1970                    its been deleted. If its there, append it to the temp list.
1971                    */
1972
1973                 if (oiter == _processors.end()) {
1974
1975                         /* no more elements in the old list, so just stick the rest of
1976                            the new order onto the temp list.
1977                            */
1978
1979                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1980                         while (niter != new_order.end()) {
1981                                 ++niter;
1982                         }
1983                         break;
1984
1985                 } else {
1986
1987                         if (!(*oiter)->display_to_user()) {
1988
1989                                 as_it_will_be.push_back (*oiter);
1990
1991                         } else {
1992
1993                                 /* visible processor: check that its in the new order */
1994
1995                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1996                                         /* deleted: do nothing, shared_ptr<> will clean up */
1997                                 } else {
1998                                         /* ignore this one, and add the next item from the new order instead */
1999                                         as_it_will_be.push_back (*niter);
2000                                         ++niter;
2001                                 }
2002                         }
2003
2004                         /* now remove from old order - its taken care of no matter what */
2005                         oiter = _processors.erase (oiter);
2006                 }
2007
2008         }
2009         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2010
2011         /* If the meter is in a custom position, find it and make a rough note of its position */
2012         maybe_note_meter_position ();
2013 }
2014
2015 void
2016 Route::move_instrument_down (bool postfader)
2017 {
2018         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2019         ProcessorList new_order;
2020         boost::shared_ptr<Processor> instrument;
2021         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2022                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
2023                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
2024                         instrument = *i;
2025                 } else if (instrument && *i == _amp) {
2026                         if (postfader) {
2027                                 new_order.push_back (*i);
2028                                 new_order.push_back (instrument);
2029                         } else {
2030                                 new_order.push_back (instrument);
2031                                 new_order.push_back (*i);
2032                         }
2033                 } else {
2034                         new_order.push_back (*i);
2035                 }
2036         }
2037         if (!instrument) {
2038                 return;
2039         }
2040         lm.release ();
2041         reorder_processors (new_order, 0);
2042 }
2043
2044 int
2045 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2046 {
2047         // it a change is already queued, wait for it
2048         // (unless engine is stopped. apply immediately and proceed
2049         while (g_atomic_int_get (&_pending_process_reorder)) {
2050                 if (!AudioEngine::instance()->running()) {
2051                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2052                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2053
2054                         apply_processor_order(_pending_processor_order);
2055                         setup_invisible_processors ();
2056
2057                         g_atomic_int_set (&_pending_process_reorder, 0);
2058
2059                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2060                         set_processor_positions ();
2061                 } else {
2062                         // TODO rather use a semaphore or something.
2063                         // but since ::reorder_processors() is called
2064                         // from the GUI thread, this is fine..
2065                         Glib::usleep(500);
2066                 }
2067         }
2068
2069         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2070
2071                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2072                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2073                 ProcessorState pstate (this);
2074
2075                 apply_processor_order (new_order);
2076
2077                 if (configure_processors_unlocked (err, &lm)) {
2078                         pstate.restore ();
2079                         return -1;
2080                 }
2081
2082                 lm.release();
2083                 lx.release();
2084
2085                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2086                 set_processor_positions ();
2087
2088         } else {
2089                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2090                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2091
2092                 // _pending_processor_order is protected by _processor_lock
2093                 _pending_processor_order = new_order;
2094                 g_atomic_int_set (&_pending_process_reorder, 1);
2095         }
2096
2097         return 0;
2098 }
2099
2100 bool
2101 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2102 {
2103         boost::shared_ptr<PluginInsert> pi;
2104         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2105                 return false;
2106         }
2107
2108         if (pi->has_sidechain () == add) {
2109                 return true; // ?? call failed, but result is as expected.
2110         }
2111
2112         {
2113                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2114                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2115                 if (i == _processors.end ()) {
2116                         return false;
2117                 }
2118         }
2119
2120         {
2121                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2122                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2123                 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2124
2125                 lx.release (); // IO::add_port() and ~IO takes process lock  - XXX check if this is safe
2126                 if (add) {
2127                         if (!pi->add_sidechain ()) {
2128                                 return false;
2129                         }
2130                 } else {
2131                         if (!pi->del_sidechain ()) {
2132                                 return false;
2133                         }
2134                 }
2135
2136                 lx.acquire ();
2137                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2138                 lx.release ();
2139
2140                 if (c.empty()) {
2141                         if (add) {
2142                                 pi->del_sidechain ();
2143                         } else {
2144                                 pi->add_sidechain ();
2145                                 // TODO restore side-chain's state.
2146                         }
2147                         return false;
2148                 }
2149                 lx.acquire ();
2150                 configure_processors_unlocked (0, &lm);
2151         }
2152
2153         if (pi->has_sidechain ()) {
2154                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2155         }
2156
2157         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2158         _session.set_dirty ();
2159         return true;
2160 }
2161
2162 bool
2163 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2164 {
2165         boost::shared_ptr<PluginInsert> pi;
2166         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2167                 return false;
2168         }
2169
2170         {
2171                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2172                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2173                 if (i == _processors.end ()) {
2174                         return false;
2175                 }
2176         }
2177
2178         {
2179                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2180                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2181
2182                 const ChanCount& old (pi->preset_out ());
2183                 if (!pi->set_preset_out (outs)) {
2184                         return true; // no change, OK
2185                 }
2186
2187                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2188                 if (c.empty()) {
2189                         /* not possible */
2190                         pi->set_preset_out (old);
2191                         return false;
2192                 }
2193                 configure_processors_unlocked (0, &lm);
2194         }
2195
2196         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2197         _session.set_dirty ();
2198         return true;
2199 }
2200
2201 bool
2202 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2203 {
2204         ChanCount unused;
2205         return customize_plugin_insert (proc, 0, unused, unused);
2206 }
2207
2208 bool
2209 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
2210 {
2211         boost::shared_ptr<PluginInsert> pi;
2212         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2213                 return false;
2214         }
2215
2216         {
2217                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2218                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2219                 if (i == _processors.end ()) {
2220                         return false;
2221                 }
2222         }
2223
2224         {
2225                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2226                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2227
2228                 bool      old_cust  = pi->custom_cfg ();
2229                 uint32_t  old_cnt   = pi->get_count ();
2230                 ChanCount old_chan  = pi->output_streams ();
2231                 ChanCount old_sinks = pi->natural_input_streams ();
2232
2233                 if (count == 0) {
2234                         pi->set_custom_cfg (false);
2235                 } else {
2236                         pi->set_custom_cfg (true);
2237                         pi->set_count (count);
2238                         pi->set_outputs (outs);
2239                         pi->set_sinks (sinks);
2240                 }
2241
2242                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2243                 if (c.empty()) {
2244                         /* not possible */
2245
2246                         pi->set_count (old_cnt);
2247                         pi->set_sinks (old_sinks);
2248                         pi->set_outputs (old_chan);
2249                         pi->set_custom_cfg (old_cust);
2250
2251                         return false;
2252                 }
2253                 configure_processors_unlocked (0, &lm);
2254         }
2255
2256         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2257         _session.set_dirty ();
2258         return true;
2259 }
2260
2261 bool
2262 Route::set_strict_io (const bool enable)
2263 {
2264         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2265
2266         if (_strict_io != enable) {
2267                 _strict_io = enable;
2268                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2269                 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2270                         boost::shared_ptr<PluginInsert> pi;
2271                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2272                                 pi->set_strict_io (_strict_io);
2273                         }
2274                 }
2275
2276                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2277
2278                 if (c.empty()) {
2279                         // not possible
2280                         _strict_io = !enable; // restore old value
2281                         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2282                                 boost::shared_ptr<PluginInsert> pi;
2283                                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2284                                         pi->set_strict_io (_strict_io);
2285                                 }
2286                         }
2287                         return false;
2288                 }
2289                 lm.release ();
2290
2291                 configure_processors (0);
2292                 lx.release ();
2293
2294                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2295                 _session.set_dirty ();
2296         }
2297         return true;
2298 }
2299
2300 XMLNode&
2301 Route::get_state()
2302 {
2303         return state(true);
2304 }
2305
2306 XMLNode&
2307 Route::get_template()
2308 {
2309         return state(false);
2310 }
2311
2312 XMLNode&
2313 Route::state(bool full_state)
2314 {
2315         if (!_session._template_state_dir.empty()) {
2316                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2317         }
2318
2319         XMLNode *node = new XMLNode("Route");
2320         ProcessorList::iterator i;
2321
2322         node->set_property ("id", id ());
2323         node->set_property ("name", name());
2324         node->set_property ("default-type", _default_type);
2325         node->set_property ("strict-io", _strict_io);
2326
2327         node->add_child_nocopy (_presentation_info.get_state());
2328
2329         node->set_property ("active", _active);
2330         node->set_property ("denormal-protection", _denormal_protection);
2331         node->set_property ("meter-point", _meter_point);
2332
2333         node->set_property ("meter-type", _meter_type);
2334
2335         if (_route_group) {
2336                 node->set_property ("route-group", _route_group->name());
2337         }
2338
2339         node->add_child_nocopy (_solo_control->get_state ());
2340         node->add_child_nocopy (_solo_isolate_control->get_state ());
2341         node->add_child_nocopy (_solo_safe_control->get_state ());
2342
2343         node->add_child_nocopy (_input->state (full_state));
2344         node->add_child_nocopy (_output->state (full_state));
2345         node->add_child_nocopy (_mute_master->get_state ());
2346
2347         node->add_child_nocopy (_mute_control->get_state ());
2348         node->add_child_nocopy (_phase_control->get_state ());
2349
2350         if (full_state) {
2351                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2352         }
2353
2354         if (_comment.length()) {
2355                 XMLNode *cmt = node->add_child ("Comment");
2356                 cmt->add_content (_comment);
2357         }
2358
2359         if (_pannable) {
2360                 node->add_child_nocopy (_pannable->state (full_state));
2361         }
2362
2363         {
2364                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2365                 for (i = _processors.begin(); i != _processors.end(); ++i) {
2366                         if (!full_state) {
2367                                 /* template save: do not include internal sends functioning as
2368                                          aux sends because the chance of the target ID
2369                                          in the session where this template is used
2370                                          is not very likely.
2371
2372                                          similarly, do not save listen sends which connect to
2373                                          the monitor section, because these will always be
2374                                          added if necessary.
2375                                          */
2376                                 boost::shared_ptr<InternalSend> is;
2377
2378                                 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2379                                         if (is->role() == Delivery::Listen) {
2380                                                 continue;
2381                                         }
2382                                 }
2383                         }
2384                         node->add_child_nocopy((*i)->state (full_state));
2385                 }
2386         }
2387
2388         if (_extra_xml) {
2389                 node->add_child_copy (*_extra_xml);
2390         }
2391
2392         if (_custom_meter_position_noted) {
2393                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2394                 if (after) {
2395                         node->set_property (X_("processor-after-last-custom-meter"), after->id());
2396                 }
2397         }
2398
2399         if (!_session._template_state_dir.empty()) {
2400                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2401         }
2402
2403         node->add_child_copy (Slavable::get_state());
2404
2405         return *node;
2406 }
2407
2408 int
2409 Route::set_state (const XMLNode& node, int version)
2410 {
2411         if (version < 3000) {
2412                 return set_state_2X (node, version);
2413         }
2414
2415         XMLNodeList nlist;
2416         XMLNodeConstIterator niter;
2417         XMLNode *child;
2418
2419         if (node.name() != "Route"){
2420                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2421                 return -1;
2422         }
2423
2424         std::string route_name;
2425         if (node.get_property (X_("name"), route_name)) {
2426                 Route::set_name (route_name);
2427         }
2428
2429         set_id (node);
2430         _initial_io_setup = true;
2431
2432         Stripable::set_state (node, version);
2433
2434         node.get_property (X_("strict-io"), _strict_io);
2435
2436         if (is_monitor()) {
2437                 /* monitor bus does not get a panner, but if (re)created
2438                    via XML, it will already have one by the time we
2439                    call ::set_state(). so ... remove it.
2440                 */
2441                 unpan ();
2442         }
2443
2444         /* add all processors (except amp, which is always present) */
2445
2446         nlist = node.children();
2447         XMLNode processor_state (X_("processor_state"));
2448
2449         Stateful::save_extra_xml (node);
2450
2451         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2452
2453                 child = *niter;
2454
2455                 if (child->name() == IO::state_node_name) {
2456                         std::string direction;
2457                         if (!child->get_property (X_("direction"), direction)) {
2458                                 continue;
2459                         }
2460
2461                         if (direction == "Input") {
2462                                 _input->set_state (*child, version);
2463                         } else if (direction == "Output") {
2464                                 _output->set_state (*child, version);
2465                         }
2466
2467                 } else if (child->name() == X_("Processor")) {
2468                         processor_state.add_child_copy (*child);
2469                 } else if (child->name() == X_("Pannable")) {
2470                         if (_pannable) {
2471                                 _pannable->set_state (*child, version);
2472                         } else {
2473                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2474                         }
2475                 } else if (child->name() == Slavable::xml_node_name) {
2476                         Slavable::set_state (*child, version);
2477                 }
2478         }
2479
2480         MeterPoint mp;
2481         if (node.get_property (X_("meter-point"), mp)) {
2482                 set_meter_point (mp, true);
2483                 if (_meter) {
2484                         _meter->set_display_to_user (_meter_point == MeterCustom);
2485                 }
2486         }
2487
2488         node.get_property (X_("meter-type"), _meter_type);
2489
2490         _initial_io_setup = false;
2491
2492         set_processor_state (processor_state);
2493
2494         // this looks up the internal instrument in processors
2495         reset_instrument_info();
2496
2497         bool denormal_protection;
2498         if (node.get_property (X_("denormal-protection"), denormal_protection)) {
2499                 set_denormal_protection (denormal_protection);
2500         }
2501
2502         /* convert old 3001 state */
2503         std::string phase_invert_str;
2504         if (node.get_property (X_("phase-invert"), phase_invert_str)) {
2505                 _phase_control->set_phase_invert (boost::dynamic_bitset<> (phase_invert_str));
2506         }
2507
2508         bool is_active;
2509         if (node.get_property (X_("active"), is_active)) {
2510                 set_active (is_active, this);
2511         }
2512
2513         std::string id_string;
2514         if (node.get_property (X_("processor-after-last-custom-meter"), id_string)) {
2515                 PBD::ID id (id_string);
2516                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2517                 ProcessorList::const_iterator i = _processors.begin ();
2518                 while (i != _processors.end() && (*i)->id() != id) {
2519                         ++i;
2520                 }
2521
2522                 if (i != _processors.end ()) {
2523                         _processor_after_last_custom_meter = *i;
2524                         _custom_meter_position_noted = true;
2525                 }
2526         }
2527
2528         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2529                 child = *niter;
2530
2531                 if (child->name() == X_("Comment")) {
2532
2533                         /* XXX this is a terrible API design in libxml++ */
2534
2535                         XMLNode *cmt = *(child->children().begin());
2536                         _comment = cmt->content();
2537
2538                 }  else if (child->name() == Controllable::xml_node_name) {
2539                         std::string control_name;
2540                         if (!child->get_property (X_("name"), control_name)) {
2541                                 continue;
2542                         }
2543
2544                         if (control_name == _solo_control->name()) {
2545                                 _solo_control->set_state (*child, version);
2546                         } else if (control_name == _solo_safe_control->name()) {
2547                                 _solo_safe_control->set_state (*child, version);
2548                         } else if (control_name == _solo_isolate_control->name()) {
2549                                 _solo_isolate_control->set_state (*child, version);
2550                         } else if (control_name == _mute_control->name()) {
2551                                 _mute_control->set_state (*child, version);
2552                         } else if (control_name == _phase_control->name()) {
2553                                 _phase_control->set_state (*child, version);
2554                         } else {
2555                                 Evoral::Parameter p = EventTypeMap::instance().from_symbol (control_name);
2556                                 if (p.type () >= MidiCCAutomation && p.type () < MidiSystemExclusiveAutomation) {
2557                                         boost::shared_ptr<AutomationControl> ac = automation_control (p, true);
2558                                         if (ac) {
2559                                                 ac->set_state (*child, version);
2560                                         }
2561                                 }
2562                         }
2563                 } else if (child->name() == MuteMaster::xml_node_name) {
2564                         _mute_master->set_state (*child, version);
2565
2566                 } else if (child->name() == Automatable::xml_node_name) {
2567                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2568                 }
2569         }
2570
2571         return 0;
2572 }
2573
2574 int
2575 Route::set_state_2X (const XMLNode& node, int version)
2576 {
2577         LocaleGuard lg;
2578         XMLNodeList nlist;
2579         XMLNodeConstIterator niter;
2580         XMLNode *child;
2581         XMLProperty const * prop;
2582
2583         /* 2X things which still remain to be handled:
2584          * default-type
2585          * automation
2586          * controlouts
2587          */
2588
2589         if (node.name() != "Route") {
2590                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2591                 return -1;
2592         }
2593
2594         Stripable::set_state (node, version);
2595
2596         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2597                 set_denormal_protection (string_to<bool> (prop->value()));
2598         }
2599
2600         if ((prop = node.property (X_("muted"))) != 0) {
2601
2602                 bool first = true;
2603                 bool muted = string_to<bool> (prop->value());
2604
2605                 if (muted) {
2606
2607                         string mute_point;
2608
2609                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2610
2611                                 if (string_to<bool> (prop->value())){
2612                                         mute_point = mute_point + "PreFader";
2613                                         first = false;
2614                                 }
2615                         }
2616
2617                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2618
2619                                 if (string_to<bool> (prop->value())){
2620
2621                                         if (!first) {
2622                                                 mute_point = mute_point + ",";
2623                                         }
2624
2625                                         mute_point = mute_point + "PostFader";
2626                                         first = false;
2627                                 }
2628                         }
2629
2630                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2631
2632                                 if (string_to<bool> (prop->value())){
2633
2634                                         if (!first) {
2635                                                 mute_point = mute_point + ",";
2636                                         }
2637
2638                                         mute_point = mute_point + "Listen";
2639                                         first = false;
2640                                 }
2641                         }
2642
2643                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2644
2645                                 if (string_to<bool> (prop->value())){
2646
2647                                         if (!first) {
2648                                                 mute_point = mute_point + ",";
2649                                         }
2650
2651                                         mute_point = mute_point + "Main";
2652                                 }
2653                         }
2654
2655                         _mute_master->set_mute_points (mute_point);
2656                         _mute_master->set_muted_by_self (true);
2657                 }
2658         }
2659
2660         if ((prop = node.property (X_("meter-point"))) != 0) {
2661                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2662         }
2663
2664         /* IOs */
2665
2666         nlist = node.children ();
2667         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2668
2669                 child = *niter;
2670
2671                 if (child->name() == IO::state_node_name) {
2672
2673                         /* there is a note in IO::set_state_2X() about why we have to call
2674                            this directly.
2675                            */
2676
2677                         _input->set_state_2X (*child, version, true);
2678                         _output->set_state_2X (*child, version, false);
2679
2680                         if ((prop = child->property (X_("name"))) != 0) {
2681                                 Route::set_name (prop->value ());
2682                         }
2683
2684                         set_id (*child);
2685
2686                         if ((prop = child->property (X_("active"))) != 0) {
2687                                 bool yn = string_to<bool> (prop->value());
2688                                 _active = !yn; // force switch
2689                                 set_active (yn, this);
2690                         }
2691
2692                         if ((prop = child->property (X_("gain"))) != 0) {
2693                                 gain_t val;
2694
2695                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2696                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
2697                                 }
2698                         }
2699
2700                         /* Set up Panners in the IO */
2701                         XMLNodeList io_nlist = child->children ();
2702
2703                         XMLNodeConstIterator io_niter;
2704                         XMLNode *io_child;
2705
2706                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2707
2708                                 io_child = *io_niter;
2709
2710                                 if (io_child->name() == X_("Panner")) {
2711                                         _main_outs->panner_shell()->set_state(*io_child, version);
2712                                 } else if (io_child->name() == X_("Automation")) {
2713                                         /* IO's automation is for the fader */
2714                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2715                                 }
2716                         }
2717                 }
2718         }
2719
2720         XMLNodeList redirect_nodes;
2721
2722         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2723
2724                 child = *niter;
2725
2726                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2727                         redirect_nodes.push_back(child);
2728                 }
2729
2730         }
2731
2732         set_processor_state_2X (redirect_nodes, version);
2733
2734         Stateful::save_extra_xml (node);
2735
2736         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2737                 child = *niter;
2738
2739                 if (child->name() == X_("Comment")) {
2740
2741                         /* XXX this is a terrible API design in libxml++ */
2742
2743                         XMLNode *cmt = *(child->children().begin());
2744                         _comment = cmt->content();
2745
2746                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2747                         if (prop->value() == X_("solo")) {
2748                                 _solo_control->set_state (*child, version);
2749                         } else if (prop->value() == X_("mute")) {
2750                                 _mute_control->set_state (*child, version);
2751                         }
2752
2753                 }
2754         }
2755
2756         return 0;
2757 }
2758
2759 XMLNode&
2760 Route::get_processor_state ()
2761 {
2762         XMLNode* root = new XMLNode (X_("redirects"));
2763         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2764                 root->add_child_nocopy ((*i)->state (true));
2765         }
2766
2767         return *root;
2768 }
2769
2770 void
2771 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2772 {
2773         /* We don't bother removing existing processors not in nList, as this
2774            method will only be called when creating a Route from scratch, not
2775            for undo purposes.  Just put processors in at the appropriate place
2776            in the list.
2777         */
2778
2779         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2780                 add_processor_from_xml_2X (**i, version);
2781         }
2782 }
2783
2784 void
2785 Route::set_processor_state (const XMLNode& node)
2786 {
2787         const XMLNodeList &nlist = node.children();
2788         XMLNodeConstIterator niter;
2789         ProcessorList new_order;
2790         bool must_configure = false;
2791
2792         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2793
2794                 XMLProperty* prop = (*niter)->property ("type");
2795
2796                 if (prop->value() == "amp") {
2797                         _amp->set_state (**niter, Stateful::current_state_version);
2798                         new_order.push_back (_amp);
2799                 } else if (prop->value() == "trim") {
2800                         _trim->set_state (**niter, Stateful::current_state_version);
2801                         new_order.push_back (_trim);
2802                 } else if (prop->value() == "meter") {
2803                         _meter->set_state (**niter, Stateful::current_state_version);
2804                         new_order.push_back (_meter);
2805                 } else if (prop->value() == "delay") {
2806                         if (_delayline) {
2807                                 _delayline->set_state (**niter, Stateful::current_state_version);
2808                                 new_order.push_back (_delayline);
2809                         }
2810                 } else if (prop->value() == "main-outs") {
2811                         _main_outs->set_state (**niter, Stateful::current_state_version);
2812                 } else if (prop->value() == "intreturn") {
2813                         if (!_intreturn) {
2814                                 _intreturn.reset (new InternalReturn (_session));
2815                                 must_configure = true;
2816                         }
2817                         _intreturn->set_state (**niter, Stateful::current_state_version);
2818                 } else if (is_monitor() && prop->value() == "monitor") {
2819                         if (!_monitor_control) {
2820                                 _monitor_control.reset (new MonitorProcessor (_session));
2821                                 must_configure = true;
2822                         }
2823                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2824                 } else if (prop->value() == "capture") {
2825                         /* CapturingProcessor should never be restored, it's always
2826                            added explicitly when needed */
2827                 } else {
2828                         ProcessorList::iterator o;
2829
2830                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2831                                 XMLProperty const * id_prop = (*niter)->property(X_("id"));
2832                                 if (id_prop && (*o)->id() == id_prop->value()) {
2833                                         (*o)->set_state (**niter, Stateful::current_state_version);
2834                                         new_order.push_back (*o);
2835                                         break;
2836                                 }
2837                         }
2838
2839                         // If the processor (*niter) is not on the route then create it
2840
2841                         if (o == _processors.end()) {
2842
2843                                 boost::shared_ptr<Processor> processor;
2844
2845                                 if (prop->value() == "intsend") {
2846
2847                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2848
2849                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2850                                            prop->value() == "lv2" ||
2851                                            prop->value() == "windows-vst" ||
2852                                            prop->value() == "mac-vst" ||
2853                                            prop->value() == "lxvst" ||
2854                                            prop->value() == "luaproc" ||
2855                                            prop->value() == "audiounit") {
2856
2857                                         if (_session.get_disable_all_loaded_plugins ()) {
2858                                                 processor.reset (new UnknownProcessor (_session, **niter));
2859                                         } else {
2860                                                 processor.reset (new PluginInsert (_session));
2861                                                 processor->set_owner (this);
2862                                                 if (_strict_io) {
2863                                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
2864                                                         pi->set_strict_io (true);
2865                                                 }
2866
2867                                         }
2868                                 } else if (prop->value() == "port") {
2869
2870                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2871
2872                                 } else if (prop->value() == "send") {
2873
2874                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2875                                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
2876                                         send->SelfDestruct.connect_same_thread (*this,
2877                                                         boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
2878
2879                                 } else {
2880                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2881                                         continue;
2882                                 }
2883
2884                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2885                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2886                                         processor.reset (new UnknownProcessor (_session, **niter));
2887                                 }
2888
2889                                 /* subscribe to Sidechain IO changes */
2890                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
2891                                 if (pi && pi->has_sidechain ()) {
2892                                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2893                                 }
2894
2895                                 /* we have to note the monitor send here, otherwise a new one will be created
2896                                    and the state of this one will be lost.
2897                                 */
2898                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2899                                 if (isend && isend->role() == Delivery::Listen) {
2900                                         _monitor_send = isend;
2901                                 }
2902
2903                                 /* it doesn't matter if invisible processors are added here, as they
2904                                    will be sorted out by setup_invisible_processors () shortly.
2905                                 */
2906
2907                                 new_order.push_back (processor);
2908                                 must_configure = true;
2909                         }
2910                 }
2911         }
2912
2913         {
2914                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2915                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2916                 /* re-assign _processors w/o process-lock.
2917                  * if there's an IO-processor present in _processors but
2918                  * not in new_order, it will be deleted and ~IO takes
2919                  * a process lock.
2920                  */
2921                 _processors = new_order;
2922
2923                 if (must_configure) {
2924                         configure_processors_unlocked (0, &lm);
2925                 }
2926
2927                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2928
2929                         (*i)->set_owner (this);
2930                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2931
2932                         boost::shared_ptr<PluginInsert> pi;
2933
2934                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2935                                 if (pi->has_no_inputs ()) {
2936                                         _have_internal_generator = true;
2937                                         break;
2938                                 }
2939                         }
2940                 }
2941         }
2942
2943         reset_instrument_info ();
2944         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2945         set_processor_positions ();
2946 }
2947
2948 void
2949 Route::curve_reallocate ()
2950 {
2951 //      _gain_automation_curve.finish_resize ();
2952 //      _pan_automation_curve.finish_resize ();
2953 }
2954
2955 void
2956 Route::silence (framecnt_t nframes)
2957 {
2958         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2959         if (!lm.locked()) {
2960                 return;
2961         }
2962
2963         silence_unlocked (nframes);
2964 }
2965
2966 void
2967 Route::silence_unlocked (framecnt_t nframes)
2968 {
2969         /* Must be called with the processor lock held */
2970
2971         const framepos_t now = _session.transport_frame ();
2972
2973         if (!_silent) {
2974
2975                 _output->silence (nframes);
2976
2977                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2978                         boost::shared_ptr<PluginInsert> pi;
2979
2980                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2981                                 // skip plugins, they don't need anything when we're not active
2982                                 continue;
2983                         }
2984
2985                         (*i)->silence (nframes, now);
2986                 }
2987
2988                 if (nframes == _session.get_block_size()) {
2989                         // _silent = true;
2990                 }
2991         }
2992 }
2993
2994 void
2995 Route::add_internal_return ()
2996 {
2997         if (!_intreturn) {
2998                 _intreturn.reset (new InternalReturn (_session));
2999                 add_processor (_intreturn, PreFader);
3000         }
3001 }
3002
3003 void
3004 Route::add_send_to_internal_return (InternalSend* send)
3005 {
3006         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3007
3008         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3009                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3010
3011                 if (d) {
3012                         return d->add_send (send);
3013                 }
3014         }
3015 }
3016
3017 void
3018 Route::remove_send_from_internal_return (InternalSend* send)
3019 {
3020         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3021
3022         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3023                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3024
3025                 if (d) {
3026                         return d->remove_send (send);
3027                 }
3028         }
3029 }
3030
3031 void
3032 Route::enable_monitor_send ()
3033 {
3034         /* Caller must hold process lock */
3035         assert (!AudioEngine::instance()->process_lock().trylock());
3036
3037         /* master never sends to monitor section via the normal mechanism */
3038         assert (!is_master ());
3039         assert (!is_monitor ());
3040
3041         /* make sure we have one */
3042         if (!_monitor_send) {
3043                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3044                 _monitor_send->set_display_to_user (false);
3045         }
3046
3047         /* set it up */
3048         configure_processors (0);
3049 }
3050
3051 /** Add an aux send to a route.
3052  *  @param route route to send to.
3053  *  @param before Processor to insert before, or 0 to insert at the end.
3054  */
3055 int
3056 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3057 {
3058         assert (route != _session.monitor_out ());
3059
3060         {
3061                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3062
3063                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3064
3065                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3066
3067                         if (d && d->target_route() == route) {
3068                                 /* already listening via the specified IO: do nothing */
3069                                 return 0;
3070                         }
3071                 }
3072         }
3073
3074         try {
3075
3076                 boost::shared_ptr<InternalSend> listener;
3077
3078                 {
3079                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3080                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3081                 }
3082
3083                 add_processor (listener, before);
3084
3085         } catch (failed_constructor& err) {
3086                 return -1;
3087         }
3088
3089         return 0;
3090 }
3091
3092 void
3093 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3094 {
3095         ProcessorStreams err;
3096         ProcessorList::iterator tmp;
3097
3098         {
3099                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3100
3101                 /* have to do this early because otherwise processor reconfig
3102                  * will put _monitor_send back in the list
3103                  */
3104
3105                 if (route == _session.monitor_out()) {
3106                         _monitor_send.reset ();
3107                 }
3108
3109           again:
3110                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3111
3112                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3113
3114                         if (d && d->target_route() == route) {
3115                                 rl.release ();
3116                                 if (remove_processor (*x, &err, false) > 0) {
3117                                         rl.acquire ();
3118                                         continue;
3119                                 }
3120                                 rl.acquire ();
3121
3122                                 /* list could have been demolished while we dropped the lock
3123                                    so start over.
3124                                 */
3125                                 if (_session.engine().connected()) {
3126                                         /* i/o processors cannot be removed if the engine is not running
3127                                          * so don't live-loop in case the engine is N/A or dies
3128                                          */
3129                                         goto again;
3130                                 }
3131                         }
3132                 }
3133         }
3134 }
3135
3136 void
3137 Route::set_comment (string cmt, void *src)
3138 {
3139         _comment = cmt;
3140         comment_changed ();
3141         _session.set_dirty ();
3142 }
3143
3144 bool
3145 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3146 {
3147         FeedRecord fr (other, via_sends_only);
3148
3149         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3150
3151         if (!result.second) {
3152
3153                 /* already a record for "other" - make sure sends-only information is correct */
3154                 if (!via_sends_only && result.first->sends_only) {
3155                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3156                         frp->sends_only = false;
3157                 }
3158         }
3159
3160         return result.second;
3161 }
3162
3163 void
3164 Route::clear_fed_by ()
3165 {
3166         _fed_by.clear ();
3167 }
3168
3169 bool
3170 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3171 {
3172         const FedBy& fed_by (other->fed_by());
3173
3174         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3175                 boost::shared_ptr<Route> sr = f->r.lock();
3176
3177                 if (sr && (sr.get() == this)) {
3178
3179                         if (via_sends_only) {
3180                                 *via_sends_only = f->sends_only;
3181                         }
3182
3183                         return true;
3184                 }
3185         }
3186
3187         return false;
3188 }
3189
3190 IOVector
3191 Route::all_inputs () const
3192 {
3193         /* TODO, if this works as expected,
3194          * cache the IOVector and maintain it via
3195          * input_change_handler(), sidechain_change_handler() etc
3196          */
3197         IOVector ios;
3198         ios.push_back (_input);
3199
3200         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3201         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3202
3203                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3204                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3205                 if (pi != 0) {
3206                         assert (iop == 0);
3207                         iop = pi->sidechain();
3208                 }
3209
3210                 if (iop != 0 && iop->input()) {
3211                         ios.push_back (iop->input());
3212                 }
3213         }
3214         return ios;
3215 }
3216
3217 IOVector
3218 Route::all_outputs () const
3219 {
3220         IOVector ios;
3221         // _output is included via Delivery
3222         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3223         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3224                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3225                 if (iop != 0 && iop->output()) {
3226                         ios.push_back (iop->output());
3227                 }
3228         }
3229         return ios;
3230 }
3231
3232 bool
3233 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3234 {
3235         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3236         if (other->all_inputs().fed_by (_output)) {
3237                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3238                 if (via_send_only) {
3239                         *via_send_only = false;
3240                 }
3241
3242                 return true;
3243         }
3244
3245         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3246
3247         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3248
3249                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3250                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3251                 if (pi != 0) {
3252                         assert (iop == 0);
3253                         iop = pi->sidechain();
3254                 }
3255
3256                 if (iop != 0) {
3257                         boost::shared_ptr<const IO> iop_out = iop->output();
3258                         if (other.get() == this && iop_out && iop->input() && iop_out->connected_to (iop->input())) {
3259                                 // TODO this needs a delaylines in the Insert to align connections (!)
3260                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed its own return (%2)\n", iop->name(), other->name()));
3261                                 continue;
3262                         }
3263                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3264                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3265                                 if (via_send_only) {
3266                                         *via_send_only = true;
3267                                 }
3268                                 return true;
3269                         } else {
3270                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3271                         }
3272                 } else {
3273                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3274                 }
3275
3276         }
3277
3278         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3279         return false;
3280 }
3281
3282 bool
3283 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3284 {
3285         return _session._current_route_graph.has (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other, via_send_only);
3286 }
3287
3288 bool
3289 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3290 {
3291         return _session._current_route_graph.feeds (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other);
3292 }
3293
3294 /** Called from the (non-realtime) butler thread when the transport is stopped */
3295 void
3296 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3297 {
3298         framepos_t now = _session.transport_frame();
3299
3300         {
3301                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3302
3303                 Automatable::transport_stopped (now);
3304
3305                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3306
3307                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3308                                 (*i)->flush ();
3309                         }
3310
3311                         (*i)->transport_stopped (now);
3312                 }
3313         }
3314
3315         _roll_delay = _initial_delay;
3316 }
3317
3318 void
3319 Route::input_change_handler (IOChange change, void * /*src*/)
3320 {
3321         if ((change.type & IOChange::ConfigurationChanged)) {
3322                 /* This is called with the process lock held if change
3323                    contains ConfigurationChanged
3324                 */
3325                 configure_processors (0);
3326                 _phase_control->resize (_input->n_ports().n_audio ());
3327                 io_changed (); /* EMIT SIGNAL */
3328         }
3329
3330         if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3331                 int sbou = 0;
3332                 int ibou = 0;
3333                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3334                 if (_input->connected()) {
3335                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3336                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3337                                         continue;
3338                                 }
3339                                 bool sends_only;
3340                                 bool does_feed = (*i)->direct_feeds_according_to_reality (boost::dynamic_pointer_cast<Route> (shared_from_this()), &sends_only);
3341                                 if (does_feed && !sends_only) {
3342                                         if ((*i)->soloed()) {
3343                                                 ++sbou;
3344                                         }
3345                                         if ((*i)->solo_isolate_control()->solo_isolated()) {
3346                                                 ++ibou;
3347                                         }
3348                                 }
3349                         }
3350                 }
3351
3352                 int delta  = sbou - _solo_control->soloed_by_others_upstream();
3353                 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3354
3355                 if (idelta < -1) {
3356                         PBD::warning << string_compose (
3357                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3358                                         _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3359                                      << endmsg;
3360
3361                 }
3362
3363                 if (_solo_control->soloed_by_others_upstream()) {
3364                         // ignore new connections (they're not propagated)
3365                         if (delta <= 0) {
3366                                 _solo_control->mod_solo_by_others_upstream (delta);
3367                         }
3368                 }
3369
3370                 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3371                         // solo-isolate currently only propagates downstream
3372                         if (idelta < 0) {
3373                                 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3374                         }
3375                         //_solo_isolated_by_upstream = ibou;
3376                 }
3377
3378                 // Session::route_solo_changed  does not propagate indirect solo-changes
3379                 // propagate downstream to tracks
3380                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3381                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3382                                 continue;
3383                         }
3384                         bool sends_only;
3385                         bool does_feed = feeds (*i, &sends_only);
3386                         if (delta <= 0 && does_feed && !sends_only) {
3387                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3388                         }
3389
3390                         if (idelta < 0 && does_feed && !sends_only) {
3391                                 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3392                         }
3393                 }
3394         }
3395 }
3396
3397 void
3398 Route::output_change_handler (IOChange change, void * /*src*/)
3399 {
3400         if (_initial_io_setup) {
3401                 return;
3402         }
3403
3404         if ((change.type & IOChange::ConfigurationChanged)) {
3405                 /* This is called with the process lock held if change
3406                    contains ConfigurationChanged
3407                 */
3408                 configure_processors (0);
3409
3410                 if (is_master()) {
3411                         _session.reset_monitor_section();
3412                 }
3413
3414                 io_changed (); /* EMIT SIGNAL */
3415         }
3416
3417         if ((change.type & IOChange::ConnectionsChanged)) {
3418
3419                 /* do this ONLY if connections have changed. Configuration
3420                  * changes do not, by themselves alter solo upstream or
3421                  * downstream status.
3422                  */
3423
3424                 if (_solo_control->soloed_by_others_downstream()) {
3425                         int sbod = 0;
3426                         /* checking all all downstream routes for
3427                          * explicit of implict solo is a rather drastic measure,
3428                          * ideally the input_change_handler() of the other route
3429                          * would propagate the change to us.
3430                          */
3431                         boost::shared_ptr<RouteList> routes = _session.get_routes ();
3432                         if (_output->connected()) {
3433                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3434                                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3435                                                 continue;
3436                                         }
3437                                         bool sends_only;
3438                                         bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3439                                         if (does_feed && !sends_only) {
3440                                                 if ((*i)->soloed()) {
3441                                                         ++sbod;
3442                                                         break;
3443                                                 }
3444                                         }
3445                                 }
3446                         }
3447
3448                         int delta = sbod - _solo_control->soloed_by_others_downstream();
3449                         if (delta <= 0) {
3450                                 // do not allow new connections to change implicit solo (no propagation)
3451                                 _solo_control->mod_solo_by_others_downstream (delta);
3452                                 // Session::route_solo_changed() does not propagate indirect solo-changes
3453                                 // propagate upstream to tracks
3454                                 boost::shared_ptr<Route> shared_this = boost::dynamic_pointer_cast<Route> (shared_from_this());
3455                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3456                                         if ((*i).get() == this || !can_solo()) {
3457                                                 continue;
3458                                         }
3459                                         bool sends_only;
3460                                         bool does_feed = (*i)->feeds (shared_this, &sends_only);
3461                                         if (delta != 0 && does_feed && !sends_only) {
3462                                                 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3463                                         }
3464                                 }
3465
3466                         }
3467                 }
3468         }
3469 }
3470
3471 void
3472 Route::sidechain_change_handler (IOChange change, void* src)
3473 {
3474         if (_initial_io_setup || _in_sidechain_setup) {
3475                 return;
3476         }
3477
3478         input_change_handler (change, src);
3479 }
3480
3481 uint32_t
3482 Route::pans_required () const
3483 {
3484         if (n_outputs().n_audio() < 2) {
3485                 return 0;
3486         }
3487
3488         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3489 }
3490
3491 void
3492 Route::flush_processor_buffers_locked (framecnt_t nframes)
3493 {
3494         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3495                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
3496                 if (d) {
3497                         d->flush_buffers (nframes);
3498                 } else {
3499                         boost::shared_ptr<PortInsert> p = boost::dynamic_pointer_cast<PortInsert> (*i);
3500                         if (p) {
3501                                 p->flush_buffers (nframes);
3502                         }
3503                 }
3504         }
3505 }
3506
3507 int
3508 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3509 {
3510         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3511
3512         if (!lm.locked()) {
3513                 return 0;
3514         }
3515
3516         if (!_active) {
3517                 silence_unlocked (nframes);
3518                 return 0;
3519         }
3520
3521         if (session_state_changing) {
3522                 if (_session.transport_speed() != 0.0f) {
3523                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3524                            so we cannot use them. Be silent till this is over.
3525
3526                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3527                         */
3528                         silence_unlocked (nframes);
3529                         return 0;
3530                 }
3531                 /* we're really not rolling, so we're either delivery silence or actually
3532                    monitoring, both of which are safe to do while session_state_changing is true.
3533                 */
3534         }
3535
3536         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3537
3538         fill_buffers_with_input (bufs, _input, nframes);
3539
3540         if (_meter_point == MeterInput) {
3541                 _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true);
3542         }
3543
3544         _amp->apply_gain_automation (false);
3545         _trim->apply_gain_automation (false);
3546         passthru (bufs, start_frame, end_frame, nframes, 0);
3547
3548         flush_processor_buffers_locked (nframes);
3549
3550         return 0;
3551 }
3552
3553 int
3554 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3555 {
3556         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3557         if (!lm.locked()) {
3558                 return 0;
3559         }
3560
3561         if (!_active) {
3562                 silence_unlocked (nframes);
3563                 return 0;
3564         }
3565
3566         framepos_t unused = 0;
3567
3568         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3569                 return 0;
3570         }
3571
3572         _silent = false;
3573
3574         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3575
3576         fill_buffers_with_input (bufs, _input, nframes);
3577
3578         if (_meter_point == MeterInput) {
3579                 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
3580         }
3581
3582         passthru (bufs, start_frame, end_frame, nframes, declick);
3583
3584         flush_processor_buffers_locked (nframes);
3585
3586         return 0;
3587 }
3588
3589 int
3590 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3591 {
3592         silence (nframes);
3593         flush_processor_buffers_locked (nframes);
3594         return 0;
3595 }
3596
3597 void
3598 Route::flush_processors ()
3599 {
3600         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3601
3602         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3603                 (*i)->flush ();
3604         }
3605 }
3606
3607 #ifdef __clang__
3608 __attribute__((annotate("realtime")))
3609 #endif
3610 bool
3611 Route::apply_processor_changes_rt ()
3612 {
3613         int emissions = EmitNone;
3614
3615         if (_pending_meter_point != _meter_point) {
3616                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3617                 if (pwl.locked()) {
3618                         /* meters always have buffers for 'processor_max_streams'
3619                          * they can be re-positioned without re-allocation */
3620                         if (set_meter_point_unlocked()) {
3621                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3622                         } else {
3623                                 emissions |= EmitMeterChanged;
3624                         }
3625                 }
3626         }
3627
3628         bool changed = false;
3629
3630         if (g_atomic_int_get (&_pending_process_reorder)) {
3631                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3632                 if (pwl.locked()) {
3633                         apply_processor_order (_pending_processor_order);
3634                         setup_invisible_processors ();
3635                         changed = true;
3636                         g_atomic_int_set (&_pending_process_reorder, 0);
3637                         emissions |= EmitRtProcessorChange;
3638                 }
3639         }
3640         if (changed) {
3641                 set_processor_positions ();
3642         }
3643         if (emissions != 0) {
3644                 g_atomic_int_set (&_pending_signals, emissions);
3645                 return true;
3646         }
3647         return (!selfdestruct_sequence.empty ());
3648 }
3649
3650 void
3651 Route::emit_pending_signals ()
3652 {
3653         int sig = g_atomic_int_and (&_pending_signals, 0);
3654         if (sig & EmitMeterChanged) {
3655                 _meter->emit_configuration_changed();
3656                 meter_change (); /* EMIT SIGNAL */
3657                 if (sig & EmitMeterVisibilityChange) {
3658                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3659                 } else {
3660                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3661                 }
3662         }
3663         if (sig & EmitRtProcessorChange) {
3664                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3665         }
3666
3667         /* this would be a job for the butler.
3668          * Conceptually we should not take processe/processor locks here.
3669          * OTOH its more efficient (less overhead for summoning the butler and
3670          * telling her what do do) and signal emission is called
3671          * directly after the process callback, which decreases the chance
3672          * of x-runs when taking the locks.
3673          */
3674         while (!selfdestruct_sequence.empty ()) {
3675                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3676                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3677                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3678                 selfdestruct_sequence.pop_back ();
3679                 lx.release ();
3680                 if (proc) {
3681                         remove_processor (proc);
3682                 }
3683         }
3684 }
3685
3686 void
3687 Route::set_meter_point (MeterPoint p, bool force)
3688 {
3689         if (_pending_meter_point == p && !force) {
3690                 return;
3691         }
3692
3693         if (force || !AudioEngine::instance()->running()) {
3694                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3695                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3696                 _pending_meter_point = p;
3697                 _meter->emit_configuration_changed();
3698                 meter_change (); /* EMIT SIGNAL */
3699                 if (set_meter_point_unlocked()) {
3700                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3701                 } else {
3702                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3703                 }
3704         } else {
3705                 _pending_meter_point = p;
3706         }
3707 }
3708
3709
3710 #ifdef __clang__
3711 __attribute__((annotate("realtime")))
3712 #endif
3713 bool
3714 Route::set_meter_point_unlocked ()
3715 {
3716 #ifndef NDEBUG
3717         /* Caller must hold process and processor write lock */
3718         assert (!AudioEngine::instance()->process_lock().trylock());
3719         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3720         assert (!lm.locked ());
3721 #endif
3722
3723         _meter_point = _pending_meter_point;
3724
3725         bool meter_was_visible_to_user = _meter->display_to_user ();
3726
3727         if (!_custom_meter_position_noted) {
3728                 maybe_note_meter_position ();
3729         }
3730
3731         if (_meter_point != MeterCustom) {
3732
3733                 _meter->set_display_to_user (false);
3734
3735                 setup_invisible_processors ();
3736
3737         } else {
3738                 _meter->set_display_to_user (true);
3739
3740                 /* If we have a previous position for the custom meter, try to put it there */
3741                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3742                 if (after) {
3743                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3744                         if (i != _processors.end ()) {
3745                                 _processors.remove (_meter);
3746                                 _processors.insert (i, _meter);
3747                         }
3748                 } else {// at end, right before the mains_out/panner
3749                         _processors.remove (_meter);
3750                         ProcessorList::iterator main = _processors.end();
3751                         _processors.insert (--main, _meter);
3752                 }
3753         }
3754
3755         /* Set up the meter for its new position */
3756
3757         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3758
3759         ChanCount m_in;
3760
3761         if (loc == _processors.begin()) {
3762                 m_in = _input->n_ports();
3763         } else {
3764                 ProcessorList::iterator before = loc;
3765                 --before;
3766                 m_in = (*before)->output_streams ();
3767         }
3768
3769         _meter->reflect_inputs (m_in);
3770
3771         /* we do not need to reconfigure the processors, because the meter
3772            (a) is always ready to handle processor_max_streams
3773            (b) is always an N-in/N-out processor, and thus moving
3774            it doesn't require any changes to the other processors.
3775         */
3776
3777         /* these should really be done after releasing the lock
3778          * but all those signals are subscribed to with gui_thread()
3779          * so we're safe.
3780          */
3781          return (_meter->display_to_user() != meter_was_visible_to_user);
3782 }
3783
3784 void
3785 Route::listen_position_changed ()
3786 {
3787         {
3788                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3789                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3790                 ProcessorState pstate (this);
3791
3792                 if (configure_processors_unlocked (0, &lm)) {
3793                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
3794                         pstate.restore ();
3795                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
3796                         return;
3797                 }
3798         }
3799
3800         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3801         _session.set_dirty ();
3802 }
3803
3804 boost::shared_ptr<CapturingProcessor>
3805 Route::add_export_point()
3806 {
3807         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3808         if (!_capturing_processor) {
3809                 lm.release();
3810                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3811                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3812
3813                 // this aligns all tracks; but not tracks + busses
3814                 assert (_session.worst_track_latency () >= _initial_delay);
3815                 _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay));
3816                 _capturing_processor->activate ();
3817
3818                 configure_processors_unlocked (0, &lw);
3819
3820         }
3821
3822         return _capturing_processor;
3823 }
3824
3825 framecnt_t
3826 Route::update_signal_latency ()
3827 {
3828         framecnt_t l = _output->user_latency();
3829         framecnt_t lamp = 0;
3830         bool before_amp = true;
3831         framecnt_t ltrim = 0;
3832         bool before_trim = true;
3833
3834         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3835                 if ((*i)->active ()) {
3836                         l += (*i)->signal_latency ();
3837                 }
3838                 if ((*i) == _amp) {
3839                         before_amp = false;
3840                 }
3841                 if ((*i) == _trim) {
3842                         before_amp = false;
3843                 }
3844                 if (before_amp) {
3845                         lamp = l;
3846                 }
3847                 if (before_trim) {
3848                         lamp = l;
3849                 }
3850         }
3851
3852         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3853
3854         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
3855         _signal_latency_at_amp_position = lamp;
3856         _signal_latency_at_trim_position = ltrim;
3857
3858         if (_signal_latency != l) {
3859                 _signal_latency = l;
3860                 signal_latency_changed (); /* EMIT SIGNAL */
3861         }
3862
3863         return _signal_latency;
3864 }
3865
3866 void
3867 Route::set_user_latency (framecnt_t nframes)
3868 {
3869         _output->set_user_latency (nframes);
3870         _session.update_latency_compensation ();
3871 }
3872
3873 void
3874 Route::set_latency_compensation (framecnt_t longest_session_latency)
3875 {
3876         framecnt_t old = _initial_delay;
3877
3878         if (_signal_latency < longest_session_latency) {
3879                 _initial_delay = longest_session_latency - _signal_latency;
3880         } else {
3881                 _initial_delay = 0;
3882         }
3883
3884         DEBUG_TRACE (DEBUG::Latency, string_compose (
3885                              "%1: compensate for maximum latency of %2,"
3886                              "given own latency of %3, using initial delay of %4\n",
3887                              name(), longest_session_latency, _signal_latency, _initial_delay));
3888
3889         if (_initial_delay != old) {
3890                 initial_delay_changed (); /* EMIT SIGNAL */
3891         }
3892
3893         if (_session.transport_stopped()) {
3894                 _roll_delay = _initial_delay;
3895         }
3896 }
3897
3898 void
3899 Route::set_block_size (pframes_t nframes)
3900 {
3901         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3902                 (*i)->set_block_size (nframes);
3903         }
3904
3905         _session.ensure_buffers (n_process_buffers ());
3906 }
3907
3908 void
3909 Route::protect_automation ()
3910 {
3911         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3912                 (*i)->protect_automation();
3913 }
3914
3915 /** @param declick 1 to set a pending declick fade-in,
3916  *                -1 to set a pending declick fade-out
3917  */
3918 void
3919 Route::set_pending_declick (int declick)
3920 {
3921         if (_declickable) {
3922                 /* this call is not allowed to turn off a pending declick */
3923                 if (declick) {
3924                         _pending_declick = declick;
3925                 }
3926         } else {
3927                 _pending_declick = 0;
3928         }
3929 }
3930
3931 /** Shift automation forwards from a particular place, thereby inserting time.
3932  *  Adds undo commands for any shifts that are performed.
3933  *
3934  * @param pos Position to start shifting from.
3935  * @param frames Amount to shift forwards by.
3936  */
3937
3938 void
3939 Route::shift (framepos_t pos, framecnt_t frames)
3940 {
3941         /* gain automation */
3942         {
3943                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3944
3945                 XMLNode &before = gc->alist()->get_state ();
3946                 gc->alist()->shift (pos, frames);
3947                 XMLNode &after = gc->alist()->get_state ();
3948                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3949         }
3950
3951         /* gain automation */
3952         {
3953                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3954
3955                 XMLNode &before = gc->alist()->get_state ();
3956                 gc->alist()->shift (pos, frames);
3957                 XMLNode &after = gc->alist()->get_state ();
3958                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3959         }
3960
3961         // TODO mute automation ??
3962
3963         /* pan automation */
3964         if (_pannable) {
3965                 ControlSet::Controls& c (_pannable->controls());
3966
3967                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3968                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3969                         if (pc) {
3970                                 boost::shared_ptr<AutomationList> al = pc->alist();
3971                                 XMLNode& before = al->get_state ();
3972                                 al->shift (pos, frames);
3973                                 XMLNode& after = al->get_state ();
3974                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3975                         }
3976                 }
3977         }
3978
3979         /* redirect automation */
3980         {
3981                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3982                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3983
3984                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3985
3986                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3987                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3988                                 if (ac) {
3989                                         boost::shared_ptr<AutomationList> al = ac->alist();
3990                                         XMLNode &before = al->get_state ();
3991                                         al->shift (pos, frames);
3992                                         XMLNode &after = al->get_state ();
3993                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3994                                 }
3995                         }
3996                 }
3997         }
3998 }
3999
4000 void
4001 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4002 {
4003         boost::shared_ptr<Processor> processor (p.lock ());
4004         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4005         if (!pi) {
4006                 return;
4007         }
4008         pi->set_state_dir (d);
4009 }
4010
4011 int
4012 Route::save_as_template (const string& path, const string& name)
4013 {
4014         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4015         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4016
4017         XMLNode& node (state (false));
4018
4019         XMLTree tree;
4020
4021         IO::set_name_in_state (*node.children().front(), name);
4022
4023         tree.set_root (&node);
4024
4025         /* return zero on success, non-zero otherwise */
4026         return !tree.write (path.c_str());
4027 }
4028
4029
4030 bool
4031 Route::set_name (const string& str)
4032 {
4033         if (str.empty ()) {
4034                 return false;
4035         }
4036
4037         if (str == name()) {
4038                 return true;
4039         }
4040
4041         string name = Route::ensure_track_or_route_name (str, _session);
4042         SessionObject::set_name (name);
4043
4044         bool ret = (_input->set_name(name) && _output->set_name(name));
4045
4046         if (ret) {
4047                 /* rename the main outs. Leave other IO processors
4048                  * with whatever name they already have, because its
4049                  * just fine as it is (it will not contain the route
4050                  * name if its a port insert, port send or port return).
4051                  */
4052
4053                 if (_main_outs) {
4054                         if (_main_outs->set_name (name)) {
4055                                 /* XXX returning false here is stupid because
4056                                    we already changed the route name.
4057                                 */
4058                                 return false;
4059                         }
4060                 }
4061         }
4062
4063         return ret;
4064 }
4065
4066 /** Set the name of a route in an XML description.
4067  *  @param node XML <Route> node to set the name in.
4068  *  @param name New name.
4069  */
4070 void
4071 Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
4072 {
4073         node.set_property (X_("name"), name);
4074
4075         XMLNodeList children = node.children();
4076         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4077
4078                 if ((*i)->name() == X_("IO")) {
4079
4080                         IO::set_name_in_state (**i, name);
4081
4082                 } else if ((*i)->name() == X_("Processor")) {
4083
4084                         std::string str;
4085                         if ((*i)->get_property (X_("role"), str) && str == X_("Main")) {
4086                                 (*i)->set_property (X_("name"), name);
4087                         }
4088
4089                 } else if ((*i)->name() == X_("Diskstream")) {
4090
4091                         if (rename_playlist) {
4092                                 (*i)->set_property (X_("playlist"), name + ".1");
4093                         }
4094                         (*i)->set_property (X_("name"), name);
4095
4096                 }
4097         }
4098 }
4099
4100 boost::shared_ptr<Send>
4101 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4102 {
4103         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4104
4105         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4106                 boost::shared_ptr<InternalSend> send;
4107
4108                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4109                         if (send->target_route() == target) {
4110                                 return send;
4111                         }
4112                 }
4113         }
4114
4115         return boost::shared_ptr<Send>();
4116 }
4117
4118 void
4119 Route::set_denormal_protection (bool yn)
4120 {
4121         if (_denormal_protection != yn) {
4122                 _denormal_protection = yn;
4123                 denormal_protection_changed (); /* EMIT SIGNAL */
4124         }
4125 }
4126
4127 bool
4128 Route::denormal_protection () const
4129 {
4130         return _denormal_protection;
4131 }
4132
4133 void
4134 Route::set_active (bool yn, void* src)
4135 {
4136         if (_session.transport_rolling()) {
4137                 return;
4138         }
4139
4140         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4141                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4142                 return;
4143         }
4144
4145         if (_active != yn) {
4146                 _active = yn;
4147                 _input->set_active (yn);
4148                 _output->set_active (yn);
4149                 flush_processors ();
4150                 active_changed (); // EMIT SIGNAL
4151                 _session.set_dirty ();
4152         }
4153 }
4154
4155 boost::shared_ptr<Pannable>
4156 Route::pannable() const
4157 {
4158         return _pannable;
4159 }
4160
4161 boost::shared_ptr<Panner>
4162 Route::panner() const
4163 {
4164         /* may be null ! */
4165         return _main_outs->panner_shell()->panner();
4166 }
4167
4168 boost::shared_ptr<PannerShell>
4169 Route::panner_shell() const
4170 {
4171         return _main_outs->panner_shell();
4172 }
4173
4174 boost::shared_ptr<GainControl>
4175 Route::gain_control() const
4176 {
4177         return _gain_control;
4178 }
4179
4180 boost::shared_ptr<GainControl>
4181 Route::trim_control() const
4182 {
4183         return _trim_control;
4184 }
4185
4186 boost::shared_ptr<PhaseControl>
4187 Route::phase_control() const
4188 {
4189         return _phase_control;
4190 }
4191
4192 boost::shared_ptr<AutomationControl>
4193 Route::get_control (const Evoral::Parameter& param)
4194 {
4195         /* either we own the control or .... */
4196
4197         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4198
4199         if (!c) {
4200
4201                 /* maybe one of our processors does or ... */
4202
4203                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4204                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4205                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4206                                 break;
4207                         }
4208                 }
4209         }
4210
4211         if (!c) {
4212
4213                 /* nobody does so we'll make a new one */
4214
4215                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4216                 add_control(c);
4217         }
4218
4219         return c;
4220 }
4221
4222 boost::shared_ptr<Processor>
4223 Route::nth_plugin (uint32_t n) const
4224 {
4225         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4226         ProcessorList::const_iterator i;
4227
4228         for (i = _processors.begin(); i != _processors.end(); ++i) {
4229                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4230                         if (n-- == 0) {
4231                                 return *i;
4232                         }
4233                 }
4234         }
4235
4236         return boost::shared_ptr<Processor> ();
4237 }
4238
4239 boost::shared_ptr<Processor>
4240 Route::nth_send (uint32_t n) const
4241 {
4242         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4243         ProcessorList::const_iterator i;
4244
4245         for (i = _processors.begin(); i != _processors.end(); ++i) {
4246                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4247
4248                         if ((*i)->name().find (_("Monitor")) == 0) {
4249                                 /* send to monitor section is not considered
4250                                    to be an accessible send.
4251                                 */
4252                                 continue;
4253                         }
4254
4255                         if (n-- == 0) {
4256                                 return *i;
4257                         }
4258                 }
4259         }
4260
4261         return boost::shared_ptr<Processor> ();
4262 }
4263
4264 bool
4265 Route::has_io_processor_named (const string& name)
4266 {
4267         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4268         ProcessorList::iterator i;
4269
4270         for (i = _processors.begin(); i != _processors.end(); ++i) {
4271                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4272                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4273                         if ((*i)->name() == name) {
4274                                 return true;
4275                         }
4276                 }
4277         }
4278
4279         return false;
4280 }
4281
4282 void
4283 Route::set_processor_positions ()
4284 {
4285         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4286
4287         bool had_amp = false;
4288         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4289                 (*i)->set_pre_fader (!had_amp);
4290                 if (*i == _amp) {
4291                         had_amp = true;
4292                 }
4293         }
4294 }
4295
4296 /** Called when there is a proposed change to the input port count */
4297 bool
4298 Route::input_port_count_changing (ChanCount to)
4299 {
4300         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4301         if (c.empty()) {
4302                 /* The processors cannot be configured with the new input arrangement, so
4303                    block the change.
4304                 */
4305                 return true;
4306         }
4307
4308         /* The change is ok */
4309         return false;
4310 }
4311
4312 /** Called when there is a proposed change to the output port count */
4313 bool
4314 Route::output_port_count_changing (ChanCount to)
4315 {
4316         if (_strict_io && !_in_configure_processors) {
4317                 return true;
4318         }
4319         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4320                 if (processor_out_streams.get(*t) > to.get(*t)) {
4321                         return true;
4322                 }
4323         }
4324         /* The change is ok */
4325         return false;
4326 }
4327
4328 list<string>
4329 Route::unknown_processors () const
4330 {
4331         list<string> p;
4332
4333         if (_session.get_disable_all_loaded_plugins ()) {
4334                 // Do not list "missing plugins" if they are explicitly disabled
4335                 return p;
4336         }
4337
4338         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4339         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4340                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4341                         p.push_back ((*i)->name ());
4342                 }
4343         }
4344
4345         return p;
4346 }
4347
4348
4349 framecnt_t
4350 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4351 {
4352         /* we assume that all our input ports feed all our output ports. its not
4353            universally true, but the alternative is way too corner-case to worry about.
4354         */
4355
4356         LatencyRange all_connections;
4357
4358         if (from.empty()) {
4359                 all_connections.min = 0;
4360                 all_connections.max = 0;
4361         } else {
4362                 all_connections.min = ~((pframes_t) 0);
4363                 all_connections.max = 0;
4364
4365                 /* iterate over all "from" ports and determine the latency range for all of their
4366                    connections to the "outside" (outside of this Route).
4367                 */
4368
4369                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4370
4371                         LatencyRange range;
4372
4373                         p->get_connected_latency_range (range, playback);
4374
4375                         all_connections.min = min (all_connections.min, range.min);
4376                         all_connections.max = max (all_connections.max, range.max);
4377                 }
4378         }
4379
4380         /* set the "from" port latencies to the max/min range of all their connections */
4381
4382         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4383                 p->set_private_latency_range (all_connections, playback);
4384         }
4385
4386         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4387
4388         all_connections.min += our_latency;
4389         all_connections.max += our_latency;
4390
4391         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4392                 p->set_private_latency_range (all_connections, playback);
4393         }
4394
4395         return all_connections.max;
4396 }
4397
4398 framecnt_t
4399 Route::set_private_port_latencies (bool playback) const
4400 {
4401         framecnt_t own_latency = 0;
4402
4403         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4404            OR LATENCY CALLBACK.
4405
4406            This is called (early) from the latency callback. It computes the REAL
4407            latency associated with each port and stores the result as the "private"
4408            latency of the port. A later call to Route::set_public_port_latencies()
4409            sets all ports to the same value to reflect the fact that we do latency
4410            compensation and so all signals are delayed by the same amount as they
4411            flow through ardour.
4412         */
4413
4414         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4415                 if ((*i)->active ()) {
4416                         own_latency += (*i)->signal_latency ();
4417                 }
4418         }
4419
4420         if (playback) {
4421                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4422                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4423         } else {
4424                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4425                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4426         }
4427 }
4428
4429 void
4430 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4431 {
4432         /* this is called to set the JACK-visible port latencies, which take
4433            latency compensation into account.
4434         */
4435
4436         LatencyRange range;
4437
4438         range.min = value;
4439         range.max = value;
4440
4441         {
4442                 const PortSet& ports (_input->ports());
4443                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4444                         p->set_public_latency_range (range, playback);
4445                 }
4446         }
4447
4448         {
4449                 const PortSet& ports (_output->ports());
4450                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4451                         p->set_public_latency_range (range, playback);
4452                 }
4453         }
4454 }
4455
4456 /** Put the invisible processors in the right place in _processors.
4457  *  Must be called with a writer lock on _processor_lock held.
4458  */
4459 #ifdef __clang__
4460 __attribute__((annotate("realtime")))
4461 #endif
4462 void
4463 Route::setup_invisible_processors ()
4464 {
4465 #ifndef NDEBUG
4466         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4467         assert (!lm.locked ());
4468 #endif
4469
4470         if (!_main_outs) {
4471                 /* too early to be doing this stuff */
4472                 return;
4473         }
4474
4475         /* we'll build this new list here and then use it
4476          *
4477          * TODO put the ProcessorList is on the stack for RT-safety.
4478          */
4479
4480         ProcessorList new_processors;
4481
4482         /* find visible processors */
4483
4484         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4485                 if ((*i)->display_to_user ()) {
4486                         new_processors.push_back (*i);
4487                 }
4488         }
4489
4490         /* find the amp */
4491
4492         ProcessorList::iterator amp = find (new_processors.begin(), new_processors.end(), _amp);
4493
4494         if (amp == new_processors.end ()) {
4495                 error << string_compose (_("Amp/Fader on Route '%1' went AWOL. Re-added."), name()) << endmsg;
4496                 new_processors.push_front (_amp);
4497                 amp = find (new_processors.begin(), new_processors.end(), _amp);
4498         }
4499
4500         /* and the processor after the amp */
4501
4502         ProcessorList::iterator after_amp = amp;
4503         ++after_amp;
4504
4505         /* METER */
4506
4507         if (_meter) {
4508                 switch (_meter_point) {
4509                 case MeterInput:
4510                         assert (!_meter->display_to_user ());
4511                         new_processors.push_front (_meter);
4512                         break;
4513                 case MeterPreFader:
4514                         assert (!_meter->display_to_user ());
4515                         new_processors.insert (amp, _meter);
4516                         break;
4517                 case MeterPostFader:
4518                         /* do nothing here */
4519                         break;
4520                 case MeterOutput:
4521                         /* do nothing here */
4522                         break;
4523                 case MeterCustom:
4524                         /* the meter is visible, so we don't touch it here */
4525                         break;
4526                 }
4527         }
4528
4529         /* MAIN OUTS */
4530
4531         assert (_main_outs);
4532         assert (!_main_outs->display_to_user ());
4533         new_processors.push_back (_main_outs);
4534
4535         /* iterator for the main outs */
4536
4537         ProcessorList::iterator main = new_processors.end();
4538         --main;
4539
4540         /* OUTPUT METERING */
4541
4542         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4543                 assert (!_meter->display_to_user ());
4544
4545                 /* add the processor just before or just after the main outs */
4546
4547                 ProcessorList::iterator meter_point = main;
4548
4549                 if (_meter_point == MeterOutput) {
4550                         ++meter_point;
4551                 }
4552                 new_processors.insert (meter_point, _meter);
4553         }
4554
4555         /* MONITOR SEND */
4556
4557         if (_monitor_send && !is_monitor ()) {
4558                 assert (!_monitor_send->display_to_user ());
4559                 switch (Config->get_listen_position ()) {
4560                 case PreFaderListen:
4561                         switch (Config->get_pfl_position ()) {
4562                         case PFLFromBeforeProcessors:
4563                                 new_processors.push_front (_monitor_send);
4564                                 break;
4565                         case PFLFromAfterProcessors:
4566                                 new_processors.insert (amp, _monitor_send);
4567                                 break;
4568                         }
4569                         _monitor_send->set_can_pan (false);
4570                         break;
4571                 case AfterFaderListen:
4572                         switch (Config->get_afl_position ()) {
4573                         case AFLFromBeforeProcessors:
4574                                 new_processors.insert (after_amp, _monitor_send);
4575                                 break;
4576                         case AFLFromAfterProcessors:
4577                                 new_processors.insert (new_processors.end(), _monitor_send);
4578                                 break;
4579                         }
4580                         _monitor_send->set_can_pan (true);
4581                         break;
4582                 }
4583         }
4584
4585 #if 0 // not used - just yet
4586         if (!is_master() && !is_monitor() && !is_auditioner()) {
4587                 new_processors.push_front (_delayline);
4588         }
4589 #endif
4590
4591         /* MONITOR CONTROL */
4592
4593         if (_monitor_control && is_monitor ()) {
4594                 assert (!_monitor_control->display_to_user ());
4595                 new_processors.insert (amp, _monitor_control);
4596         }
4597
4598         /* TRIM CONTROL */
4599
4600         if (_trim && _trim->active()) {
4601                 assert (!_trim->display_to_user ());
4602                 new_processors.push_front (_trim);
4603         }
4604
4605         /* INTERNAL RETURN */
4606
4607         /* doing this here means that any monitor control will come after
4608            the return and trim.
4609         */
4610
4611         if (_intreturn) {
4612                 assert (!_intreturn->display_to_user ());
4613                 new_processors.push_front (_intreturn);
4614         }
4615
4616         /* EXPORT PROCESSOR */
4617
4618         if (_capturing_processor) {
4619                 assert (!_capturing_processor->display_to_user ());
4620                 new_processors.push_front (_capturing_processor);
4621         }
4622
4623         _processors = new_processors;
4624
4625         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4626                 if (!(*i)->display_to_user () && !(*i)->enabled () && (*i) != _monitor_send) {
4627                         (*i)->enable (true);
4628                 }
4629         }
4630
4631         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4632         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4633                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4634         }
4635 }
4636
4637 void
4638 Route::unpan ()
4639 {
4640         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4641         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4642
4643         _pannable.reset ();
4644
4645         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4646                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4647                 if (d) {
4648                         d->unpan ();
4649                 }
4650         }
4651 }
4652
4653 /** If the meter point is `Custom', make a note of where the meter is.
4654  *  This is so that if the meter point is subsequently set to something else,
4655  *  and then back to custom, we can put the meter back where it was last time
4656  *  custom was enabled.
4657  *
4658  *  Must be called with the _processor_lock held.
4659  */
4660 void
4661 Route::maybe_note_meter_position ()
4662 {
4663         if (_meter_point != MeterCustom) {
4664                 return;
4665         }
4666
4667         _custom_meter_position_noted = true;
4668         /* custom meter points range from after trim to before panner/main_outs
4669          * this is a limitation by the current processor UI
4670          */
4671         bool seen_trim = false;
4672         _processor_after_last_custom_meter.reset();
4673         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4674                 if ((*i) == _trim) {
4675                         seen_trim = true;
4676                 }
4677                 if ((*i) == _main_outs) {
4678                         _processor_after_last_custom_meter = *i;
4679                         break;
4680                 }
4681                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4682                         if (!seen_trim) {
4683                                 _processor_after_last_custom_meter = _trim;
4684                         } else {
4685                                 ProcessorList::iterator j = i;
4686                                 ++j;
4687                                 assert(j != _processors.end ()); // main_outs should be before
4688                                 _processor_after_last_custom_meter = *j;
4689                         }
4690                         break;
4691                 }
4692         }
4693         assert(_processor_after_last_custom_meter.lock());
4694 }
4695
4696 boost::shared_ptr<Processor>
4697 Route::processor_by_id (PBD::ID id) const
4698 {
4699         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4700         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4701                 if ((*i)->id() == id) {
4702                         return *i;
4703                 }
4704         }
4705
4706         return boost::shared_ptr<Processor> ();
4707 }
4708
4709 /** @return the monitoring state, or in other words what data we are pushing
4710  *  into the route (data from the inputs, data from disk or silence)
4711  */
4712 MonitorState
4713 Route::monitoring_state () const
4714 {
4715         return MonitoringInput;
4716 }
4717
4718 /** @return what we should be metering; either the data coming from the input
4719  *  IO or the data that is flowing through the route.
4720  */
4721 MeterState
4722 Route::metering_state () const
4723 {
4724         return MeteringRoute;
4725 }
4726
4727 bool
4728 Route::has_external_redirects () const
4729 {
4730         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4731
4732                 /* ignore inactive processors and obviously ignore the main
4733                  * outs since everything has them and we don't care.
4734                  */
4735
4736                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4737                         return true;;
4738                 }
4739         }
4740
4741         return false;
4742 }
4743
4744 boost::shared_ptr<Processor>
4745 Route::the_instrument () const
4746 {
4747         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4748         return the_instrument_unlocked ();
4749 }
4750
4751 boost::shared_ptr<Processor>
4752 Route::the_instrument_unlocked () const
4753 {
4754         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4755                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
4756                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
4757                         return (*i);
4758                 }
4759         }
4760         return boost::shared_ptr<Processor>();
4761 }
4762
4763
4764
4765 void
4766 Route::non_realtime_locate (framepos_t pos)
4767 {
4768         if (_pannable) {
4769                 _pannable->transport_located (pos);
4770         }
4771
4772         if (_delayline.get()) {
4773                 _delayline.get()->flush();
4774         }
4775
4776         {
4777                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4778                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4779
4780                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4781                         (*i)->transport_located (pos);
4782                 }
4783         }
4784         _roll_delay = _initial_delay;
4785 }
4786
4787 void
4788 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4789 {
4790         size_t n_buffers;
4791         size_t i;
4792
4793         /* MIDI
4794          *
4795          * We don't currently mix MIDI input together, so we don't need the
4796          * complex logic of the audio case.
4797          */
4798
4799         n_buffers = bufs.count().n_midi ();
4800
4801         for (i = 0; i < n_buffers; ++i) {
4802
4803                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4804                 MidiBuffer& buf (bufs.get_midi (i));
4805
4806                 if (source_port) {
4807                         buf.copy (source_port->get_midi_buffer(nframes));
4808                 } else {
4809                         buf.silence (nframes);
4810                 }
4811         }
4812
4813         /* AUDIO */
4814
4815         n_buffers = bufs.count().n_audio();
4816
4817         size_t n_ports = io->n_ports().n_audio();
4818         float scaling = 1.0f;
4819
4820         if (n_ports > n_buffers) {
4821                 scaling = ((float) n_buffers) / n_ports;
4822         }
4823
4824         for (i = 0; i < n_ports; ++i) {
4825
4826                 /* if there are more ports than buffers, map them onto buffers
4827                  * in a round-robin fashion
4828                  */
4829
4830                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4831                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4832
4833
4834                 if (i < n_buffers) {
4835
4836                         /* first time through just copy a channel into
4837                            the output buffer.
4838                         */
4839
4840                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4841
4842                         if (scaling != 1.0f) {
4843                                 buf.apply_gain (scaling, nframes);
4844                         }
4845
4846                 } else {
4847
4848                         /* on subsequent times around, merge data from
4849                          * the port with what is already there
4850                          */
4851
4852                         if (scaling != 1.0f) {
4853                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4854                         } else {
4855                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4856                         }
4857                 }
4858         }
4859
4860         /* silence any remaining buffers */
4861
4862         for (; i < n_buffers; ++i) {
4863                 AudioBuffer& buf (bufs.get_audio (i));
4864                 buf.silence (nframes);
4865         }
4866
4867         /* establish the initial setup of the buffer set, reflecting what was
4868            copied into it. unless, of course, we are the auditioner, in which
4869            case nothing was fed into it from the inputs at all.
4870         */
4871
4872         if (!is_auditioner()) {
4873                 bufs.set_count (io->n_ports());
4874         }
4875 }
4876
4877 boost::shared_ptr<AutomationControl>
4878 Route::pan_azimuth_control() const
4879 {
4880 #ifdef MIXBUS
4881 # undef MIXBUS_PORTS_H
4882 # include "../../gtk2_ardour/mixbus_ports.h"
4883         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
4884         if (!plug) {
4885                 return boost::shared_ptr<AutomationControl>();
4886         }
4887         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
4888 #else
4889         if (!_pannable || !panner()) {
4890                 return boost::shared_ptr<AutomationControl>();
4891         }
4892         return _pannable->pan_azimuth_control;
4893 #endif
4894 }
4895
4896 boost::shared_ptr<AutomationControl>
4897 Route::pan_elevation_control() const
4898 {
4899         if (Profile->get_mixbus() || !_pannable || !panner()) {
4900                 return boost::shared_ptr<AutomationControl>();
4901         }
4902
4903         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4904
4905         if (c.find (PanElevationAutomation) != c.end()) {
4906                 return _pannable->pan_elevation_control;
4907         } else {
4908                 return boost::shared_ptr<AutomationControl>();
4909         }
4910 }
4911 boost::shared_ptr<AutomationControl>
4912 Route::pan_width_control() const
4913 {
4914 #ifdef MIXBUS
4915         if (mixbus() && _ch_pre) {
4916                 //mono blend
4917                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 5)));
4918         }
4919 #endif
4920         if (Profile->get_mixbus() || !_pannable || !panner()) {
4921                 return boost::shared_ptr<AutomationControl>();
4922         }
4923
4924         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4925
4926         if (c.find (PanWidthAutomation) != c.end()) {
4927                 return _pannable->pan_width_control;
4928         } else {
4929                 return boost::shared_ptr<AutomationControl>();
4930         }
4931 }
4932 boost::shared_ptr<AutomationControl>
4933 Route::pan_frontback_control() const
4934 {
4935         if (Profile->get_mixbus() || !_pannable || !panner()) {
4936                 return boost::shared_ptr<AutomationControl>();
4937         }
4938
4939         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4940
4941         if (c.find (PanFrontBackAutomation) != c.end()) {
4942                 return _pannable->pan_frontback_control;
4943         } else {
4944                 return boost::shared_ptr<AutomationControl>();
4945         }
4946 }
4947 boost::shared_ptr<AutomationControl>
4948 Route::pan_lfe_control() const
4949 {
4950         if (Profile->get_mixbus() || !_pannable || !panner()) {
4951                 return boost::shared_ptr<AutomationControl>();
4952         }
4953
4954         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4955
4956         if (c.find (PanLFEAutomation) != c.end()) {
4957                 return _pannable->pan_lfe_control;
4958         } else {
4959                 return boost::shared_ptr<AutomationControl>();
4960         }
4961 }
4962
4963 uint32_t
4964 Route::eq_band_cnt () const
4965 {
4966         if (Profile->get_mixbus()) {
4967 #ifdef MIXBUS32C
4968                 if (is_master() || mixbus()) {
4969                         return 3;
4970                 } else {
4971                         return 4;
4972                 }
4973 #else
4974                 return 3;
4975 #endif
4976         } else {
4977                 /* Ardour has no well-known EQ object */
4978                 return 0;
4979         }
4980 }
4981
4982 boost::shared_ptr<AutomationControl>
4983 Route::eq_gain_controllable (uint32_t band) const
4984 {
4985 #ifdef MIXBUS
4986         boost::shared_ptr<PluginInsert> eq = ch_eq();
4987
4988         if (!eq) {
4989                 return boost::shared_ptr<AutomationControl>();
4990         }
4991
4992         uint32_t port_number;
4993         if (is_master() || mixbus()) {
4994                 switch (band) {
4995                         case 0: port_number = 4; break;
4996                         case 1: port_number = 3; break;
4997                         case 2: port_number = 2; break;
4998                         default:
4999                                 return boost::shared_ptr<AutomationControl>();
5000                 }
5001         } else {
5002 #ifdef MIXBUS32C
5003                 switch (band) {
5004                         case 0: port_number = 14; break;
5005                         case 1: port_number = 12; break;
5006                         case 2: port_number = 10; break;
5007                         case 3: port_number =  8; break;
5008                         default:
5009                                 return boost::shared_ptr<AutomationControl>();
5010                 }
5011 #else
5012                 switch (band) {
5013                         case 0: port_number = 8; break;
5014                         case 1: port_number = 6; break;
5015                         case 2: port_number = 4; break;
5016                         default:
5017                                 return boost::shared_ptr<AutomationControl>();
5018                 }
5019 #endif
5020         }
5021
5022         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5023 #else
5024         return boost::shared_ptr<AutomationControl>();
5025 #endif
5026 }
5027 boost::shared_ptr<AutomationControl>
5028 Route::eq_freq_controllable (uint32_t band) const
5029 {
5030 #ifdef MIXBUS
5031         if (mixbus() || is_master()) {
5032                 /* no frequency controls for mixbusses or master */
5033                 return boost::shared_ptr<AutomationControl>();
5034         }
5035
5036         boost::shared_ptr<PluginInsert> eq = ch_eq();
5037
5038         if (!eq) {
5039                 return boost::shared_ptr<AutomationControl>();
5040         }
5041
5042         uint32_t port_number;
5043 #ifdef MIXBUS32C
5044         switch (band) {
5045                 case 0: port_number = 13; break; // lo
5046                 case 1: port_number = 11; break; // lo mid
5047                 case 2: port_number = 9; break; // hi mid
5048                 case 3: port_number = 7; break; // hi
5049                 default:
5050                         return boost::shared_ptr<AutomationControl>();
5051         }
5052 #else
5053         switch (band) {
5054                 case 0: port_number = 7; break;
5055                 case 1: port_number = 5; break;
5056                 case 2: port_number = 3; break;
5057                 default:
5058                         return boost::shared_ptr<AutomationControl>();
5059         }
5060 #endif
5061
5062         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5063 #else
5064         return boost::shared_ptr<AutomationControl>();
5065 #endif
5066 }
5067
5068 boost::shared_ptr<AutomationControl>
5069 Route::eq_q_controllable (uint32_t band) const
5070 {
5071         return boost::shared_ptr<AutomationControl>();
5072 }
5073
5074 boost::shared_ptr<AutomationControl>
5075 Route::eq_shape_controllable (uint32_t band) const
5076 {
5077 #ifdef MIXBUS32C
5078         boost::shared_ptr<PluginInsert> eq = ch_eq();
5079         if (is_master() || mixbus() || !eq) {
5080                 return boost::shared_ptr<AutomationControl>();
5081         }
5082         switch (band) {
5083                 case 0:
5084                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4))); // lo bell
5085                         break;
5086                 case 3:
5087                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3))); // hi bell
5088                         break;
5089                 default:
5090                         break;
5091         }
5092 #endif
5093         return boost::shared_ptr<AutomationControl>();
5094 }
5095
5096 boost::shared_ptr<AutomationControl>
5097 Route::eq_enable_controllable () const
5098 {
5099 #ifdef MIXBUS
5100         boost::shared_ptr<PluginInsert> eq = ch_eq();
5101
5102         if (!eq) {
5103                 return boost::shared_ptr<AutomationControl>();
5104         }
5105
5106         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5107 #else
5108         return boost::shared_ptr<AutomationControl>();
5109 #endif
5110 }
5111
5112 boost::shared_ptr<AutomationControl>
5113 Route::filter_freq_controllable (bool hpf) const
5114 {
5115 #ifdef MIXBUS
5116         boost::shared_ptr<PluginInsert> eq = ch_eq();
5117
5118         if (is_master() || mixbus() || !eq) {
5119                 return boost::shared_ptr<AutomationControl>();
5120         }
5121         if (hpf) {
5122 #ifdef MIXBUS32C
5123                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5))); // HPF freq
5124 #else
5125                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5126 #endif
5127         } else {
5128 #ifdef MIXBUS32C
5129                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6))); // LPF freq
5130 #else
5131                 return boost::shared_ptr<AutomationControl>();
5132 #endif
5133         }
5134
5135 #else
5136         return boost::shared_ptr<AutomationControl>();
5137 #endif
5138 }
5139
5140 boost::shared_ptr<AutomationControl>
5141 Route::filter_slope_controllable (bool) const
5142 {
5143         return boost::shared_ptr<AutomationControl>();
5144 }
5145
5146 boost::shared_ptr<AutomationControl>
5147 Route::filter_enable_controllable (bool) const
5148 {
5149 #ifdef MIXBUS32C
5150         boost::shared_ptr<PluginInsert> eq = ch_eq();
5151
5152         if (is_master() || mixbus() || !eq) {
5153                 return boost::shared_ptr<AutomationControl>();
5154         }
5155
5156         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5157 #else
5158         return boost::shared_ptr<AutomationControl>();
5159 #endif
5160 }
5161
5162 string
5163 Route::eq_band_name (uint32_t band) const
5164 {
5165 #ifdef MIXBUS32C
5166         if (is_master() || mixbus()) {
5167 #endif
5168         if (Profile->get_mixbus()) {
5169                 switch (band) {
5170                         case 0: return _("lo");
5171                         case 1: return _("mid");
5172                         case 2: return _("hi");
5173                         default: return string();
5174                 }
5175         } else {
5176                 return string ();
5177         }
5178 #ifdef MIXBUS32C
5179         } else {
5180                 switch (band) {
5181                         case 0: return _("lo");
5182                         case 1: return _("lo mid");
5183                         case 2: return _("hi mid");
5184                         case 3: return _("hi");
5185                         default: return string();
5186                 }
5187         }
5188 #endif
5189 }
5190
5191 boost::shared_ptr<AutomationControl>
5192 Route::comp_enable_controllable () const
5193 {
5194 #ifdef MIXBUS
5195         boost::shared_ptr<PluginInsert> comp = ch_comp();
5196
5197         if (!comp) {
5198                 return boost::shared_ptr<AutomationControl>();
5199         }
5200
5201         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5202 #else
5203         return boost::shared_ptr<AutomationControl>();
5204 #endif
5205 }
5206 boost::shared_ptr<AutomationControl>
5207 Route::comp_threshold_controllable () const
5208 {
5209 #ifdef MIXBUS
5210         boost::shared_ptr<PluginInsert> comp = ch_comp();
5211
5212         if (!comp) {
5213                 return boost::shared_ptr<AutomationControl>();
5214         }
5215
5216         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5217
5218 #else
5219         return boost::shared_ptr<AutomationControl>();
5220 #endif
5221 }
5222 boost::shared_ptr<AutomationControl>
5223 Route::comp_speed_controllable () const
5224 {
5225 #ifdef MIXBUS
5226         boost::shared_ptr<PluginInsert> comp = ch_comp();
5227
5228         if (!comp) {
5229                 return boost::shared_ptr<AutomationControl>();
5230         }
5231
5232         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5233 #else
5234         return boost::shared_ptr<AutomationControl>();
5235 #endif
5236 }
5237 boost::shared_ptr<AutomationControl>
5238 Route::comp_mode_controllable () const
5239 {
5240 #ifdef MIXBUS
5241         boost::shared_ptr<PluginInsert> comp = ch_comp();
5242
5243         if (!comp) {
5244                 return boost::shared_ptr<AutomationControl>();
5245         }
5246
5247         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5248 #else
5249         return boost::shared_ptr<AutomationControl>();
5250 #endif
5251 }
5252 boost::shared_ptr<AutomationControl>
5253 Route::comp_makeup_controllable () const
5254 {
5255 #ifdef MIXBUS
5256         boost::shared_ptr<PluginInsert> comp = ch_comp();
5257
5258         if (!comp) {
5259                 return boost::shared_ptr<AutomationControl>();
5260         }
5261
5262         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5263 #else
5264         return boost::shared_ptr<AutomationControl>();
5265 #endif
5266 }
5267 boost::shared_ptr<ReadOnlyControl>
5268 Route::comp_redux_controllable () const
5269 {
5270 #ifdef MIXBUS
5271         boost::shared_ptr<PluginInsert> comp = ch_comp();
5272
5273         if (!comp) {
5274                 return boost::shared_ptr<ReadOnlyControl>();
5275         }
5276         if (is_master()) {
5277                 return comp->control_output (2);
5278         } else {
5279                 return comp->control_output (6);
5280         }
5281
5282 #else
5283         return boost::shared_ptr<ReadOnlyControl>();
5284 #endif
5285 }
5286
5287 string
5288 Route::comp_mode_name (uint32_t mode) const
5289 {
5290 #ifdef MIXBUS
5291         switch (mode) {
5292         case 0:
5293                 return _("Leveler");
5294         case 1:
5295                 return _("Compressor");
5296         case 2:
5297                 return _("Limiter");
5298         case 3:
5299                 return mixbus() ? _("Sidechain") : _("Limiter");
5300         }
5301
5302         return _("???");
5303 #else
5304         return _("???");
5305 #endif
5306 }
5307
5308 string
5309 Route::comp_speed_name (uint32_t mode) const
5310 {
5311 #ifdef MIXBUS
5312         switch (mode) {
5313         case 0:
5314                 return _("Attk");
5315         case 1:
5316                 return _("Ratio");
5317         case 2:
5318         case 3:
5319                 return _("Rels");
5320         }
5321         return _("???");
5322 #else
5323         return _("???");
5324 #endif
5325 }
5326
5327 boost::shared_ptr<AutomationControl>
5328 Route::send_level_controllable (uint32_t n) const
5329 {
5330 #ifdef  MIXBUS
5331 # undef MIXBUS_PORTS_H
5332 # include "../../gtk2_ardour/mixbus_ports.h"
5333         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5334         if (plug) {
5335                 uint32_t port_id = 0;
5336                 switch (n) {
5337                         case  0: port_id = port_channel_post_aux1_level; break;
5338                         case  1: port_id = port_channel_post_aux2_level; break;
5339                         case  2: port_id = port_channel_post_aux3_level; break;
5340                         case  3: port_id = port_channel_post_aux4_level; break;
5341                         case  4: port_id = port_channel_post_aux5_level; break;
5342                         case  5: port_id = port_channel_post_aux6_level; break;
5343                         case  6: port_id = port_channel_post_aux7_level; break;
5344                         case  7: port_id = port_channel_post_aux8_level; break;
5345 # ifdef MIXBUS32C
5346                         case  8: port_id = port_channel_post_aux9_level; break;
5347                         case  9: port_id = port_channel_post_aux10_level; break;
5348                         case 10: port_id = port_channel_post_aux11_level; break;
5349                         case 11: port_id = port_channel_post_aux12_level; break;
5350 # endif
5351                         default:
5352                                 break;
5353                 }
5354
5355                 if (port_id > 0) {
5356                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5357                 }
5358 # ifdef MIXBUS32C
5359                 assert (n > 11);
5360                 n -= 12;
5361 # else
5362                 assert (n > 7);
5363                 n -= 8;
5364 # endif
5365         }
5366 #endif
5367         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5368         if (!s) {
5369                 return boost::shared_ptr<AutomationControl>();
5370         }
5371         return s->gain_control ();
5372 }
5373
5374 boost::shared_ptr<AutomationControl>
5375 Route::send_enable_controllable (uint32_t n) const
5376 {
5377 #ifdef  MIXBUS
5378 # undef MIXBUS_PORTS_H
5379 # include "../../gtk2_ardour/mixbus_ports.h"
5380         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5381         if (plug) {
5382                 uint32_t port_id = 0;
5383                 switch (n) {
5384                         case  0: port_id = port_channel_post_aux1_asgn; break;
5385                         case  1: port_id = port_channel_post_aux2_asgn; break;
5386                         case  2: port_id = port_channel_post_aux3_asgn; break;
5387                         case  3: port_id = port_channel_post_aux4_asgn; break;
5388                         case  4: port_id = port_channel_post_aux5_asgn; break;
5389                         case  5: port_id = port_channel_post_aux6_asgn; break;
5390                         case  6: port_id = port_channel_post_aux7_asgn; break;
5391                         case  7: port_id = port_channel_post_aux8_asgn; break;
5392 # ifdef MIXBUS32C
5393                         case  8: port_id = port_channel_post_aux9_asgn; break;
5394                         case  9: port_id = port_channel_post_aux10_asgn; break;
5395                         case 10: port_id = port_channel_post_aux11_asgn; break;
5396                         case 11: port_id = port_channel_post_aux12_asgn; break;
5397 # endif
5398                         default:
5399                                 break;
5400                 }
5401
5402                 if (port_id > 0) {
5403                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5404                 }
5405 # ifdef MIXBUS32C
5406                 assert (n > 11);
5407                 n -= 12;
5408 # else
5409                 assert (n > 7);
5410                 n -= 8;
5411 # endif
5412         }
5413 #endif
5414         /* although Ardour sends have enable/disable as part of the Processor
5415          * API, it is not exposed as a controllable.
5416          *
5417          * XXX: we should fix this (make it click-free, automatable enable-control)
5418          */
5419         return boost::shared_ptr<AutomationControl>();
5420 }
5421
5422 string
5423 Route::send_name (uint32_t n) const
5424 {
5425 #ifdef MIXBUS
5426 # ifdef MIXBUS32C
5427         if (n < 12) {
5428                 return _session.get_mixbus (n)->name();
5429         }
5430         n -= 12;
5431 #else
5432         if (n < 8) {
5433                 return _session.get_mixbus (n)->name();
5434         }
5435         n -= 8;
5436 # endif
5437 #endif
5438         boost::shared_ptr<Processor> p = nth_send (n);
5439         if (p) {
5440                 return p->name();
5441         } else {
5442                 return string();
5443         }
5444 }
5445
5446 boost::shared_ptr<AutomationControl>
5447 Route::master_send_enable_controllable () const
5448 {
5449 #ifdef  MIXBUS
5450         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5451         if (!plug) {
5452                 return boost::shared_ptr<AutomationControl>();
5453         }
5454 # undef MIXBUS_PORTS_H
5455 # include "../../gtk2_ardour/mixbus_ports.h"
5456         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5457 #else
5458         return boost::shared_ptr<AutomationControl>();
5459 #endif
5460 }
5461
5462 bool
5463 Route::slaved () const
5464 {
5465         if (!_gain_control) {
5466                 return false;
5467         }
5468         /* just test one particular control, not all of them */
5469         return _gain_control->slaved ();
5470 }
5471
5472 bool
5473 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5474 {
5475         if (!vca || !_gain_control) {
5476                 return false;
5477         }
5478
5479         /* just test one particular control, not all of them */
5480
5481         return _gain_control->slaved_to (vca->gain_control());
5482 }
5483
5484 bool
5485 Route::muted_by_others_soloing () const
5486 {
5487         if (!can_be_muted_by_others ()) {
5488                 return false;
5489         }
5490
5491         return  _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5492 }
5493
5494 void
5495 Route::clear_all_solo_state ()
5496 {
5497         _solo_control->clear_all_solo_state ();
5498 }
5499
5500 boost::shared_ptr<AutomationControl>
5501 Route::automation_control_recurse (PBD::ID const & id) const
5502 {
5503         boost::shared_ptr<AutomationControl> ac = Automatable::automation_control (id);
5504
5505         if (ac) {
5506                 return ac;
5507         }
5508
5509         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5510
5511         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5512                 if ((ac = (*i)->automation_control (id))) {
5513                         return ac;
5514                 }
5515         }
5516
5517         return boost::shared_ptr<AutomationControl> ();
5518 }