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         ProcessorList old_list = _processors;
1240         {
1241                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1242                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1243                 ProcessorList new_list;
1244                 ProcessorStreams err;
1245                 bool seen_amp = false;
1246
1247                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1248
1249                         if (*i == _amp) {
1250                                 seen_amp = true;
1251                         }
1252
1253                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1254
1255                                 /* you can't remove these */
1256
1257                                 new_list.push_back (*i);
1258
1259                         } else {
1260                                 if (seen_amp) {
1261
1262                                         switch (p) {
1263                                         case PreFader:
1264                                                 new_list.push_back (*i);
1265                                                 break;
1266                                         case PostFader:
1267                                                 (*i)->drop_references ();
1268                                                 break;
1269                                         }
1270
1271                                 } else {
1272
1273                                         switch (p) {
1274                                         case PreFader:
1275                                                 (*i)->drop_references ();
1276                                                 break;
1277                                         case PostFader:
1278                                                 new_list.push_back (*i);
1279                                                 break;
1280                                         }
1281                                 }
1282                         }
1283                 }
1284
1285                 _processors = new_list;
1286                 configure_processors_unlocked (&err, &lm); // this can't fail
1287         }
1288         /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
1289         old_list.clear ();
1290
1291         processor_max_streams.reset();
1292         _have_internal_generator = false;
1293         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1294         set_processor_positions ();
1295
1296         reset_instrument_info ();
1297
1298         if (!already_deleting) {
1299                 _session.clear_deletion_in_progress();
1300         }
1301 }
1302
1303 int
1304 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1305 {
1306         // TODO once the export point can be configured properly, do something smarter here
1307         if (processor == _capturing_processor) {
1308                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1309                 if (need_process_lock) {
1310                         lx.acquire();
1311                 }
1312
1313                 _capturing_processor.reset();
1314
1315                 if (need_process_lock) {
1316                         lx.release();
1317                 }
1318         }
1319
1320         /* these can never be removed */
1321
1322         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1323                 return 0;
1324         }
1325
1326         if (!_session.engine().connected()) {
1327                 return 1;
1328         }
1329
1330         processor_max_streams.reset();
1331
1332         {
1333                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1334                 if (need_process_lock) {
1335                         lx.acquire();
1336                 }
1337
1338                 /* Caller must hold process lock */
1339                 assert (!AudioEngine::instance()->process_lock().trylock());
1340
1341                 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1342
1343                 ProcessorState pstate (this);
1344
1345                 ProcessorList::iterator i;
1346                 bool removed = false;
1347
1348                 for (i = _processors.begin(); i != _processors.end(); ) {
1349                         if (*i == processor) {
1350
1351                                 /* move along, see failure case for configure_processors()
1352                                    where we may need to reconfigure the processor.
1353                                 */
1354
1355                                 /* stop redirects that send signals to JACK ports
1356                                    from causing noise as a result of no longer being
1357                                    run.
1358                                 */
1359
1360                                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1361                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
1362
1363                                 if (pi != 0) {
1364                                         assert (iop == 0);
1365                                         iop = pi->sidechain();
1366                                 }
1367
1368                                 if (iop != 0) {
1369                                         iop->disconnect ();
1370                                 }
1371
1372                                 i = _processors.erase (i);
1373                                 removed = true;
1374                                 break;
1375
1376                         } else {
1377                                 ++i;
1378                         }
1379
1380                         _output->set_user_latency (0);
1381                 }
1382
1383                 if (!removed) {
1384                         /* what? */
1385                         return 1;
1386                 }
1387
1388                 if (configure_processors_unlocked (err, &lm)) {
1389                         pstate.restore ();
1390                         /* we know this will work, because it worked before :) */
1391                         configure_processors_unlocked (0, &lm);
1392                         return -1;
1393                 }
1394
1395                 _have_internal_generator = false;
1396
1397                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1398                         boost::shared_ptr<PluginInsert> pi;
1399
1400                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1401                                 if (pi->has_no_inputs ()) {
1402                                         _have_internal_generator = true;
1403                                         break;
1404                                 }
1405                         }
1406                 }
1407                 if (need_process_lock) {
1408                         lx.release();
1409                 }
1410         }
1411
1412         reset_instrument_info ();
1413         processor->drop_references ();
1414         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1415         set_processor_positions ();
1416
1417         return 0;
1418 }
1419
1420 int
1421 Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
1422 {
1423         /* these can never be removed */
1424         if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
1425                 return 1;
1426         }
1427         /* and can't be used as substitute, either */
1428         if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
1429                 return 1;
1430         }
1431
1432         /* I/Os are out, too */
1433         if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
1434                 return 1;
1435         }
1436
1437         /* this function cannot be used to swap/reorder processors */
1438         if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
1439                 return 1;
1440         }
1441
1442         if (!AudioEngine::instance()->connected() || !old || !sub) {
1443                 return 1;
1444         }
1445
1446         /* ensure that sub is not owned by another route */
1447         if (sub->owner ()) {
1448                 return 1;
1449         }
1450
1451         {
1452                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1453                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1454                 ProcessorState pstate (this);
1455
1456                 assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
1457
1458                 ProcessorList::iterator i;
1459                 bool replaced = false;
1460                 bool enable = old->enabled ();
1461
1462                 for (i = _processors.begin(); i != _processors.end(); ) {
1463                         if (*i == old) {
1464                                 i = _processors.erase (i);
1465                                 _processors.insert (i, sub);
1466                                 sub->set_owner (this);
1467                                 replaced = true;
1468                                 break;
1469                         } else {
1470                                 ++i;
1471                         }
1472                 }
1473
1474                 if (!replaced) {
1475                         return 1;
1476                 }
1477
1478                 if (_strict_io) {
1479                         boost::shared_ptr<PluginInsert> pi;
1480                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
1481                                 pi->set_strict_io (true);
1482                         }
1483                 }
1484
1485                 if (configure_processors_unlocked (err, &lm)) {
1486                         pstate.restore ();
1487                         configure_processors_unlocked (0, &lm);
1488                         return -1;
1489                 }
1490
1491                 _have_internal_generator = false;
1492
1493                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1494                         boost::shared_ptr<PluginInsert> pi;
1495                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1496                                 if (pi->has_no_inputs ()) {
1497                                         _have_internal_generator = true;
1498                                         break;
1499                                 }
1500                         }
1501                 }
1502
1503                 if (enable) {
1504                         sub->enable (true);
1505                 }
1506
1507                 sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1508                 _output->set_user_latency (0);
1509         }
1510
1511         reset_instrument_info ();
1512         old->drop_references ();
1513         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1514         set_processor_positions ();
1515         return 0;
1516 }
1517
1518 int
1519 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1520 {
1521         ProcessorList deleted;
1522
1523         if (!_session.engine().connected()) {
1524                 return 1;
1525         }
1526
1527         processor_max_streams.reset();
1528
1529         {
1530                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1531                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1532                 ProcessorState pstate (this);
1533
1534                 ProcessorList::iterator i;
1535                 boost::shared_ptr<Processor> processor;
1536
1537                 for (i = _processors.begin(); i != _processors.end(); ) {
1538
1539                         processor = *i;
1540
1541                         /* these can never be removed */
1542
1543                         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1544                                 ++i;
1545                                 continue;
1546                         }
1547
1548                         /* see if its in the list of processors to delete */
1549
1550                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1551                                 ++i;
1552                                 continue;
1553                         }
1554
1555                         /* stop IOProcessors that send to JACK ports
1556                            from causing noise as a result of no longer being
1557                            run.
1558                         */
1559
1560                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(processor);
1561                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
1562                         if (pi != 0) {
1563                                 assert (iop == 0);
1564                                 iop = pi->sidechain();
1565                         }
1566
1567                         if (iop != 0) {
1568                                 iop->disconnect ();
1569                         }
1570
1571                         deleted.push_back (processor);
1572                         i = _processors.erase (i);
1573                 }
1574
1575                 if (deleted.empty()) {
1576                         /* none of those in the requested list were found */
1577                         return 0;
1578                 }
1579
1580                 _output->set_user_latency (0);
1581
1582                 if (configure_processors_unlocked (err, &lm)) {
1583                         pstate.restore ();
1584                         /* we know this will work, because it worked before :) */
1585                         configure_processors_unlocked (0, &lm);
1586                         return -1;
1587                 }
1588                 //lx.unlock();
1589
1590                 _have_internal_generator = false;
1591
1592                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1593                         boost::shared_ptr<PluginInsert> pi;
1594
1595                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1596                                 if (pi->has_no_inputs ()) {
1597                                         _have_internal_generator = true;
1598                                         break;
1599                                 }
1600                         }
1601                 }
1602         }
1603
1604         /* now try to do what we need to so that those that were removed will be deleted */
1605
1606         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1607                 (*i)->drop_references ();
1608         }
1609
1610         reset_instrument_info ();
1611         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1612         set_processor_positions ();
1613
1614         return 0;
1615 }
1616
1617 void
1618 Route::reset_instrument_info ()
1619 {
1620         boost::shared_ptr<Processor> instr = the_instrument();
1621         if (instr) {
1622                 _instrument_info.set_internal_instrument (instr);
1623         }
1624 }
1625
1626 /** Caller must hold process lock */
1627 int
1628 Route::configure_processors (ProcessorStreams* err)
1629 {
1630 #ifndef PLATFORM_WINDOWS
1631         assert (!AudioEngine::instance()->process_lock().trylock());
1632 #endif
1633
1634         if (!_in_configure_processors) {
1635                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1636                 return configure_processors_unlocked (err, &lm);
1637         }
1638
1639         return 0;
1640 }
1641
1642 ChanCount
1643 Route::input_streams () const
1644 {
1645         return _input->n_ports ();
1646 }
1647
1648 list<pair<ChanCount, ChanCount> >
1649 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1650 {
1651         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1652
1653         return try_configure_processors_unlocked (in, err);
1654 }
1655
1656 list<pair<ChanCount, ChanCount> >
1657 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1658 {
1659         // Check each processor in order to see if we can configure as requested
1660         ChanCount out;
1661         list<pair<ChanCount, ChanCount> > configuration;
1662         uint32_t index = 0;
1663
1664         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1665         DEBUG_TRACE (DEBUG::Processors, "{\n");
1666
1667         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1668
1669                 if ((*p)->can_support_io_configuration(in, out)) {
1670
1671                         if (boost::dynamic_pointer_cast<Delivery> (*p)
1672                                         && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main
1673                                         && !is_auditioner()
1674                                         && (is_monitor() || _strict_io || Profile->get_mixbus ())) {
1675                                 /* with strict I/O the panner + output are forced to
1676                                  * follow the last processor's output.
1677                                  *
1678                                  * Delivery::can_support_io_configuration() will only add ports,
1679                                  * but not remove excess ports.
1680                                  *
1681                                  * This works because the delivery only requires
1682                                  * as many outputs as there are inputs.
1683                                  * Delivery::configure_io() will do the actual removal
1684                                  * by calling _output->ensure_io()
1685                                  */
1686                                 if (!is_master() && _session.master_out () && in.n_audio() > 0) {
1687                                         /* ..but at least as many as there are master-inputs, if
1688                                          * the delivery is dealing with audio */
1689                                         // XXX this may need special-casing for mixbus (master-outputs)
1690                                         // and should maybe be a preference anyway ?!
1691                                         out = ChanCount::max (in, _session.master_out ()->n_inputs ());
1692                                 } else {
1693                                         out = in;
1694                                 }
1695                         }
1696
1697                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1698                         configuration.push_back(make_pair(in, out));
1699
1700                         if (is_monitor()) {
1701                                 // restriction for Monitor Section Processors
1702                                 if (in.n_audio() != out.n_audio() || out.n_midi() > 0) {
1703                                         /* Note: The Monitor follows the master-bus and has no panner.
1704                                          *
1705                                          * The general idea is to only allow plugins that retain the channel-count
1706                                          * and plugins with MIDI in (e.g VSTs with control that will remain unconnected).
1707                                          * Then again 5.1 in, monitor stereo is a valid use-case.
1708                                          *
1709                                          * and worse: we only refuse adding plugins *here*.
1710                                          *
1711                                          * 1) stereo-master, stereo-mon, add a stereo-plugin, OK
1712                                          * 2) change master-bus, add a channel
1713                                          * 2a) monitor-secion follows
1714                                          * 3) monitor processors fail to re-reconfigure (stereo plugin)
1715                                          * 4) re-load session, monitor-processor remains unconfigured, crash.
1716                                          */
1717                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: Channel configuration change.\n");
1718                                 }
1719                                 if (boost::dynamic_pointer_cast<InternalSend> (*p)) {
1720                                         // internal sends make no sense, only feedback
1721                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1722                                         return list<pair<ChanCount, ChanCount> > ();
1723                                 }
1724                                 if (boost::dynamic_pointer_cast<PortInsert> (*p)) {
1725                                         /* External Sends can be problematic. one can add/remove ports
1726                                          * there signal leaves the DAW to external monitors anyway, so there's
1727                                          * no real use for allowing them here anyway.
1728                                          */
1729                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No External Sends allowed.\n");
1730                                         return list<pair<ChanCount, ChanCount> > ();
1731                                 }
1732                                 if (boost::dynamic_pointer_cast<Send> (*p)) {
1733                                         // ditto
1734                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1735                                         return list<pair<ChanCount, ChanCount> > ();
1736                                 }
1737                         }
1738                         in = out;
1739                 } else {
1740                         if (err) {
1741                                 err->index = index;
1742                                 err->count = in;
1743                         }
1744                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1745                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1746                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1747                         return list<pair<ChanCount, ChanCount> > ();
1748                 }
1749         }
1750
1751         DEBUG_TRACE (DEBUG::Processors, "}\n");
1752
1753         return configuration;
1754 }
1755
1756 /** Set the input/output configuration of each processor in the processors list.
1757  *  Caller must hold process lock.
1758  *  Return 0 on success, otherwise configuration is impossible.
1759  */
1760 int
1761 Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLock::WriterLock* lm)
1762 {
1763 #ifndef PLATFORM_WINDOWS
1764         assert (!AudioEngine::instance()->process_lock().trylock());
1765 #endif
1766
1767         if (_in_configure_processors) {
1768                 return 0;
1769         }
1770
1771         /* put invisible processors where they should be */
1772         setup_invisible_processors ();
1773
1774         _in_configure_processors = true;
1775
1776         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1777
1778         if (configuration.empty ()) {
1779                 _in_configure_processors = false;
1780                 return -1;
1781         }
1782
1783         ChanCount out;
1784         bool seen_mains_out = false;
1785         processor_out_streams = _input->n_ports();
1786         processor_max_streams.reset();
1787
1788         /* processor configure_io() may result in adding ports
1789          * e.g. Delivery::configure_io -> ARDOUR::IO::ensure_io ()
1790          *
1791          * with jack2 adding ports results in a graph-order callback,
1792          * which calls Session::resort_routes() and eventually
1793          * Route::direct_feeds_according_to_reality()
1794          * which takes a ReaderLock (_processor_lock).
1795          *
1796          * so we can't hold a WriterLock here until jack2 threading
1797          * is fixed.
1798          *
1799          * NB. we still hold the process lock
1800          *
1801          * (ardour's own engines do call graph-order from the
1802          * process-thread and hence do not have this issue; besides
1803          * merely adding ports won't trigger a graph-order, only
1804          * making connections does)
1805          */
1806         lm->release ();
1807
1808         // TODO check for a potential ReaderLock after ReaderLock ??
1809         Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
1810
1811         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1812         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1813
1814                 if (!(*p)->configure_io(c->first, c->second)) {
1815                         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
1816                         _in_configure_processors = false;
1817                         lr.release ();
1818                         lm->acquire ();
1819                         return -1;
1820                 }
1821                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1822                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1823
1824                 boost::shared_ptr<IOProcessor> iop;
1825                 boost::shared_ptr<PluginInsert> pi;
1826                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1827                         /* plugins connected via Split or Hide Match may have more channels.
1828                          * route/scratch buffers are needed for all of them
1829                          * The configuration may only be a subset (both input and output)
1830                          */
1831                         processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
1832                 }
1833                 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
1834                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
1835                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
1836                 }
1837                 out = c->second;
1838
1839                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1840                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1841                         /* main delivery will increase port count to match input.
1842                          * the Delivery::Main is usually the last processor - followed only by
1843                          * 'MeterOutput'.
1844                          */
1845                         seen_mains_out = true;
1846                 }
1847                 if (!seen_mains_out) {
1848                         processor_out_streams = out;
1849                 }
1850         }
1851
1852         lr.release ();
1853         lm->acquire ();
1854
1855
1856         if (_meter) {
1857                 _meter->set_max_channels (processor_max_streams);
1858         }
1859
1860         /* make sure we have sufficient scratch buffers to cope with the new processor
1861            configuration
1862         */
1863         _session.ensure_buffers (n_process_buffers ());
1864
1865         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1866
1867         _in_configure_processors = false;
1868         return 0;
1869 }
1870
1871 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1872  *  @param state New active state for those processors.
1873  */
1874 void
1875 Route::all_visible_processors_active (bool state)
1876 {
1877         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1878
1879         if (_processors.empty()) {
1880                 return;
1881         }
1882
1883         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1884                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1885                         continue;
1886                 }
1887 #ifdef MIXBUS
1888                 boost::shared_ptr<PluginInsert> pi;
1889                 if (0 != (pi = boost::dynamic_pointer_cast<PluginInsert>(*i))) {
1890                         if (pi->is_channelstrip ()) {
1891                                 continue;
1892                         }
1893                 }
1894 #endif
1895                 (*i)->enable (state);
1896         }
1897
1898         _session.set_dirty ();
1899 }
1900
1901 bool
1902 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
1903 {
1904         /* check if re-order requires re-configuration of any processors
1905          * -> compare channel configuration for all processors
1906          */
1907         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1908         ChanCount c = input_streams ();
1909
1910         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
1911                 bool found = false;
1912                 if (c != (*j)->input_streams()) {
1913                         return true;
1914                 }
1915                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1916                         if (*i == *j) {
1917                                 found = true;
1918                                 if ((*i)->input_streams() != c) {
1919                                         return true;
1920                                 }
1921                                 c = (*i)->output_streams();
1922                                 break;
1923                         }
1924                 }
1925                 if (!found) {
1926                         return true;
1927                 }
1928         }
1929         return false;
1930 }
1931
1932 #ifdef __clang__
1933 __attribute__((annotate("realtime")))
1934 #endif
1935 void
1936 Route::apply_processor_order (const ProcessorList& new_order)
1937 {
1938         /* need to hold processor_lock; either read or write lock
1939          * and the engine process_lock.
1940          * Due to r/w lock ambiguity we can only assert the latter
1941          */
1942         assert (!AudioEngine::instance()->process_lock().trylock());
1943
1944
1945         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1946          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1947          * processors in the current actual processor list that are hidden. Any visible processors
1948          *  in the current list but not in "new_order" will be assumed to be deleted.
1949          */
1950
1951         /* "as_it_will_be" and "_processors" are lists of shared pointers.
1952          * actual memory usage is small, but insert/erase is not actually rt-safe :(
1953          * (note though that  ::processors_reorder_needs_configure() ensured that
1954          * this function will only ever be called from the rt-thread if no processor were removed)
1955          *
1956          * either way, I can't proove it, but an x-run due to re-order here is less likley
1957          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
1958          */
1959
1960         ProcessorList as_it_will_be;
1961         ProcessorList::iterator oiter;
1962         ProcessorList::const_iterator niter;
1963
1964         oiter = _processors.begin();
1965         niter = new_order.begin();
1966
1967         while (niter !=  new_order.end()) {
1968
1969                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1970                    then append it to the temp list.
1971
1972                    Otherwise, see if the next processor in the old list is in the new list. if not,
1973                    its been deleted. If its there, append it to the temp list.
1974                    */
1975
1976                 if (oiter == _processors.end()) {
1977
1978                         /* no more elements in the old list, so just stick the rest of
1979                            the new order onto the temp list.
1980                            */
1981
1982                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1983                         while (niter != new_order.end()) {
1984                                 ++niter;
1985                         }
1986                         break;
1987
1988                 } else {
1989
1990                         if (!(*oiter)->display_to_user()) {
1991
1992                                 as_it_will_be.push_back (*oiter);
1993
1994                         } else {
1995
1996                                 /* visible processor: check that its in the new order */
1997
1998                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1999                                         /* deleted: do nothing, shared_ptr<> will clean up */
2000                                 } else {
2001                                         /* ignore this one, and add the next item from the new order instead */
2002                                         as_it_will_be.push_back (*niter);
2003                                         ++niter;
2004                                 }
2005                         }
2006
2007                         /* now remove from old order - its taken care of no matter what */
2008                         oiter = _processors.erase (oiter);
2009                 }
2010
2011         }
2012         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2013
2014         /* If the meter is in a custom position, find it and make a rough note of its position */
2015         maybe_note_meter_position ();
2016 }
2017
2018 void
2019 Route::move_instrument_down (bool postfader)
2020 {
2021         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2022         ProcessorList new_order;
2023         boost::shared_ptr<Processor> instrument;
2024         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2025                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
2026                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
2027                         instrument = *i;
2028                 } else if (instrument && *i == _amp) {
2029                         if (postfader) {
2030                                 new_order.push_back (*i);
2031                                 new_order.push_back (instrument);
2032                         } else {
2033                                 new_order.push_back (instrument);
2034                                 new_order.push_back (*i);
2035                         }
2036                 } else {
2037                         new_order.push_back (*i);
2038                 }
2039         }
2040         if (!instrument) {
2041                 return;
2042         }
2043         lm.release ();
2044         reorder_processors (new_order, 0);
2045 }
2046
2047 int
2048 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2049 {
2050         // it a change is already queued, wait for it
2051         // (unless engine is stopped. apply immediately and proceed
2052         while (g_atomic_int_get (&_pending_process_reorder)) {
2053                 if (!AudioEngine::instance()->running()) {
2054                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2055                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2056
2057                         apply_processor_order(_pending_processor_order);
2058                         setup_invisible_processors ();
2059
2060                         g_atomic_int_set (&_pending_process_reorder, 0);
2061
2062                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2063                         set_processor_positions ();
2064                 } else {
2065                         // TODO rather use a semaphore or something.
2066                         // but since ::reorder_processors() is called
2067                         // from the GUI thread, this is fine..
2068                         Glib::usleep(500);
2069                 }
2070         }
2071
2072         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2073
2074                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2075                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2076                 ProcessorState pstate (this);
2077
2078                 apply_processor_order (new_order);
2079
2080                 if (configure_processors_unlocked (err, &lm)) {
2081                         pstate.restore ();
2082                         return -1;
2083                 }
2084
2085                 lm.release();
2086                 lx.release();
2087
2088                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2089                 set_processor_positions ();
2090
2091         } else {
2092                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2093                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2094
2095                 // _pending_processor_order is protected by _processor_lock
2096                 _pending_processor_order = new_order;
2097                 g_atomic_int_set (&_pending_process_reorder, 1);
2098         }
2099
2100         return 0;
2101 }
2102
2103 bool
2104 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2105 {
2106         boost::shared_ptr<PluginInsert> pi;
2107         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2108                 return false;
2109         }
2110
2111         if (pi->has_sidechain () == add) {
2112                 return true; // ?? call failed, but result is as expected.
2113         }
2114
2115         {
2116                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2117                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2118                 if (i == _processors.end ()) {
2119                         return false;
2120                 }
2121         }
2122
2123         {
2124                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2125                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2126                 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2127
2128                 lx.release (); // IO::add_port() and ~IO takes process lock  - XXX check if this is safe
2129                 if (add) {
2130                         if (!pi->add_sidechain ()) {
2131                                 return false;
2132                         }
2133                 } else {
2134                         if (!pi->del_sidechain ()) {
2135                                 return false;
2136                         }
2137                 }
2138
2139                 lx.acquire ();
2140                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2141                 lx.release ();
2142
2143                 if (c.empty()) {
2144                         if (add) {
2145                                 pi->del_sidechain ();
2146                         } else {
2147                                 pi->add_sidechain ();
2148                                 // TODO restore side-chain's state.
2149                         }
2150                         return false;
2151                 }
2152                 lx.acquire ();
2153                 configure_processors_unlocked (0, &lm);
2154         }
2155
2156         if (pi->has_sidechain ()) {
2157                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2158         }
2159
2160         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2161         _session.set_dirty ();
2162         return true;
2163 }
2164
2165 bool
2166 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2167 {
2168         boost::shared_ptr<PluginInsert> pi;
2169         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2170                 return false;
2171         }
2172
2173         {
2174                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2175                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2176                 if (i == _processors.end ()) {
2177                         return false;
2178                 }
2179         }
2180
2181         {
2182                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2183                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2184
2185                 const ChanCount& old (pi->preset_out ());
2186                 if (!pi->set_preset_out (outs)) {
2187                         return true; // no change, OK
2188                 }
2189
2190                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2191                 if (c.empty()) {
2192                         /* not possible */
2193                         pi->set_preset_out (old);
2194                         return false;
2195                 }
2196                 configure_processors_unlocked (0, &lm);
2197         }
2198
2199         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2200         _session.set_dirty ();
2201         return true;
2202 }
2203
2204 bool
2205 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2206 {
2207         ChanCount unused;
2208         return customize_plugin_insert (proc, 0, unused, unused);
2209 }
2210
2211 bool
2212 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
2213 {
2214         boost::shared_ptr<PluginInsert> pi;
2215         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2216                 return false;
2217         }
2218
2219         {
2220                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2221                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2222                 if (i == _processors.end ()) {
2223                         return false;
2224                 }
2225         }
2226
2227         {
2228                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2229                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2230
2231                 bool      old_cust  = pi->custom_cfg ();
2232                 uint32_t  old_cnt   = pi->get_count ();
2233                 ChanCount old_chan  = pi->output_streams ();
2234                 ChanCount old_sinks = pi->natural_input_streams ();
2235
2236                 if (count == 0) {
2237                         pi->set_custom_cfg (false);
2238                 } else {
2239                         pi->set_custom_cfg (true);
2240                         pi->set_count (count);
2241                         pi->set_outputs (outs);
2242                         pi->set_sinks (sinks);
2243                 }
2244
2245                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2246                 if (c.empty()) {
2247                         /* not possible */
2248
2249                         pi->set_count (old_cnt);
2250                         pi->set_sinks (old_sinks);
2251                         pi->set_outputs (old_chan);
2252                         pi->set_custom_cfg (old_cust);
2253
2254                         return false;
2255                 }
2256                 configure_processors_unlocked (0, &lm);
2257         }
2258
2259         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2260         _session.set_dirty ();
2261         return true;
2262 }
2263
2264 bool
2265 Route::set_strict_io (const bool enable)
2266 {
2267         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2268
2269         if (_strict_io != enable) {
2270                 _strict_io = enable;
2271                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2272                 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2273                         boost::shared_ptr<PluginInsert> pi;
2274                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2275                                 pi->set_strict_io (_strict_io);
2276                         }
2277                 }
2278
2279                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2280
2281                 if (c.empty()) {
2282                         // not possible
2283                         _strict_io = !enable; // restore old value
2284                         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2285                                 boost::shared_ptr<PluginInsert> pi;
2286                                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2287                                         pi->set_strict_io (_strict_io);
2288                                 }
2289                         }
2290                         return false;
2291                 }
2292                 lm.release ();
2293
2294                 configure_processors (0);
2295                 lx.release ();
2296
2297                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2298                 _session.set_dirty ();
2299         }
2300         return true;
2301 }
2302
2303 XMLNode&
2304 Route::get_state()
2305 {
2306         return state(true);
2307 }
2308
2309 XMLNode&
2310 Route::get_template()
2311 {
2312         return state(false);
2313 }
2314
2315 XMLNode&
2316 Route::state(bool full_state)
2317 {
2318         if (!_session._template_state_dir.empty()) {
2319                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2320         }
2321
2322         XMLNode *node = new XMLNode("Route");
2323         ProcessorList::iterator i;
2324
2325         node->set_property ("id", id ());
2326         node->set_property ("name", name());
2327         node->set_property ("default-type", _default_type);
2328         node->set_property ("strict-io", _strict_io);
2329
2330         node->add_child_nocopy (_presentation_info.get_state());
2331
2332         node->set_property ("active", _active);
2333         node->set_property ("denormal-protection", _denormal_protection);
2334         node->set_property ("meter-point", _meter_point);
2335
2336         node->set_property ("meter-type", _meter_type);
2337
2338         if (_route_group) {
2339                 node->set_property ("route-group", _route_group->name());
2340         }
2341
2342         node->add_child_nocopy (_solo_control->get_state ());
2343         node->add_child_nocopy (_solo_isolate_control->get_state ());
2344         node->add_child_nocopy (_solo_safe_control->get_state ());
2345
2346         node->add_child_nocopy (_input->state (full_state));
2347         node->add_child_nocopy (_output->state (full_state));
2348         node->add_child_nocopy (_mute_master->get_state ());
2349
2350         node->add_child_nocopy (_mute_control->get_state ());
2351         node->add_child_nocopy (_phase_control->get_state ());
2352
2353         if (full_state) {
2354                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2355         }
2356
2357         if (_comment.length()) {
2358                 XMLNode *cmt = node->add_child ("Comment");
2359                 cmt->add_content (_comment);
2360         }
2361
2362         if (_pannable) {
2363                 node->add_child_nocopy (_pannable->state (full_state));
2364         }
2365
2366         {
2367                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2368                 for (i = _processors.begin(); i != _processors.end(); ++i) {
2369                         if (!full_state) {
2370                                 /* template save: do not include internal sends functioning as
2371                                          aux sends because the chance of the target ID
2372                                          in the session where this template is used
2373                                          is not very likely.
2374
2375                                          similarly, do not save listen sends which connect to
2376                                          the monitor section, because these will always be
2377                                          added if necessary.
2378                                          */
2379                                 boost::shared_ptr<InternalSend> is;
2380
2381                                 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2382                                         if (is->role() == Delivery::Listen) {
2383                                                 continue;
2384                                         }
2385                                 }
2386                         }
2387                         node->add_child_nocopy((*i)->state (full_state));
2388                 }
2389         }
2390
2391         if (_extra_xml) {
2392                 node->add_child_copy (*_extra_xml);
2393         }
2394
2395         if (_custom_meter_position_noted) {
2396                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2397                 if (after) {
2398                         node->set_property (X_("processor-after-last-custom-meter"), after->id());
2399                 }
2400         }
2401
2402         if (!_session._template_state_dir.empty()) {
2403                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2404         }
2405
2406         node->add_child_copy (Slavable::get_state());
2407
2408         return *node;
2409 }
2410
2411 int
2412 Route::set_state (const XMLNode& node, int version)
2413 {
2414         if (version < 3000) {
2415                 return set_state_2X (node, version);
2416         }
2417
2418         XMLNodeList nlist;
2419         XMLNodeConstIterator niter;
2420         XMLNode *child;
2421
2422         if (node.name() != "Route"){
2423                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2424                 return -1;
2425         }
2426
2427         std::string route_name;
2428         if (node.get_property (X_("name"), route_name)) {
2429                 Route::set_name (route_name);
2430         }
2431
2432         set_id (node);
2433         _initial_io_setup = true;
2434
2435         Stripable::set_state (node, version);
2436
2437         node.get_property (X_("strict-io"), _strict_io);
2438
2439         if (is_monitor()) {
2440                 /* monitor bus does not get a panner, but if (re)created
2441                    via XML, it will already have one by the time we
2442                    call ::set_state(). so ... remove it.
2443                 */
2444                 unpan ();
2445         }
2446
2447         /* add all processors (except amp, which is always present) */
2448
2449         nlist = node.children();
2450         XMLNode processor_state (X_("processor_state"));
2451
2452         Stateful::save_extra_xml (node);
2453
2454         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2455
2456                 child = *niter;
2457
2458                 if (child->name() == IO::state_node_name) {
2459                         std::string direction;
2460                         if (!child->get_property (X_("direction"), direction)) {
2461                                 continue;
2462                         }
2463
2464                         if (direction == "Input") {
2465                                 _input->set_state (*child, version);
2466                         } else if (direction == "Output") {
2467                                 _output->set_state (*child, version);
2468                         }
2469
2470                 } else if (child->name() == X_("Processor")) {
2471                         processor_state.add_child_copy (*child);
2472                 } else if (child->name() == X_("Pannable")) {
2473                         if (_pannable) {
2474                                 _pannable->set_state (*child, version);
2475                         } else {
2476                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2477                         }
2478                 } else if (child->name() == Slavable::xml_node_name) {
2479                         Slavable::set_state (*child, version);
2480                 }
2481         }
2482
2483         MeterPoint mp;
2484         if (node.get_property (X_("meter-point"), mp)) {
2485                 set_meter_point (mp, true);
2486                 if (_meter) {
2487                         _meter->set_display_to_user (_meter_point == MeterCustom);
2488                 }
2489         }
2490
2491         node.get_property (X_("meter-type"), _meter_type);
2492
2493         _initial_io_setup = false;
2494
2495         set_processor_state (processor_state);
2496
2497         // this looks up the internal instrument in processors
2498         reset_instrument_info();
2499
2500         bool denormal_protection;
2501         if (node.get_property (X_("denormal-protection"), denormal_protection)) {
2502                 set_denormal_protection (denormal_protection);
2503         }
2504
2505         /* convert old 3001 state */
2506         std::string phase_invert_str;
2507         if (node.get_property (X_("phase-invert"), phase_invert_str)) {
2508                 _phase_control->set_phase_invert (boost::dynamic_bitset<> (phase_invert_str));
2509         }
2510
2511         bool is_active;
2512         if (node.get_property (X_("active"), is_active)) {
2513                 set_active (is_active, this);
2514         }
2515
2516         std::string id_string;
2517         if (node.get_property (X_("processor-after-last-custom-meter"), id_string)) {
2518                 PBD::ID id (id_string);
2519                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2520                 ProcessorList::const_iterator i = _processors.begin ();
2521                 while (i != _processors.end() && (*i)->id() != id) {
2522                         ++i;
2523                 }
2524
2525                 if (i != _processors.end ()) {
2526                         _processor_after_last_custom_meter = *i;
2527                         _custom_meter_position_noted = true;
2528                 }
2529         }
2530
2531         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2532                 child = *niter;
2533
2534                 if (child->name() == X_("Comment")) {
2535
2536                         /* XXX this is a terrible API design in libxml++ */
2537
2538                         XMLNode *cmt = *(child->children().begin());
2539                         _comment = cmt->content();
2540
2541                 }  else if (child->name() == Controllable::xml_node_name) {
2542                         std::string control_name;
2543                         if (!child->get_property (X_("name"), control_name)) {
2544                                 continue;
2545                         }
2546
2547                         if (control_name == _solo_control->name()) {
2548                                 _solo_control->set_state (*child, version);
2549                         } else if (control_name == _solo_safe_control->name()) {
2550                                 _solo_safe_control->set_state (*child, version);
2551                         } else if (control_name == _solo_isolate_control->name()) {
2552                                 _solo_isolate_control->set_state (*child, version);
2553                         } else if (control_name == _mute_control->name()) {
2554                                 _mute_control->set_state (*child, version);
2555                         } else if (control_name == _phase_control->name()) {
2556                                 _phase_control->set_state (*child, version);
2557                         } else {
2558                                 Evoral::Parameter p = EventTypeMap::instance().from_symbol (control_name);
2559                                 if (p.type () >= MidiCCAutomation && p.type () < MidiSystemExclusiveAutomation) {
2560                                         boost::shared_ptr<AutomationControl> ac = automation_control (p, true);
2561                                         if (ac) {
2562                                                 ac->set_state (*child, version);
2563                                         }
2564                                 }
2565                         }
2566                 } else if (child->name() == MuteMaster::xml_node_name) {
2567                         _mute_master->set_state (*child, version);
2568
2569                 } else if (child->name() == Automatable::xml_node_name) {
2570                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2571                 }
2572         }
2573
2574         return 0;
2575 }
2576
2577 int
2578 Route::set_state_2X (const XMLNode& node, int version)
2579 {
2580         LocaleGuard lg;
2581         XMLNodeList nlist;
2582         XMLNodeConstIterator niter;
2583         XMLNode *child;
2584         XMLProperty const * prop;
2585
2586         /* 2X things which still remain to be handled:
2587          * default-type
2588          * automation
2589          * controlouts
2590          */
2591
2592         if (node.name() != "Route") {
2593                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2594                 return -1;
2595         }
2596
2597         Stripable::set_state (node, version);
2598
2599         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2600                 set_denormal_protection (string_to<bool> (prop->value()));
2601         }
2602
2603         if ((prop = node.property (X_("muted"))) != 0) {
2604
2605                 bool first = true;
2606                 bool muted = string_to<bool> (prop->value());
2607
2608                 if (muted) {
2609
2610                         string mute_point;
2611
2612                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2613
2614                                 if (string_to<bool> (prop->value())){
2615                                         mute_point = mute_point + "PreFader";
2616                                         first = false;
2617                                 }
2618                         }
2619
2620                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2621
2622                                 if (string_to<bool> (prop->value())){
2623
2624                                         if (!first) {
2625                                                 mute_point = mute_point + ",";
2626                                         }
2627
2628                                         mute_point = mute_point + "PostFader";
2629                                         first = false;
2630                                 }
2631                         }
2632
2633                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2634
2635                                 if (string_to<bool> (prop->value())){
2636
2637                                         if (!first) {
2638                                                 mute_point = mute_point + ",";
2639                                         }
2640
2641                                         mute_point = mute_point + "Listen";
2642                                         first = false;
2643                                 }
2644                         }
2645
2646                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2647
2648                                 if (string_to<bool> (prop->value())){
2649
2650                                         if (!first) {
2651                                                 mute_point = mute_point + ",";
2652                                         }
2653
2654                                         mute_point = mute_point + "Main";
2655                                 }
2656                         }
2657
2658                         _mute_master->set_mute_points (mute_point);
2659                         _mute_master->set_muted_by_self (true);
2660                 }
2661         }
2662
2663         if ((prop = node.property (X_("meter-point"))) != 0) {
2664                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2665         }
2666
2667         /* IOs */
2668
2669         nlist = node.children ();
2670         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2671
2672                 child = *niter;
2673
2674                 if (child->name() == IO::state_node_name) {
2675
2676                         /* there is a note in IO::set_state_2X() about why we have to call
2677                            this directly.
2678                            */
2679
2680                         _input->set_state_2X (*child, version, true);
2681                         _output->set_state_2X (*child, version, false);
2682
2683                         if ((prop = child->property (X_("name"))) != 0) {
2684                                 Route::set_name (prop->value ());
2685                         }
2686
2687                         set_id (*child);
2688
2689                         if ((prop = child->property (X_("active"))) != 0) {
2690                                 bool yn = string_to<bool> (prop->value());
2691                                 _active = !yn; // force switch
2692                                 set_active (yn, this);
2693                         }
2694
2695                         if ((prop = child->property (X_("gain"))) != 0) {
2696                                 gain_t val;
2697
2698                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2699                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
2700                                 }
2701                         }
2702
2703                         /* Set up Panners in the IO */
2704                         XMLNodeList io_nlist = child->children ();
2705
2706                         XMLNodeConstIterator io_niter;
2707                         XMLNode *io_child;
2708
2709                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2710
2711                                 io_child = *io_niter;
2712
2713                                 if (io_child->name() == X_("Panner")) {
2714                                         _main_outs->panner_shell()->set_state(*io_child, version);
2715                                 } else if (io_child->name() == X_("Automation")) {
2716                                         /* IO's automation is for the fader */
2717                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2718                                 }
2719                         }
2720                 }
2721         }
2722
2723         XMLNodeList redirect_nodes;
2724
2725         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2726
2727                 child = *niter;
2728
2729                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2730                         redirect_nodes.push_back(child);
2731                 }
2732
2733         }
2734
2735         set_processor_state_2X (redirect_nodes, version);
2736
2737         Stateful::save_extra_xml (node);
2738
2739         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2740                 child = *niter;
2741
2742                 if (child->name() == X_("Comment")) {
2743
2744                         /* XXX this is a terrible API design in libxml++ */
2745
2746                         XMLNode *cmt = *(child->children().begin());
2747                         _comment = cmt->content();
2748
2749                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2750                         if (prop->value() == X_("solo")) {
2751                                 _solo_control->set_state (*child, version);
2752                         } else if (prop->value() == X_("mute")) {
2753                                 _mute_control->set_state (*child, version);
2754                         }
2755
2756                 }
2757         }
2758
2759         return 0;
2760 }
2761
2762 XMLNode&
2763 Route::get_processor_state ()
2764 {
2765         XMLNode* root = new XMLNode (X_("redirects"));
2766         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2767                 root->add_child_nocopy ((*i)->state (true));
2768         }
2769
2770         return *root;
2771 }
2772
2773 void
2774 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2775 {
2776         /* We don't bother removing existing processors not in nList, as this
2777            method will only be called when creating a Route from scratch, not
2778            for undo purposes.  Just put processors in at the appropriate place
2779            in the list.
2780         */
2781
2782         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2783                 add_processor_from_xml_2X (**i, version);
2784         }
2785 }
2786
2787 void
2788 Route::set_processor_state (const XMLNode& node)
2789 {
2790         const XMLNodeList &nlist = node.children();
2791         XMLNodeConstIterator niter;
2792         ProcessorList new_order;
2793         bool must_configure = false;
2794
2795         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2796
2797                 XMLProperty* prop = (*niter)->property ("type");
2798
2799                 if (prop->value() == "amp") {
2800                         _amp->set_state (**niter, Stateful::current_state_version);
2801                         new_order.push_back (_amp);
2802                 } else if (prop->value() == "trim") {
2803                         _trim->set_state (**niter, Stateful::current_state_version);
2804                         new_order.push_back (_trim);
2805                 } else if (prop->value() == "meter") {
2806                         _meter->set_state (**niter, Stateful::current_state_version);
2807                         new_order.push_back (_meter);
2808                 } else if (prop->value() == "delay") {
2809                         if (_delayline) {
2810                                 _delayline->set_state (**niter, Stateful::current_state_version);
2811                                 new_order.push_back (_delayline);
2812                         }
2813                 } else if (prop->value() == "main-outs") {
2814                         _main_outs->set_state (**niter, Stateful::current_state_version);
2815                 } else if (prop->value() == "intreturn") {
2816                         if (!_intreturn) {
2817                                 _intreturn.reset (new InternalReturn (_session));
2818                                 must_configure = true;
2819                         }
2820                         _intreturn->set_state (**niter, Stateful::current_state_version);
2821                 } else if (is_monitor() && prop->value() == "monitor") {
2822                         if (!_monitor_control) {
2823                                 _monitor_control.reset (new MonitorProcessor (_session));
2824                                 must_configure = true;
2825                         }
2826                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2827                 } else if (prop->value() == "capture") {
2828                         /* CapturingProcessor should never be restored, it's always
2829                            added explicitly when needed */
2830                 } else {
2831                         ProcessorList::iterator o;
2832
2833                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2834                                 XMLProperty const * id_prop = (*niter)->property(X_("id"));
2835                                 if (id_prop && (*o)->id() == id_prop->value()) {
2836                                         (*o)->set_state (**niter, Stateful::current_state_version);
2837                                         new_order.push_back (*o);
2838                                         break;
2839                                 }
2840                         }
2841
2842                         // If the processor (*niter) is not on the route then create it
2843
2844                         if (o == _processors.end()) {
2845
2846                                 boost::shared_ptr<Processor> processor;
2847
2848                                 if (prop->value() == "intsend") {
2849
2850                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2851
2852                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2853                                            prop->value() == "lv2" ||
2854                                            prop->value() == "windows-vst" ||
2855                                            prop->value() == "mac-vst" ||
2856                                            prop->value() == "lxvst" ||
2857                                            prop->value() == "luaproc" ||
2858                                            prop->value() == "audiounit") {
2859
2860                                         if (_session.get_disable_all_loaded_plugins ()) {
2861                                                 processor.reset (new UnknownProcessor (_session, **niter));
2862                                         } else {
2863                                                 processor.reset (new PluginInsert (_session));
2864                                                 processor->set_owner (this);
2865                                                 if (_strict_io) {
2866                                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
2867                                                         pi->set_strict_io (true);
2868                                                 }
2869
2870                                         }
2871                                 } else if (prop->value() == "port") {
2872
2873                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2874
2875                                 } else if (prop->value() == "send") {
2876
2877                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2878                                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
2879                                         send->SelfDestruct.connect_same_thread (*this,
2880                                                         boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
2881
2882                                 } else {
2883                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2884                                         continue;
2885                                 }
2886
2887                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2888                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2889                                         processor.reset (new UnknownProcessor (_session, **niter));
2890                                 }
2891
2892                                 /* subscribe to Sidechain IO changes */
2893                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
2894                                 if (pi && pi->has_sidechain ()) {
2895                                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2896                                 }
2897
2898                                 /* we have to note the monitor send here, otherwise a new one will be created
2899                                    and the state of this one will be lost.
2900                                 */
2901                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2902                                 if (isend && isend->role() == Delivery::Listen) {
2903                                         _monitor_send = isend;
2904                                 }
2905
2906                                 /* it doesn't matter if invisible processors are added here, as they
2907                                    will be sorted out by setup_invisible_processors () shortly.
2908                                 */
2909
2910                                 new_order.push_back (processor);
2911                                 must_configure = true;
2912                         }
2913                 }
2914         }
2915
2916         ProcessorList old_list = _processors; // keep a copy
2917         {
2918                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2919                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2920                 /* re-assign _processors w/o process-lock.
2921                  * if there's an IO-processor present in _processors but
2922                  * not in new_order, it will be deleted and ~IO takes
2923                  * a process lock.
2924                  */
2925                 _processors = new_order;
2926
2927                 if (must_configure) {
2928                         configure_processors_unlocked (0, &lm);
2929                 }
2930
2931                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2932
2933                         (*i)->set_owner (this);
2934                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2935
2936                         boost::shared_ptr<PluginInsert> pi;
2937
2938                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2939                                 if (pi->has_no_inputs ()) {
2940                                         _have_internal_generator = true;
2941                                         break;
2942                                 }
2943                         }
2944                 }
2945         }
2946         /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
2947         old_list.clear ();
2948
2949         reset_instrument_info ();
2950         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2951         set_processor_positions ();
2952 }
2953
2954 void
2955 Route::curve_reallocate ()
2956 {
2957 //      _gain_automation_curve.finish_resize ();
2958 //      _pan_automation_curve.finish_resize ();
2959 }
2960
2961 void
2962 Route::silence (framecnt_t nframes)
2963 {
2964         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2965         if (!lm.locked()) {
2966                 return;
2967         }
2968
2969         silence_unlocked (nframes);
2970 }
2971
2972 void
2973 Route::silence_unlocked (framecnt_t nframes)
2974 {
2975         /* Must be called with the processor lock held */
2976
2977         const framepos_t now = _session.transport_frame ();
2978
2979         if (!_silent) {
2980
2981                 _output->silence (nframes);
2982
2983                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2984                         boost::shared_ptr<PluginInsert> pi;
2985
2986                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2987                                 // skip plugins, they don't need anything when we're not active
2988                                 continue;
2989                         }
2990
2991                         (*i)->silence (nframes, now);
2992                 }
2993
2994                 if (nframes == _session.get_block_size()) {
2995                         // _silent = true;
2996                 }
2997         }
2998 }
2999
3000 void
3001 Route::add_internal_return ()
3002 {
3003         if (!_intreturn) {
3004                 _intreturn.reset (new InternalReturn (_session));
3005                 add_processor (_intreturn, PreFader);
3006         }
3007 }
3008
3009 void
3010 Route::add_send_to_internal_return (InternalSend* send)
3011 {
3012         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3013
3014         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3015                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3016
3017                 if (d) {
3018                         return d->add_send (send);
3019                 }
3020         }
3021 }
3022
3023 void
3024 Route::remove_send_from_internal_return (InternalSend* send)
3025 {
3026         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3027
3028         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3029                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3030
3031                 if (d) {
3032                         return d->remove_send (send);
3033                 }
3034         }
3035 }
3036
3037 void
3038 Route::enable_monitor_send ()
3039 {
3040         /* Caller must hold process lock */
3041         assert (!AudioEngine::instance()->process_lock().trylock());
3042
3043         /* master never sends to monitor section via the normal mechanism */
3044         assert (!is_master ());
3045         assert (!is_monitor ());
3046
3047         /* make sure we have one */
3048         if (!_monitor_send) {
3049                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3050                 _monitor_send->set_display_to_user (false);
3051         }
3052
3053         /* set it up */
3054         configure_processors (0);
3055 }
3056
3057 /** Add an aux send to a route.
3058  *  @param route route to send to.
3059  *  @param before Processor to insert before, or 0 to insert at the end.
3060  */
3061 int
3062 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3063 {
3064         assert (route != _session.monitor_out ());
3065
3066         {
3067                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3068
3069                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3070
3071                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3072
3073                         if (d && d->target_route() == route) {
3074                                 /* already listening via the specified IO: do nothing */
3075                                 return 0;
3076                         }
3077                 }
3078         }
3079
3080         try {
3081
3082                 boost::shared_ptr<InternalSend> listener;
3083
3084                 {
3085                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3086                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3087                 }
3088
3089                 add_processor (listener, before);
3090
3091         } catch (failed_constructor& err) {
3092                 return -1;
3093         }
3094
3095         return 0;
3096 }
3097
3098 void
3099 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3100 {
3101         ProcessorStreams err;
3102         ProcessorList::iterator tmp;
3103
3104         {
3105                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3106
3107                 /* have to do this early because otherwise processor reconfig
3108                  * will put _monitor_send back in the list
3109                  */
3110
3111                 if (route == _session.monitor_out()) {
3112                         _monitor_send.reset ();
3113                 }
3114
3115           again:
3116                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3117
3118                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3119
3120                         if (d && d->target_route() == route) {
3121                                 rl.release ();
3122                                 if (remove_processor (*x, &err, false) > 0) {
3123                                         rl.acquire ();
3124                                         continue;
3125                                 }
3126                                 rl.acquire ();
3127
3128                                 /* list could have been demolished while we dropped the lock
3129                                    so start over.
3130                                 */
3131                                 if (_session.engine().connected()) {
3132                                         /* i/o processors cannot be removed if the engine is not running
3133                                          * so don't live-loop in case the engine is N/A or dies
3134                                          */
3135                                         goto again;
3136                                 }
3137                         }
3138                 }
3139         }
3140 }
3141
3142 void
3143 Route::set_comment (string cmt, void *src)
3144 {
3145         _comment = cmt;
3146         comment_changed ();
3147         _session.set_dirty ();
3148 }
3149
3150 bool
3151 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3152 {
3153         FeedRecord fr (other, via_sends_only);
3154
3155         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3156
3157         if (!result.second) {
3158
3159                 /* already a record for "other" - make sure sends-only information is correct */
3160                 if (!via_sends_only && result.first->sends_only) {
3161                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3162                         frp->sends_only = false;
3163                 }
3164         }
3165
3166         return result.second;
3167 }
3168
3169 void
3170 Route::clear_fed_by ()
3171 {
3172         _fed_by.clear ();
3173 }
3174
3175 bool
3176 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3177 {
3178         const FedBy& fed_by (other->fed_by());
3179
3180         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3181                 boost::shared_ptr<Route> sr = f->r.lock();
3182
3183                 if (sr && (sr.get() == this)) {
3184
3185                         if (via_sends_only) {
3186                                 *via_sends_only = f->sends_only;
3187                         }
3188
3189                         return true;
3190                 }
3191         }
3192
3193         return false;
3194 }
3195
3196 IOVector
3197 Route::all_inputs () const
3198 {
3199         /* TODO, if this works as expected,
3200          * cache the IOVector and maintain it via
3201          * input_change_handler(), sidechain_change_handler() etc
3202          */
3203         IOVector ios;
3204         ios.push_back (_input);
3205
3206         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3207         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3208
3209                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3210                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3211                 if (pi != 0) {
3212                         assert (iop == 0);
3213                         iop = pi->sidechain();
3214                 }
3215
3216                 if (iop != 0 && iop->input()) {
3217                         ios.push_back (iop->input());
3218                 }
3219         }
3220         return ios;
3221 }
3222
3223 IOVector
3224 Route::all_outputs () const
3225 {
3226         IOVector ios;
3227         // _output is included via Delivery
3228         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3229         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3230                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3231                 if (iop != 0 && iop->output()) {
3232                         ios.push_back (iop->output());
3233                 }
3234         }
3235         return ios;
3236 }
3237
3238 bool
3239 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3240 {
3241         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3242         if (other->all_inputs().fed_by (_output)) {
3243                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3244                 if (via_send_only) {
3245                         *via_send_only = false;
3246                 }
3247
3248                 return true;
3249         }
3250
3251         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3252
3253         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3254
3255                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3256                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3257                 if (pi != 0) {
3258                         assert (iop == 0);
3259                         iop = pi->sidechain();
3260                 }
3261
3262                 if (iop != 0) {
3263                         boost::shared_ptr<const IO> iop_out = iop->output();
3264                         if (other.get() == this && iop_out && iop->input() && iop_out->connected_to (iop->input())) {
3265                                 // TODO this needs a delaylines in the Insert to align connections (!)
3266                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed its own return (%2)\n", iop->name(), other->name()));
3267                                 continue;
3268                         }
3269                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3270                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3271                                 if (via_send_only) {
3272                                         *via_send_only = true;
3273                                 }
3274                                 return true;
3275                         } else {
3276                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3277                         }
3278                 } else {
3279                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3280                 }
3281
3282         }
3283
3284         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3285         return false;
3286 }
3287
3288 bool
3289 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3290 {
3291         return _session._current_route_graph.has (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other, via_send_only);
3292 }
3293
3294 bool
3295 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3296 {
3297         return _session._current_route_graph.feeds (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other);
3298 }
3299
3300 /** Called from the (non-realtime) butler thread when the transport is stopped */
3301 void
3302 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3303 {
3304         framepos_t now = _session.transport_frame();
3305
3306         {
3307                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3308
3309                 Automatable::transport_stopped (now);
3310
3311                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3312
3313                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3314                                 (*i)->flush ();
3315                         }
3316
3317                         (*i)->transport_stopped (now);
3318                 }
3319         }
3320
3321         _roll_delay = _initial_delay;
3322 }
3323
3324 void
3325 Route::input_change_handler (IOChange change, void * /*src*/)
3326 {
3327         if ((change.type & IOChange::ConfigurationChanged)) {
3328                 /* This is called with the process lock held if change
3329                    contains ConfigurationChanged
3330                 */
3331                 configure_processors (0);
3332                 _phase_control->resize (_input->n_ports().n_audio ());
3333                 io_changed (); /* EMIT SIGNAL */
3334         }
3335
3336         if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3337                 int sbou = 0;
3338                 int ibou = 0;
3339                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3340                 if (_input->connected()) {
3341                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3342                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3343                                         continue;
3344                                 }
3345                                 bool sends_only;
3346                                 bool does_feed = (*i)->direct_feeds_according_to_reality (boost::dynamic_pointer_cast<Route> (shared_from_this()), &sends_only);
3347                                 if (does_feed && !sends_only) {
3348                                         if ((*i)->soloed()) {
3349                                                 ++sbou;
3350                                         }
3351                                         if ((*i)->solo_isolate_control()->solo_isolated()) {
3352                                                 ++ibou;
3353                                         }
3354                                 }
3355                         }
3356                 }
3357
3358                 int delta  = sbou - _solo_control->soloed_by_others_upstream();
3359                 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3360
3361                 if (idelta < -1) {
3362                         PBD::warning << string_compose (
3363                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3364                                         _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3365                                      << endmsg;
3366
3367                 }
3368
3369                 if (_solo_control->soloed_by_others_upstream()) {
3370                         // ignore new connections (they're not propagated)
3371                         if (delta <= 0) {
3372                                 _solo_control->mod_solo_by_others_upstream (delta);
3373                         }
3374                 }
3375
3376                 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3377                         // solo-isolate currently only propagates downstream
3378                         if (idelta < 0) {
3379                                 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3380                         }
3381                         //_solo_isolated_by_upstream = ibou;
3382                 }
3383
3384                 // Session::route_solo_changed  does not propagate indirect solo-changes
3385                 // propagate downstream to tracks
3386                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3387                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3388                                 continue;
3389                         }
3390                         bool sends_only;
3391                         bool does_feed = feeds (*i, &sends_only);
3392                         if (delta <= 0 && does_feed && !sends_only) {
3393                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3394                         }
3395
3396                         if (idelta < 0 && does_feed && !sends_only) {
3397                                 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3398                         }
3399                 }
3400         }
3401 }
3402
3403 void
3404 Route::output_change_handler (IOChange change, void * /*src*/)
3405 {
3406         if (_initial_io_setup) {
3407                 return;
3408         }
3409
3410         if ((change.type & IOChange::ConfigurationChanged)) {
3411                 /* This is called with the process lock held if change
3412                    contains ConfigurationChanged
3413                 */
3414                 configure_processors (0);
3415
3416                 if (is_master()) {
3417                         _session.reset_monitor_section();
3418                 }
3419
3420                 io_changed (); /* EMIT SIGNAL */
3421         }
3422
3423         if ((change.type & IOChange::ConnectionsChanged)) {
3424
3425                 /* do this ONLY if connections have changed. Configuration
3426                  * changes do not, by themselves alter solo upstream or
3427                  * downstream status.
3428                  */
3429
3430                 if (_solo_control->soloed_by_others_downstream()) {
3431                         int sbod = 0;
3432                         /* checking all all downstream routes for
3433                          * explicit of implict solo is a rather drastic measure,
3434                          * ideally the input_change_handler() of the other route
3435                          * would propagate the change to us.
3436                          */
3437                         boost::shared_ptr<RouteList> routes = _session.get_routes ();
3438                         if (_output->connected()) {
3439                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3440                                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3441                                                 continue;
3442                                         }
3443                                         bool sends_only;
3444                                         bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3445                                         if (does_feed && !sends_only) {
3446                                                 if ((*i)->soloed()) {
3447                                                         ++sbod;
3448                                                         break;
3449                                                 }
3450                                         }
3451                                 }
3452                         }
3453
3454                         int delta = sbod - _solo_control->soloed_by_others_downstream();
3455                         if (delta <= 0) {
3456                                 // do not allow new connections to change implicit solo (no propagation)
3457                                 _solo_control->mod_solo_by_others_downstream (delta);
3458                                 // Session::route_solo_changed() does not propagate indirect solo-changes
3459                                 // propagate upstream to tracks
3460                                 boost::shared_ptr<Route> shared_this = boost::dynamic_pointer_cast<Route> (shared_from_this());
3461                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3462                                         if ((*i).get() == this || !can_solo()) {
3463                                                 continue;
3464                                         }
3465                                         bool sends_only;
3466                                         bool does_feed = (*i)->feeds (shared_this, &sends_only);
3467                                         if (delta != 0 && does_feed && !sends_only) {
3468                                                 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3469                                         }
3470                                 }
3471
3472                         }
3473                 }
3474         }
3475 }
3476
3477 void
3478 Route::sidechain_change_handler (IOChange change, void* src)
3479 {
3480         if (_initial_io_setup || _in_sidechain_setup) {
3481                 return;
3482         }
3483
3484         input_change_handler (change, src);
3485 }
3486
3487 uint32_t
3488 Route::pans_required () const
3489 {
3490         if (n_outputs().n_audio() < 2) {
3491                 return 0;
3492         }
3493
3494         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3495 }
3496
3497 void
3498 Route::flush_processor_buffers_locked (framecnt_t nframes)
3499 {
3500         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3501                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
3502                 if (d) {
3503                         d->flush_buffers (nframes);
3504                 } else {
3505                         boost::shared_ptr<PortInsert> p = boost::dynamic_pointer_cast<PortInsert> (*i);
3506                         if (p) {
3507                                 p->flush_buffers (nframes);
3508                         }
3509                 }
3510         }
3511 }
3512
3513 int
3514 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3515 {
3516         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3517
3518         if (!lm.locked()) {
3519                 return 0;
3520         }
3521
3522         if (!_active) {
3523                 silence_unlocked (nframes);
3524                 return 0;
3525         }
3526
3527         if (session_state_changing) {
3528                 if (_session.transport_speed() != 0.0f) {
3529                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3530                            so we cannot use them. Be silent till this is over.
3531
3532                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3533                         */
3534                         silence_unlocked (nframes);
3535                         return 0;
3536                 }
3537                 /* we're really not rolling, so we're either delivery silence or actually
3538                    monitoring, both of which are safe to do while session_state_changing is true.
3539                 */
3540         }
3541
3542         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3543
3544         fill_buffers_with_input (bufs, _input, nframes);
3545
3546         if (_meter_point == MeterInput) {
3547                 _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true);
3548         }
3549
3550         _amp->apply_gain_automation (false);
3551         _trim->apply_gain_automation (false);
3552         passthru (bufs, start_frame, end_frame, nframes, 0);
3553
3554         flush_processor_buffers_locked (nframes);
3555
3556         return 0;
3557 }
3558
3559 int
3560 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3561 {
3562         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3563         if (!lm.locked()) {
3564                 return 0;
3565         }
3566
3567         if (!_active) {
3568                 silence_unlocked (nframes);
3569                 return 0;
3570         }
3571
3572         framepos_t unused = 0;
3573
3574         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3575                 return 0;
3576         }
3577
3578         _silent = false;
3579
3580         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3581
3582         fill_buffers_with_input (bufs, _input, nframes);
3583
3584         if (_meter_point == MeterInput) {
3585                 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
3586         }
3587
3588         passthru (bufs, start_frame, end_frame, nframes, declick);
3589
3590         flush_processor_buffers_locked (nframes);
3591
3592         return 0;
3593 }
3594
3595 int
3596 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3597 {
3598         silence (nframes);
3599         flush_processor_buffers_locked (nframes);
3600         return 0;
3601 }
3602
3603 void
3604 Route::flush_processors ()
3605 {
3606         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3607
3608         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3609                 (*i)->flush ();
3610         }
3611 }
3612
3613 #ifdef __clang__
3614 __attribute__((annotate("realtime")))
3615 #endif
3616 bool
3617 Route::apply_processor_changes_rt ()
3618 {
3619         int emissions = EmitNone;
3620
3621         if (_pending_meter_point != _meter_point) {
3622                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3623                 if (pwl.locked()) {
3624                         /* meters always have buffers for 'processor_max_streams'
3625                          * they can be re-positioned without re-allocation */
3626                         if (set_meter_point_unlocked()) {
3627                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3628                         } else {
3629                                 emissions |= EmitMeterChanged;
3630                         }
3631                 }
3632         }
3633
3634         bool changed = false;
3635
3636         if (g_atomic_int_get (&_pending_process_reorder)) {
3637                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3638                 if (pwl.locked()) {
3639                         apply_processor_order (_pending_processor_order);
3640                         setup_invisible_processors ();
3641                         changed = true;
3642                         g_atomic_int_set (&_pending_process_reorder, 0);
3643                         emissions |= EmitRtProcessorChange;
3644                 }
3645         }
3646         if (changed) {
3647                 set_processor_positions ();
3648         }
3649         if (emissions != 0) {
3650                 g_atomic_int_set (&_pending_signals, emissions);
3651                 return true;
3652         }
3653         return (!selfdestruct_sequence.empty ());
3654 }
3655
3656 void
3657 Route::emit_pending_signals ()
3658 {
3659         int sig = g_atomic_int_and (&_pending_signals, 0);
3660         if (sig & EmitMeterChanged) {
3661                 _meter->emit_configuration_changed();
3662                 meter_change (); /* EMIT SIGNAL */
3663                 if (sig & EmitMeterVisibilityChange) {
3664                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3665                 } else {
3666                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3667                 }
3668         }
3669         if (sig & EmitRtProcessorChange) {
3670                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3671         }
3672
3673         /* this would be a job for the butler.
3674          * Conceptually we should not take processe/processor locks here.
3675          * OTOH its more efficient (less overhead for summoning the butler and
3676          * telling her what do do) and signal emission is called
3677          * directly after the process callback, which decreases the chance
3678          * of x-runs when taking the locks.
3679          */
3680         while (!selfdestruct_sequence.empty ()) {
3681                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3682                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3683                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3684                 selfdestruct_sequence.pop_back ();
3685                 lx.release ();
3686                 if (proc) {
3687                         remove_processor (proc);
3688                 }
3689         }
3690 }
3691
3692 void
3693 Route::set_meter_point (MeterPoint p, bool force)
3694 {
3695         if (_pending_meter_point == p && !force) {
3696                 return;
3697         }
3698
3699         if (force || !AudioEngine::instance()->running()) {
3700                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3701                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3702                 _pending_meter_point = p;
3703                 _meter->emit_configuration_changed();
3704                 meter_change (); /* EMIT SIGNAL */
3705                 if (set_meter_point_unlocked()) {
3706                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3707                 } else {
3708                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3709                 }
3710         } else {
3711                 _pending_meter_point = p;
3712         }
3713 }
3714
3715
3716 #ifdef __clang__
3717 __attribute__((annotate("realtime")))
3718 #endif
3719 bool
3720 Route::set_meter_point_unlocked ()
3721 {
3722 #ifndef NDEBUG
3723         /* Caller must hold process and processor write lock */
3724         assert (!AudioEngine::instance()->process_lock().trylock());
3725         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3726         assert (!lm.locked ());
3727 #endif
3728
3729         _meter_point = _pending_meter_point;
3730
3731         bool meter_was_visible_to_user = _meter->display_to_user ();
3732
3733         if (!_custom_meter_position_noted) {
3734                 maybe_note_meter_position ();
3735         }
3736
3737         if (_meter_point != MeterCustom) {
3738
3739                 _meter->set_display_to_user (false);
3740
3741                 setup_invisible_processors ();
3742
3743         } else {
3744                 _meter->set_display_to_user (true);
3745
3746                 /* If we have a previous position for the custom meter, try to put it there */
3747                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3748                 if (after) {
3749                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3750                         if (i != _processors.end ()) {
3751                                 _processors.remove (_meter);
3752                                 _processors.insert (i, _meter);
3753                         }
3754                 } else {// at end, right before the mains_out/panner
3755                         _processors.remove (_meter);
3756                         ProcessorList::iterator main = _processors.end();
3757                         _processors.insert (--main, _meter);
3758                 }
3759         }
3760
3761         /* Set up the meter for its new position */
3762
3763         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3764
3765         ChanCount m_in;
3766
3767         if (loc == _processors.begin()) {
3768                 m_in = _input->n_ports();
3769         } else {
3770                 ProcessorList::iterator before = loc;
3771                 --before;
3772                 m_in = (*before)->output_streams ();
3773         }
3774
3775         _meter->reflect_inputs (m_in);
3776
3777         /* we do not need to reconfigure the processors, because the meter
3778            (a) is always ready to handle processor_max_streams
3779            (b) is always an N-in/N-out processor, and thus moving
3780            it doesn't require any changes to the other processors.
3781         */
3782
3783         /* these should really be done after releasing the lock
3784          * but all those signals are subscribed to with gui_thread()
3785          * so we're safe.
3786          */
3787          return (_meter->display_to_user() != meter_was_visible_to_user);
3788 }
3789
3790 void
3791 Route::listen_position_changed ()
3792 {
3793         {
3794                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3795                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3796                 ProcessorState pstate (this);
3797
3798                 if (configure_processors_unlocked (0, &lm)) {
3799                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
3800                         pstate.restore ();
3801                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
3802                         return;
3803                 }
3804         }
3805
3806         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3807         _session.set_dirty ();
3808 }
3809
3810 boost::shared_ptr<CapturingProcessor>
3811 Route::add_export_point()
3812 {
3813         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3814         if (!_capturing_processor) {
3815                 lm.release();
3816                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3817                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3818
3819                 // this aligns all tracks; but not tracks + busses
3820                 assert (_session.worst_track_latency () >= _initial_delay);
3821                 _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay));
3822                 _capturing_processor->activate ();
3823
3824                 configure_processors_unlocked (0, &lw);
3825
3826         }
3827
3828         return _capturing_processor;
3829 }
3830
3831 framecnt_t
3832 Route::update_signal_latency ()
3833 {
3834         framecnt_t l = _output->user_latency();
3835         framecnt_t lamp = 0;
3836         bool before_amp = true;
3837         framecnt_t ltrim = 0;
3838         bool before_trim = true;
3839
3840         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3841                 if ((*i)->active ()) {
3842                         l += (*i)->signal_latency ();
3843                 }
3844                 if ((*i) == _amp) {
3845                         before_amp = false;
3846                 }
3847                 if ((*i) == _trim) {
3848                         before_amp = false;
3849                 }
3850                 if (before_amp) {
3851                         lamp = l;
3852                 }
3853                 if (before_trim) {
3854                         lamp = l;
3855                 }
3856         }
3857
3858         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3859
3860         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
3861         _signal_latency_at_amp_position = lamp;
3862         _signal_latency_at_trim_position = ltrim;
3863
3864         if (_signal_latency != l) {
3865                 _signal_latency = l;
3866                 signal_latency_changed (); /* EMIT SIGNAL */
3867         }
3868
3869         return _signal_latency;
3870 }
3871
3872 void
3873 Route::set_user_latency (framecnt_t nframes)
3874 {
3875         _output->set_user_latency (nframes);
3876         _session.update_latency_compensation ();
3877 }
3878
3879 void
3880 Route::set_latency_compensation (framecnt_t longest_session_latency)
3881 {
3882         framecnt_t old = _initial_delay;
3883
3884         if (_signal_latency < longest_session_latency) {
3885                 _initial_delay = longest_session_latency - _signal_latency;
3886         } else {
3887                 _initial_delay = 0;
3888         }
3889
3890         DEBUG_TRACE (DEBUG::Latency, string_compose (
3891                              "%1: compensate for maximum latency of %2,"
3892                              "given own latency of %3, using initial delay of %4\n",
3893                              name(), longest_session_latency, _signal_latency, _initial_delay));
3894
3895         if (_initial_delay != old) {
3896                 initial_delay_changed (); /* EMIT SIGNAL */
3897         }
3898
3899         if (_session.transport_stopped()) {
3900                 _roll_delay = _initial_delay;
3901         }
3902 }
3903
3904 void
3905 Route::set_block_size (pframes_t nframes)
3906 {
3907         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3908                 (*i)->set_block_size (nframes);
3909         }
3910
3911         _session.ensure_buffers (n_process_buffers ());
3912 }
3913
3914 void
3915 Route::protect_automation ()
3916 {
3917         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3918                 (*i)->protect_automation();
3919 }
3920
3921 /** @param declick 1 to set a pending declick fade-in,
3922  *                -1 to set a pending declick fade-out
3923  */
3924 void
3925 Route::set_pending_declick (int declick)
3926 {
3927         if (_declickable) {
3928                 /* this call is not allowed to turn off a pending declick */
3929                 if (declick) {
3930                         _pending_declick = declick;
3931                 }
3932         } else {
3933                 _pending_declick = 0;
3934         }
3935 }
3936
3937 /** Shift automation forwards from a particular place, thereby inserting time.
3938  *  Adds undo commands for any shifts that are performed.
3939  *
3940  * @param pos Position to start shifting from.
3941  * @param frames Amount to shift forwards by.
3942  */
3943
3944 void
3945 Route::shift (framepos_t pos, framecnt_t frames)
3946 {
3947         /* gain automation */
3948         {
3949                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3950
3951                 XMLNode &before = gc->alist()->get_state ();
3952                 gc->alist()->shift (pos, frames);
3953                 XMLNode &after = gc->alist()->get_state ();
3954                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3955         }
3956
3957         /* gain automation */
3958         {
3959                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3960
3961                 XMLNode &before = gc->alist()->get_state ();
3962                 gc->alist()->shift (pos, frames);
3963                 XMLNode &after = gc->alist()->get_state ();
3964                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3965         }
3966
3967         // TODO mute automation ??
3968
3969         /* pan automation */
3970         if (_pannable) {
3971                 ControlSet::Controls& c (_pannable->controls());
3972
3973                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3974                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3975                         if (pc) {
3976                                 boost::shared_ptr<AutomationList> al = pc->alist();
3977                                 XMLNode& before = al->get_state ();
3978                                 al->shift (pos, frames);
3979                                 XMLNode& after = al->get_state ();
3980                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3981                         }
3982                 }
3983         }
3984
3985         /* redirect automation */
3986         {
3987                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3988                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3989
3990                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3991
3992                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3993                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3994                                 if (ac) {
3995                                         boost::shared_ptr<AutomationList> al = ac->alist();
3996                                         XMLNode &before = al->get_state ();
3997                                         al->shift (pos, frames);
3998                                         XMLNode &after = al->get_state ();
3999                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4000                                 }
4001                         }
4002                 }
4003         }
4004 }
4005
4006 void
4007 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4008 {
4009         boost::shared_ptr<Processor> processor (p.lock ());
4010         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4011         if (!pi) {
4012                 return;
4013         }
4014         pi->set_state_dir (d);
4015 }
4016
4017 int
4018 Route::save_as_template (const string& path, const string& name)
4019 {
4020         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4021         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4022
4023         XMLNode& node (state (false));
4024
4025         XMLTree tree;
4026
4027         IO::set_name_in_state (*node.children().front(), name);
4028
4029         tree.set_root (&node);
4030
4031         /* return zero on success, non-zero otherwise */
4032         return !tree.write (path.c_str());
4033 }
4034
4035
4036 bool
4037 Route::set_name (const string& str)
4038 {
4039         if (str.empty ()) {
4040                 return false;
4041         }
4042
4043         if (str == name()) {
4044                 return true;
4045         }
4046
4047         string name = Route::ensure_track_or_route_name (str, _session);
4048         SessionObject::set_name (name);
4049
4050         bool ret = (_input->set_name(name) && _output->set_name(name));
4051
4052         if (ret) {
4053                 /* rename the main outs. Leave other IO processors
4054                  * with whatever name they already have, because its
4055                  * just fine as it is (it will not contain the route
4056                  * name if its a port insert, port send or port return).
4057                  */
4058
4059                 if (_main_outs) {
4060                         if (_main_outs->set_name (name)) {
4061                                 /* XXX returning false here is stupid because
4062                                    we already changed the route name.
4063                                 */
4064                                 return false;
4065                         }
4066                 }
4067         }
4068
4069         return ret;
4070 }
4071
4072 /** Set the name of a route in an XML description.
4073  *  @param node XML <Route> node to set the name in.
4074  *  @param name New name.
4075  */
4076 void
4077 Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
4078 {
4079         node.set_property (X_("name"), name);
4080
4081         XMLNodeList children = node.children();
4082         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4083
4084                 if ((*i)->name() == X_("IO")) {
4085
4086                         IO::set_name_in_state (**i, name);
4087
4088                 } else if ((*i)->name() == X_("Processor")) {
4089
4090                         std::string str;
4091                         if ((*i)->get_property (X_("role"), str) && str == X_("Main")) {
4092                                 (*i)->set_property (X_("name"), name);
4093                         }
4094
4095                 } else if ((*i)->name() == X_("Diskstream")) {
4096
4097                         if (rename_playlist) {
4098                                 (*i)->set_property (X_("playlist"), name + ".1");
4099                         }
4100                         (*i)->set_property (X_("name"), name);
4101
4102                 }
4103         }
4104 }
4105
4106 boost::shared_ptr<Send>
4107 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4108 {
4109         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4110
4111         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4112                 boost::shared_ptr<InternalSend> send;
4113
4114                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4115                         if (send->target_route() == target) {
4116                                 return send;
4117                         }
4118                 }
4119         }
4120
4121         return boost::shared_ptr<Send>();
4122 }
4123
4124 void
4125 Route::set_denormal_protection (bool yn)
4126 {
4127         if (_denormal_protection != yn) {
4128                 _denormal_protection = yn;
4129                 denormal_protection_changed (); /* EMIT SIGNAL */
4130         }
4131 }
4132
4133 bool
4134 Route::denormal_protection () const
4135 {
4136         return _denormal_protection;
4137 }
4138
4139 void
4140 Route::set_active (bool yn, void* src)
4141 {
4142         if (_session.transport_rolling()) {
4143                 return;
4144         }
4145
4146         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4147                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4148                 return;
4149         }
4150
4151         if (_active != yn) {
4152                 _active = yn;
4153                 _input->set_active (yn);
4154                 _output->set_active (yn);
4155                 flush_processors ();
4156                 active_changed (); // EMIT SIGNAL
4157                 _session.set_dirty ();
4158         }
4159 }
4160
4161 boost::shared_ptr<Pannable>
4162 Route::pannable() const
4163 {
4164         return _pannable;
4165 }
4166
4167 boost::shared_ptr<Panner>
4168 Route::panner() const
4169 {
4170         /* may be null ! */
4171         return _main_outs->panner_shell()->panner();
4172 }
4173
4174 boost::shared_ptr<PannerShell>
4175 Route::panner_shell() const
4176 {
4177         return _main_outs->panner_shell();
4178 }
4179
4180 boost::shared_ptr<GainControl>
4181 Route::gain_control() const
4182 {
4183         return _gain_control;
4184 }
4185
4186 boost::shared_ptr<GainControl>
4187 Route::trim_control() const
4188 {
4189         return _trim_control;
4190 }
4191
4192 boost::shared_ptr<PhaseControl>
4193 Route::phase_control() const
4194 {
4195         return _phase_control;
4196 }
4197
4198 boost::shared_ptr<AutomationControl>
4199 Route::get_control (const Evoral::Parameter& param)
4200 {
4201         /* either we own the control or .... */
4202
4203         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4204
4205         if (!c) {
4206
4207                 /* maybe one of our processors does or ... */
4208
4209                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4210                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4211                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4212                                 break;
4213                         }
4214                 }
4215         }
4216
4217         if (!c) {
4218
4219                 /* nobody does so we'll make a new one */
4220
4221                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4222                 add_control(c);
4223         }
4224
4225         return c;
4226 }
4227
4228 boost::shared_ptr<Processor>
4229 Route::nth_plugin (uint32_t n) const
4230 {
4231         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4232         ProcessorList::const_iterator i;
4233
4234         for (i = _processors.begin(); i != _processors.end(); ++i) {
4235                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4236                         if (n-- == 0) {
4237                                 return *i;
4238                         }
4239                 }
4240         }
4241
4242         return boost::shared_ptr<Processor> ();
4243 }
4244
4245 boost::shared_ptr<Processor>
4246 Route::nth_send (uint32_t n) const
4247 {
4248         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4249         ProcessorList::const_iterator i;
4250
4251         for (i = _processors.begin(); i != _processors.end(); ++i) {
4252                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4253
4254                         if ((*i)->name().find (_("Monitor")) == 0) {
4255                                 /* send to monitor section is not considered
4256                                    to be an accessible send.
4257                                 */
4258                                 continue;
4259                         }
4260
4261                         if (n-- == 0) {
4262                                 return *i;
4263                         }
4264                 }
4265         }
4266
4267         return boost::shared_ptr<Processor> ();
4268 }
4269
4270 bool
4271 Route::has_io_processor_named (const string& name)
4272 {
4273         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4274         ProcessorList::iterator i;
4275
4276         for (i = _processors.begin(); i != _processors.end(); ++i) {
4277                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4278                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4279                         if ((*i)->name() == name) {
4280                                 return true;
4281                         }
4282                 }
4283         }
4284
4285         return false;
4286 }
4287
4288 void
4289 Route::set_processor_positions ()
4290 {
4291         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4292
4293         bool had_amp = false;
4294         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4295                 (*i)->set_pre_fader (!had_amp);
4296                 if (*i == _amp) {
4297                         had_amp = true;
4298                 }
4299         }
4300 }
4301
4302 /** Called when there is a proposed change to the input port count */
4303 bool
4304 Route::input_port_count_changing (ChanCount to)
4305 {
4306         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4307         if (c.empty()) {
4308                 /* The processors cannot be configured with the new input arrangement, so
4309                    block the change.
4310                 */
4311                 return true;
4312         }
4313
4314         /* The change is ok */
4315         return false;
4316 }
4317
4318 /** Called when there is a proposed change to the output port count */
4319 bool
4320 Route::output_port_count_changing (ChanCount to)
4321 {
4322         if (_strict_io && !_in_configure_processors) {
4323                 return true;
4324         }
4325         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4326                 if (processor_out_streams.get(*t) > to.get(*t)) {
4327                         return true;
4328                 }
4329         }
4330         /* The change is ok */
4331         return false;
4332 }
4333
4334 list<string>
4335 Route::unknown_processors () const
4336 {
4337         list<string> p;
4338
4339         if (_session.get_disable_all_loaded_plugins ()) {
4340                 // Do not list "missing plugins" if they are explicitly disabled
4341                 return p;
4342         }
4343
4344         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4345         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4346                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4347                         p.push_back ((*i)->name ());
4348                 }
4349         }
4350
4351         return p;
4352 }
4353
4354
4355 framecnt_t
4356 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4357 {
4358         /* we assume that all our input ports feed all our output ports. its not
4359            universally true, but the alternative is way too corner-case to worry about.
4360         */
4361
4362         LatencyRange all_connections;
4363
4364         if (from.empty()) {
4365                 all_connections.min = 0;
4366                 all_connections.max = 0;
4367         } else {
4368                 all_connections.min = ~((pframes_t) 0);
4369                 all_connections.max = 0;
4370
4371                 /* iterate over all "from" ports and determine the latency range for all of their
4372                    connections to the "outside" (outside of this Route).
4373                 */
4374
4375                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4376
4377                         LatencyRange range;
4378
4379                         p->get_connected_latency_range (range, playback);
4380
4381                         all_connections.min = min (all_connections.min, range.min);
4382                         all_connections.max = max (all_connections.max, range.max);
4383                 }
4384         }
4385
4386         /* set the "from" port latencies to the max/min range of all their connections */
4387
4388         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4389                 p->set_private_latency_range (all_connections, playback);
4390         }
4391
4392         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4393
4394         all_connections.min += our_latency;
4395         all_connections.max += our_latency;
4396
4397         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4398                 p->set_private_latency_range (all_connections, playback);
4399         }
4400
4401         return all_connections.max;
4402 }
4403
4404 framecnt_t
4405 Route::set_private_port_latencies (bool playback) const
4406 {
4407         framecnt_t own_latency = 0;
4408
4409         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4410            OR LATENCY CALLBACK.
4411
4412            This is called (early) from the latency callback. It computes the REAL
4413            latency associated with each port and stores the result as the "private"
4414            latency of the port. A later call to Route::set_public_port_latencies()
4415            sets all ports to the same value to reflect the fact that we do latency
4416            compensation and so all signals are delayed by the same amount as they
4417            flow through ardour.
4418         */
4419
4420         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4421                 if ((*i)->active ()) {
4422                         own_latency += (*i)->signal_latency ();
4423                 }
4424         }
4425
4426         if (playback) {
4427                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4428                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4429         } else {
4430                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4431                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4432         }
4433 }
4434
4435 void
4436 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4437 {
4438         /* this is called to set the JACK-visible port latencies, which take
4439            latency compensation into account.
4440         */
4441
4442         LatencyRange range;
4443
4444         range.min = value;
4445         range.max = value;
4446
4447         {
4448                 const PortSet& ports (_input->ports());
4449                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4450                         p->set_public_latency_range (range, playback);
4451                 }
4452         }
4453
4454         {
4455                 const PortSet& ports (_output->ports());
4456                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4457                         p->set_public_latency_range (range, playback);
4458                 }
4459         }
4460 }
4461
4462 /** Put the invisible processors in the right place in _processors.
4463  *  Must be called with a writer lock on _processor_lock held.
4464  */
4465 #ifdef __clang__
4466 __attribute__((annotate("realtime")))
4467 #endif
4468 void
4469 Route::setup_invisible_processors ()
4470 {
4471 #ifndef NDEBUG
4472         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4473         assert (!lm.locked ());
4474 #endif
4475
4476         if (!_main_outs) {
4477                 /* too early to be doing this stuff */
4478                 return;
4479         }
4480
4481         /* we'll build this new list here and then use it
4482          *
4483          * TODO put the ProcessorList is on the stack for RT-safety.
4484          */
4485
4486         ProcessorList new_processors;
4487
4488         /* find visible processors */
4489
4490         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4491                 if ((*i)->display_to_user ()) {
4492                         new_processors.push_back (*i);
4493                 }
4494         }
4495
4496         /* find the amp */
4497
4498         ProcessorList::iterator amp = find (new_processors.begin(), new_processors.end(), _amp);
4499
4500         if (amp == new_processors.end ()) {
4501                 error << string_compose (_("Amp/Fader on Route '%1' went AWOL. Re-added."), name()) << endmsg;
4502                 new_processors.push_front (_amp);
4503                 amp = find (new_processors.begin(), new_processors.end(), _amp);
4504         }
4505
4506         /* and the processor after the amp */
4507
4508         ProcessorList::iterator after_amp = amp;
4509         ++after_amp;
4510
4511         /* METER */
4512
4513         if (_meter) {
4514                 switch (_meter_point) {
4515                 case MeterInput:
4516                         assert (!_meter->display_to_user ());
4517                         new_processors.push_front (_meter);
4518                         break;
4519                 case MeterPreFader:
4520                         assert (!_meter->display_to_user ());
4521                         new_processors.insert (amp, _meter);
4522                         break;
4523                 case MeterPostFader:
4524                         /* do nothing here */
4525                         break;
4526                 case MeterOutput:
4527                         /* do nothing here */
4528                         break;
4529                 case MeterCustom:
4530                         /* the meter is visible, so we don't touch it here */
4531                         break;
4532                 }
4533         }
4534
4535         /* MAIN OUTS */
4536
4537         assert (_main_outs);
4538         assert (!_main_outs->display_to_user ());
4539         new_processors.push_back (_main_outs);
4540
4541         /* iterator for the main outs */
4542
4543         ProcessorList::iterator main = new_processors.end();
4544         --main;
4545
4546         /* OUTPUT METERING */
4547
4548         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4549                 assert (!_meter->display_to_user ());
4550
4551                 /* add the processor just before or just after the main outs */
4552
4553                 ProcessorList::iterator meter_point = main;
4554
4555                 if (_meter_point == MeterOutput) {
4556                         ++meter_point;
4557                 }
4558                 new_processors.insert (meter_point, _meter);
4559         }
4560
4561         /* MONITOR SEND */
4562
4563         if (_monitor_send && !is_monitor ()) {
4564                 assert (!_monitor_send->display_to_user ());
4565                 switch (Config->get_listen_position ()) {
4566                 case PreFaderListen:
4567                         switch (Config->get_pfl_position ()) {
4568                         case PFLFromBeforeProcessors:
4569                                 new_processors.push_front (_monitor_send);
4570                                 break;
4571                         case PFLFromAfterProcessors:
4572                                 new_processors.insert (amp, _monitor_send);
4573                                 break;
4574                         }
4575                         _monitor_send->set_can_pan (false);
4576                         break;
4577                 case AfterFaderListen:
4578                         switch (Config->get_afl_position ()) {
4579                         case AFLFromBeforeProcessors:
4580                                 new_processors.insert (after_amp, _monitor_send);
4581                                 break;
4582                         case AFLFromAfterProcessors:
4583                                 new_processors.insert (new_processors.end(), _monitor_send);
4584                                 break;
4585                         }
4586                         _monitor_send->set_can_pan (true);
4587                         break;
4588                 }
4589         }
4590
4591 #if 0 // not used - just yet
4592         if (!is_master() && !is_monitor() && !is_auditioner()) {
4593                 new_processors.push_front (_delayline);
4594         }
4595 #endif
4596
4597         /* MONITOR CONTROL */
4598
4599         if (_monitor_control && is_monitor ()) {
4600                 assert (!_monitor_control->display_to_user ());
4601                 new_processors.insert (amp, _monitor_control);
4602         }
4603
4604         /* TRIM CONTROL */
4605
4606         if (_trim && _trim->active()) {
4607                 assert (!_trim->display_to_user ());
4608                 new_processors.push_front (_trim);
4609         }
4610
4611         /* INTERNAL RETURN */
4612
4613         /* doing this here means that any monitor control will come after
4614            the return and trim.
4615         */
4616
4617         if (_intreturn) {
4618                 assert (!_intreturn->display_to_user ());
4619                 new_processors.push_front (_intreturn);
4620         }
4621
4622         /* EXPORT PROCESSOR */
4623
4624         if (_capturing_processor) {
4625                 assert (!_capturing_processor->display_to_user ());
4626                 new_processors.push_front (_capturing_processor);
4627         }
4628
4629         _processors = new_processors;
4630
4631         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4632                 if (!(*i)->display_to_user () && !(*i)->enabled () && (*i) != _monitor_send) {
4633                         (*i)->enable (true);
4634                 }
4635         }
4636
4637         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4638         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4639                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4640         }
4641 }
4642
4643 void
4644 Route::unpan ()
4645 {
4646         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4647         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4648
4649         _pannable.reset ();
4650
4651         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4652                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4653                 if (d) {
4654                         d->unpan ();
4655                 }
4656         }
4657 }
4658
4659 /** If the meter point is `Custom', make a note of where the meter is.
4660  *  This is so that if the meter point is subsequently set to something else,
4661  *  and then back to custom, we can put the meter back where it was last time
4662  *  custom was enabled.
4663  *
4664  *  Must be called with the _processor_lock held.
4665  */
4666 void
4667 Route::maybe_note_meter_position ()
4668 {
4669         if (_meter_point != MeterCustom) {
4670                 return;
4671         }
4672
4673         _custom_meter_position_noted = true;
4674         /* custom meter points range from after trim to before panner/main_outs
4675          * this is a limitation by the current processor UI
4676          */
4677         bool seen_trim = false;
4678         _processor_after_last_custom_meter.reset();
4679         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4680                 if ((*i) == _trim) {
4681                         seen_trim = true;
4682                 }
4683                 if ((*i) == _main_outs) {
4684                         _processor_after_last_custom_meter = *i;
4685                         break;
4686                 }
4687                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4688                         if (!seen_trim) {
4689                                 _processor_after_last_custom_meter = _trim;
4690                         } else {
4691                                 ProcessorList::iterator j = i;
4692                                 ++j;
4693                                 assert(j != _processors.end ()); // main_outs should be before
4694                                 _processor_after_last_custom_meter = *j;
4695                         }
4696                         break;
4697                 }
4698         }
4699         assert(_processor_after_last_custom_meter.lock());
4700 }
4701
4702 boost::shared_ptr<Processor>
4703 Route::processor_by_id (PBD::ID id) const
4704 {
4705         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4706         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4707                 if ((*i)->id() == id) {
4708                         return *i;
4709                 }
4710         }
4711
4712         return boost::shared_ptr<Processor> ();
4713 }
4714
4715 /** @return the monitoring state, or in other words what data we are pushing
4716  *  into the route (data from the inputs, data from disk or silence)
4717  */
4718 MonitorState
4719 Route::monitoring_state () const
4720 {
4721         return MonitoringInput;
4722 }
4723
4724 /** @return what we should be metering; either the data coming from the input
4725  *  IO or the data that is flowing through the route.
4726  */
4727 MeterState
4728 Route::metering_state () const
4729 {
4730         return MeteringRoute;
4731 }
4732
4733 bool
4734 Route::has_external_redirects () const
4735 {
4736         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4737
4738                 /* ignore inactive processors and obviously ignore the main
4739                  * outs since everything has them and we don't care.
4740                  */
4741
4742                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4743                         return true;;
4744                 }
4745         }
4746
4747         return false;
4748 }
4749
4750 boost::shared_ptr<Processor>
4751 Route::the_instrument () const
4752 {
4753         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4754         return the_instrument_unlocked ();
4755 }
4756
4757 boost::shared_ptr<Processor>
4758 Route::the_instrument_unlocked () const
4759 {
4760         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4761                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
4762                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
4763                         return (*i);
4764                 }
4765         }
4766         return boost::shared_ptr<Processor>();
4767 }
4768
4769
4770
4771 void
4772 Route::non_realtime_locate (framepos_t pos)
4773 {
4774         if (_pannable) {
4775                 _pannable->transport_located (pos);
4776         }
4777
4778         if (_delayline.get()) {
4779                 _delayline.get()->flush();
4780         }
4781
4782         {
4783                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4784                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4785
4786                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4787                         (*i)->transport_located (pos);
4788                 }
4789         }
4790         _roll_delay = _initial_delay;
4791 }
4792
4793 void
4794 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4795 {
4796         size_t n_buffers;
4797         size_t i;
4798
4799         /* MIDI
4800          *
4801          * We don't currently mix MIDI input together, so we don't need the
4802          * complex logic of the audio case.
4803          */
4804
4805         n_buffers = bufs.count().n_midi ();
4806
4807         for (i = 0; i < n_buffers; ++i) {
4808
4809                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4810                 MidiBuffer& buf (bufs.get_midi (i));
4811
4812                 if (source_port) {
4813                         buf.copy (source_port->get_midi_buffer(nframes));
4814                 } else {
4815                         buf.silence (nframes);
4816                 }
4817         }
4818
4819         /* AUDIO */
4820
4821         n_buffers = bufs.count().n_audio();
4822
4823         size_t n_ports = io->n_ports().n_audio();
4824         float scaling = 1.0f;
4825
4826         if (n_ports > n_buffers) {
4827                 scaling = ((float) n_buffers) / n_ports;
4828         }
4829
4830         for (i = 0; i < n_ports; ++i) {
4831
4832                 /* if there are more ports than buffers, map them onto buffers
4833                  * in a round-robin fashion
4834                  */
4835
4836                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4837                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4838
4839
4840                 if (i < n_buffers) {
4841
4842                         /* first time through just copy a channel into
4843                            the output buffer.
4844                         */
4845
4846                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4847
4848                         if (scaling != 1.0f) {
4849                                 buf.apply_gain (scaling, nframes);
4850                         }
4851
4852                 } else {
4853
4854                         /* on subsequent times around, merge data from
4855                          * the port with what is already there
4856                          */
4857
4858                         if (scaling != 1.0f) {
4859                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4860                         } else {
4861                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4862                         }
4863                 }
4864         }
4865
4866         /* silence any remaining buffers */
4867
4868         for (; i < n_buffers; ++i) {
4869                 AudioBuffer& buf (bufs.get_audio (i));
4870                 buf.silence (nframes);
4871         }
4872
4873         /* establish the initial setup of the buffer set, reflecting what was
4874            copied into it. unless, of course, we are the auditioner, in which
4875            case nothing was fed into it from the inputs at all.
4876         */
4877
4878         if (!is_auditioner()) {
4879                 bufs.set_count (io->n_ports());
4880         }
4881 }
4882
4883 boost::shared_ptr<AutomationControl>
4884 Route::pan_azimuth_control() const
4885 {
4886 #ifdef MIXBUS
4887 # undef MIXBUS_PORTS_H
4888 # include "../../gtk2_ardour/mixbus_ports.h"
4889         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
4890         if (!plug) {
4891                 return boost::shared_ptr<AutomationControl>();
4892         }
4893         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
4894 #else
4895         if (!_pannable || !panner()) {
4896                 return boost::shared_ptr<AutomationControl>();
4897         }
4898         return _pannable->pan_azimuth_control;
4899 #endif
4900 }
4901
4902 boost::shared_ptr<AutomationControl>
4903 Route::pan_elevation_control() const
4904 {
4905         if (Profile->get_mixbus() || !_pannable || !panner()) {
4906                 return boost::shared_ptr<AutomationControl>();
4907         }
4908
4909         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4910
4911         if (c.find (PanElevationAutomation) != c.end()) {
4912                 return _pannable->pan_elevation_control;
4913         } else {
4914                 return boost::shared_ptr<AutomationControl>();
4915         }
4916 }
4917 boost::shared_ptr<AutomationControl>
4918 Route::pan_width_control() const
4919 {
4920 #ifdef MIXBUS
4921         if (mixbus() && _ch_pre) {
4922                 //mono blend
4923                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 5)));
4924         }
4925 #endif
4926         if (Profile->get_mixbus() || !_pannable || !panner()) {
4927                 return boost::shared_ptr<AutomationControl>();
4928         }
4929
4930         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4931
4932         if (c.find (PanWidthAutomation) != c.end()) {
4933                 return _pannable->pan_width_control;
4934         } else {
4935                 return boost::shared_ptr<AutomationControl>();
4936         }
4937 }
4938 boost::shared_ptr<AutomationControl>
4939 Route::pan_frontback_control() const
4940 {
4941         if (Profile->get_mixbus() || !_pannable || !panner()) {
4942                 return boost::shared_ptr<AutomationControl>();
4943         }
4944
4945         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4946
4947         if (c.find (PanFrontBackAutomation) != c.end()) {
4948                 return _pannable->pan_frontback_control;
4949         } else {
4950                 return boost::shared_ptr<AutomationControl>();
4951         }
4952 }
4953 boost::shared_ptr<AutomationControl>
4954 Route::pan_lfe_control() const
4955 {
4956         if (Profile->get_mixbus() || !_pannable || !panner()) {
4957                 return boost::shared_ptr<AutomationControl>();
4958         }
4959
4960         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4961
4962         if (c.find (PanLFEAutomation) != c.end()) {
4963                 return _pannable->pan_lfe_control;
4964         } else {
4965                 return boost::shared_ptr<AutomationControl>();
4966         }
4967 }
4968
4969 uint32_t
4970 Route::eq_band_cnt () const
4971 {
4972         if (Profile->get_mixbus()) {
4973 #ifdef MIXBUS32C
4974                 if (is_master() || mixbus()) {
4975                         return 3;
4976                 } else {
4977                         return 4;
4978                 }
4979 #else
4980                 return 3;
4981 #endif
4982         } else {
4983                 /* Ardour has no well-known EQ object */
4984                 return 0;
4985         }
4986 }
4987
4988 boost::shared_ptr<AutomationControl>
4989 Route::eq_gain_controllable (uint32_t band) const
4990 {
4991 #ifdef MIXBUS
4992         boost::shared_ptr<PluginInsert> eq = ch_eq();
4993
4994         if (!eq) {
4995                 return boost::shared_ptr<AutomationControl>();
4996         }
4997
4998         uint32_t port_number;
4999         if (is_master() || mixbus()) {
5000                 switch (band) {
5001                         case 0: port_number = 4; break;
5002                         case 1: port_number = 3; break;
5003                         case 2: port_number = 2; break;
5004                         default:
5005                                 return boost::shared_ptr<AutomationControl>();
5006                 }
5007         } else {
5008 #ifdef MIXBUS32C
5009                 switch (band) {
5010                         case 0: port_number = 14; break;
5011                         case 1: port_number = 12; break;
5012                         case 2: port_number = 10; break;
5013                         case 3: port_number =  8; break;
5014                         default:
5015                                 return boost::shared_ptr<AutomationControl>();
5016                 }
5017 #else
5018                 switch (band) {
5019                         case 0: port_number = 8; break;
5020                         case 1: port_number = 6; break;
5021                         case 2: port_number = 4; break;
5022                         default:
5023                                 return boost::shared_ptr<AutomationControl>();
5024                 }
5025 #endif
5026         }
5027
5028         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5029 #else
5030         return boost::shared_ptr<AutomationControl>();
5031 #endif
5032 }
5033 boost::shared_ptr<AutomationControl>
5034 Route::eq_freq_controllable (uint32_t band) const
5035 {
5036 #ifdef MIXBUS
5037         if (mixbus() || is_master()) {
5038                 /* no frequency controls for mixbusses or master */
5039                 return boost::shared_ptr<AutomationControl>();
5040         }
5041
5042         boost::shared_ptr<PluginInsert> eq = ch_eq();
5043
5044         if (!eq) {
5045                 return boost::shared_ptr<AutomationControl>();
5046         }
5047
5048         uint32_t port_number;
5049 #ifdef MIXBUS32C
5050         switch (band) {
5051                 case 0: port_number = 13; break; // lo
5052                 case 1: port_number = 11; break; // lo mid
5053                 case 2: port_number = 9; break; // hi mid
5054                 case 3: port_number = 7; break; // hi
5055                 default:
5056                         return boost::shared_ptr<AutomationControl>();
5057         }
5058 #else
5059         switch (band) {
5060                 case 0: port_number = 7; break;
5061                 case 1: port_number = 5; break;
5062                 case 2: port_number = 3; break;
5063                 default:
5064                         return boost::shared_ptr<AutomationControl>();
5065         }
5066 #endif
5067
5068         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5069 #else
5070         return boost::shared_ptr<AutomationControl>();
5071 #endif
5072 }
5073
5074 boost::shared_ptr<AutomationControl>
5075 Route::eq_q_controllable (uint32_t band) const
5076 {
5077         return boost::shared_ptr<AutomationControl>();
5078 }
5079
5080 boost::shared_ptr<AutomationControl>
5081 Route::eq_shape_controllable (uint32_t band) const
5082 {
5083 #ifdef MIXBUS32C
5084         boost::shared_ptr<PluginInsert> eq = ch_eq();
5085         if (is_master() || mixbus() || !eq) {
5086                 return boost::shared_ptr<AutomationControl>();
5087         }
5088         switch (band) {
5089                 case 0:
5090                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4))); // lo bell
5091                         break;
5092                 case 3:
5093                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3))); // hi bell
5094                         break;
5095                 default:
5096                         break;
5097         }
5098 #endif
5099         return boost::shared_ptr<AutomationControl>();
5100 }
5101
5102 boost::shared_ptr<AutomationControl>
5103 Route::eq_enable_controllable () const
5104 {
5105 #ifdef MIXBUS
5106         boost::shared_ptr<PluginInsert> eq = ch_eq();
5107
5108         if (!eq) {
5109                 return boost::shared_ptr<AutomationControl>();
5110         }
5111
5112         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5113 #else
5114         return boost::shared_ptr<AutomationControl>();
5115 #endif
5116 }
5117
5118 boost::shared_ptr<AutomationControl>
5119 Route::filter_freq_controllable (bool hpf) const
5120 {
5121 #ifdef MIXBUS
5122         boost::shared_ptr<PluginInsert> eq = ch_eq();
5123
5124         if (is_master() || mixbus() || !eq) {
5125                 return boost::shared_ptr<AutomationControl>();
5126         }
5127         if (hpf) {
5128 #ifdef MIXBUS32C
5129                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5))); // HPF freq
5130 #else
5131                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5132 #endif
5133         } else {
5134 #ifdef MIXBUS32C
5135                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6))); // LPF freq
5136 #else
5137                 return boost::shared_ptr<AutomationControl>();
5138 #endif
5139         }
5140
5141 #else
5142         return boost::shared_ptr<AutomationControl>();
5143 #endif
5144 }
5145
5146 boost::shared_ptr<AutomationControl>
5147 Route::filter_slope_controllable (bool) const
5148 {
5149         return boost::shared_ptr<AutomationControl>();
5150 }
5151
5152 boost::shared_ptr<AutomationControl>
5153 Route::filter_enable_controllable (bool) const
5154 {
5155 #ifdef MIXBUS32C
5156         boost::shared_ptr<PluginInsert> eq = ch_eq();
5157
5158         if (is_master() || mixbus() || !eq) {
5159                 return boost::shared_ptr<AutomationControl>();
5160         }
5161
5162         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5163 #else
5164         return boost::shared_ptr<AutomationControl>();
5165 #endif
5166 }
5167
5168 string
5169 Route::eq_band_name (uint32_t band) const
5170 {
5171 #ifdef MIXBUS32C
5172         if (is_master() || mixbus()) {
5173 #endif
5174         if (Profile->get_mixbus()) {
5175                 switch (band) {
5176                         case 0: return _("lo");
5177                         case 1: return _("mid");
5178                         case 2: return _("hi");
5179                         default: return string();
5180                 }
5181         } else {
5182                 return string ();
5183         }
5184 #ifdef MIXBUS32C
5185         } else {
5186                 switch (band) {
5187                         case 0: return _("lo");
5188                         case 1: return _("lo mid");
5189                         case 2: return _("hi mid");
5190                         case 3: return _("hi");
5191                         default: return string();
5192                 }
5193         }
5194 #endif
5195 }
5196
5197 boost::shared_ptr<AutomationControl>
5198 Route::comp_enable_controllable () const
5199 {
5200 #ifdef MIXBUS
5201         boost::shared_ptr<PluginInsert> comp = ch_comp();
5202
5203         if (!comp) {
5204                 return boost::shared_ptr<AutomationControl>();
5205         }
5206
5207         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5208 #else
5209         return boost::shared_ptr<AutomationControl>();
5210 #endif
5211 }
5212 boost::shared_ptr<AutomationControl>
5213 Route::comp_threshold_controllable () const
5214 {
5215 #ifdef MIXBUS
5216         boost::shared_ptr<PluginInsert> comp = ch_comp();
5217
5218         if (!comp) {
5219                 return boost::shared_ptr<AutomationControl>();
5220         }
5221
5222         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5223
5224 #else
5225         return boost::shared_ptr<AutomationControl>();
5226 #endif
5227 }
5228 boost::shared_ptr<AutomationControl>
5229 Route::comp_speed_controllable () const
5230 {
5231 #ifdef MIXBUS
5232         boost::shared_ptr<PluginInsert> comp = ch_comp();
5233
5234         if (!comp) {
5235                 return boost::shared_ptr<AutomationControl>();
5236         }
5237
5238         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5239 #else
5240         return boost::shared_ptr<AutomationControl>();
5241 #endif
5242 }
5243 boost::shared_ptr<AutomationControl>
5244 Route::comp_mode_controllable () const
5245 {
5246 #ifdef MIXBUS
5247         boost::shared_ptr<PluginInsert> comp = ch_comp();
5248
5249         if (!comp) {
5250                 return boost::shared_ptr<AutomationControl>();
5251         }
5252
5253         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5254 #else
5255         return boost::shared_ptr<AutomationControl>();
5256 #endif
5257 }
5258 boost::shared_ptr<AutomationControl>
5259 Route::comp_makeup_controllable () const
5260 {
5261 #ifdef MIXBUS
5262         boost::shared_ptr<PluginInsert> comp = ch_comp();
5263
5264         if (!comp) {
5265                 return boost::shared_ptr<AutomationControl>();
5266         }
5267
5268         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5269 #else
5270         return boost::shared_ptr<AutomationControl>();
5271 #endif
5272 }
5273 boost::shared_ptr<ReadOnlyControl>
5274 Route::comp_redux_controllable () const
5275 {
5276 #ifdef MIXBUS
5277         boost::shared_ptr<PluginInsert> comp = ch_comp();
5278
5279         if (!comp) {
5280                 return boost::shared_ptr<ReadOnlyControl>();
5281         }
5282         if (is_master()) {
5283                 return comp->control_output (2);
5284         } else {
5285                 return comp->control_output (6);
5286         }
5287
5288 #else
5289         return boost::shared_ptr<ReadOnlyControl>();
5290 #endif
5291 }
5292
5293 string
5294 Route::comp_mode_name (uint32_t mode) const
5295 {
5296 #ifdef MIXBUS
5297         switch (mode) {
5298         case 0:
5299                 return _("Leveler");
5300         case 1:
5301                 return _("Compressor");
5302         case 2:
5303                 return _("Limiter");
5304         case 3:
5305                 return mixbus() ? _("Sidechain") : _("Limiter");
5306         }
5307
5308         return _("???");
5309 #else
5310         return _("???");
5311 #endif
5312 }
5313
5314 string
5315 Route::comp_speed_name (uint32_t mode) const
5316 {
5317 #ifdef MIXBUS
5318         switch (mode) {
5319         case 0:
5320                 return _("Attk");
5321         case 1:
5322                 return _("Ratio");
5323         case 2:
5324         case 3:
5325                 return _("Rels");
5326         }
5327         return _("???");
5328 #else
5329         return _("???");
5330 #endif
5331 }
5332
5333 boost::shared_ptr<AutomationControl>
5334 Route::send_level_controllable (uint32_t n) const
5335 {
5336 #ifdef  MIXBUS
5337 # undef MIXBUS_PORTS_H
5338 # include "../../gtk2_ardour/mixbus_ports.h"
5339         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5340         if (plug) {
5341                 uint32_t port_id = 0;
5342                 switch (n) {
5343                         case  0: port_id = port_channel_post_aux1_level; break;
5344                         case  1: port_id = port_channel_post_aux2_level; break;
5345                         case  2: port_id = port_channel_post_aux3_level; break;
5346                         case  3: port_id = port_channel_post_aux4_level; break;
5347                         case  4: port_id = port_channel_post_aux5_level; break;
5348                         case  5: port_id = port_channel_post_aux6_level; break;
5349                         case  6: port_id = port_channel_post_aux7_level; break;
5350                         case  7: port_id = port_channel_post_aux8_level; break;
5351 # ifdef MIXBUS32C
5352                         case  8: port_id = port_channel_post_aux9_level; break;
5353                         case  9: port_id = port_channel_post_aux10_level; break;
5354                         case 10: port_id = port_channel_post_aux11_level; break;
5355                         case 11: port_id = port_channel_post_aux12_level; break;
5356 # endif
5357                         default:
5358                                 break;
5359                 }
5360
5361                 if (port_id > 0) {
5362                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5363                 }
5364 # ifdef MIXBUS32C
5365                 assert (n > 11);
5366                 n -= 12;
5367 # else
5368                 assert (n > 7);
5369                 n -= 8;
5370 # endif
5371         }
5372 #endif
5373         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5374         if (!s) {
5375                 return boost::shared_ptr<AutomationControl>();
5376         }
5377         return s->gain_control ();
5378 }
5379
5380 boost::shared_ptr<AutomationControl>
5381 Route::send_enable_controllable (uint32_t n) const
5382 {
5383 #ifdef  MIXBUS
5384 # undef MIXBUS_PORTS_H
5385 # include "../../gtk2_ardour/mixbus_ports.h"
5386         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5387         if (plug) {
5388                 uint32_t port_id = 0;
5389                 switch (n) {
5390                         case  0: port_id = port_channel_post_aux1_asgn; break;
5391                         case  1: port_id = port_channel_post_aux2_asgn; break;
5392                         case  2: port_id = port_channel_post_aux3_asgn; break;
5393                         case  3: port_id = port_channel_post_aux4_asgn; break;
5394                         case  4: port_id = port_channel_post_aux5_asgn; break;
5395                         case  5: port_id = port_channel_post_aux6_asgn; break;
5396                         case  6: port_id = port_channel_post_aux7_asgn; break;
5397                         case  7: port_id = port_channel_post_aux8_asgn; break;
5398 # ifdef MIXBUS32C
5399                         case  8: port_id = port_channel_post_aux9_asgn; break;
5400                         case  9: port_id = port_channel_post_aux10_asgn; break;
5401                         case 10: port_id = port_channel_post_aux11_asgn; break;
5402                         case 11: port_id = port_channel_post_aux12_asgn; break;
5403 # endif
5404                         default:
5405                                 break;
5406                 }
5407
5408                 if (port_id > 0) {
5409                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5410                 }
5411 # ifdef MIXBUS32C
5412                 assert (n > 11);
5413                 n -= 12;
5414 # else
5415                 assert (n > 7);
5416                 n -= 8;
5417 # endif
5418         }
5419 #endif
5420         /* although Ardour sends have enable/disable as part of the Processor
5421          * API, it is not exposed as a controllable.
5422          *
5423          * XXX: we should fix this (make it click-free, automatable enable-control)
5424          */
5425         return boost::shared_ptr<AutomationControl>();
5426 }
5427
5428 string
5429 Route::send_name (uint32_t n) const
5430 {
5431 #ifdef MIXBUS
5432 # ifdef MIXBUS32C
5433         if (n < 12) {
5434                 return _session.get_mixbus (n)->name();
5435         }
5436         n -= 12;
5437 #else
5438         if (n < 8) {
5439                 return _session.get_mixbus (n)->name();
5440         }
5441         n -= 8;
5442 # endif
5443 #endif
5444         boost::shared_ptr<Processor> p = nth_send (n);
5445         if (p) {
5446                 return p->name();
5447         } else {
5448                 return string();
5449         }
5450 }
5451
5452 boost::shared_ptr<AutomationControl>
5453 Route::master_send_enable_controllable () const
5454 {
5455 #ifdef  MIXBUS
5456         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5457         if (!plug) {
5458                 return boost::shared_ptr<AutomationControl>();
5459         }
5460 # undef MIXBUS_PORTS_H
5461 # include "../../gtk2_ardour/mixbus_ports.h"
5462         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5463 #else
5464         return boost::shared_ptr<AutomationControl>();
5465 #endif
5466 }
5467
5468 bool
5469 Route::slaved () const
5470 {
5471         if (!_gain_control) {
5472                 return false;
5473         }
5474         /* just test one particular control, not all of them */
5475         return _gain_control->slaved ();
5476 }
5477
5478 bool
5479 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5480 {
5481         if (!vca || !_gain_control) {
5482                 return false;
5483         }
5484
5485         /* just test one particular control, not all of them */
5486
5487         return _gain_control->slaved_to (vca->gain_control());
5488 }
5489
5490 bool
5491 Route::muted_by_others_soloing () const
5492 {
5493         if (!can_be_muted_by_others ()) {
5494                 return false;
5495         }
5496
5497         return  _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5498 }
5499
5500 void
5501 Route::clear_all_solo_state ()
5502 {
5503         _solo_control->clear_all_solo_state ();
5504 }
5505
5506 boost::shared_ptr<AutomationControl>
5507 Route::automation_control_recurse (PBD::ID const & id) const
5508 {
5509         boost::shared_ptr<AutomationControl> ac = Automatable::automation_control (id);
5510
5511         if (ac) {
5512                 return ac;
5513         }
5514
5515         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5516
5517         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5518                 if ((ac = (*i)->automation_control (id))) {
5519                         return ac;
5520                 }
5521         }
5522
5523         return boost::shared_ptr<AutomationControl> ();
5524 }
5525
5526 SlavableControlList
5527 Route::slavables () const
5528 {
5529         SlavableControlList rv;
5530         rv.push_back (_gain_control);
5531         rv.push_back (_mute_control);
5532         rv.push_back (_solo_control);
5533         return rv;
5534 }