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         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 (others.empty()) {
 930                 return 0;
 931         }
 932
 933         ProcessorList to_skip;
 934
 935         // check if there's an instrument to replace or configure
 936         for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 937                 boost::shared_ptr<PluginInsert> pi;
 938                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) == 0) {
 939                         continue;
 940                 }
 941                 if (!pi->plugin ()->get_info ()->is_instrument ()) {
 942                         continue;
 943                 }
 944                 boost::shared_ptr<Processor> instrument = the_instrument ();
 945                 ChanCount in (DataType::MIDI, 1);
 946                 ChanCount out (DataType::AUDIO, 2); // XXX route's out?!
 947
 948                 PluginSetupOptions flags = None;
 949                 if (instrument) {
 950                         flags |= CanReplace;
 951                         in = instrument->input_streams ();
 952                         out = instrument->output_streams ();
 953                 }
 954                 if (pi->has_output_presets (in, out)) {
 955                         flags |= MultiOut;
 956                 }
 957
 958                 pi->set_strict_io (_strict_io);
 959
 960                 PluginSetupOptions mask = None;
 961                 if (Config->get_ask_replace_instrument ()) {
 962                         mask |= CanReplace;
 963                 }
 964                 if (Config->get_ask_setup_instrument ()) {
 965                         mask |= MultiOut;
 966                 }
 967
 968                 flags &= mask;
 969
 970                 if (flags != None) {
 971                         boost::optional<int> rv = PluginSetup (boost::dynamic_pointer_cast<Route>(shared_from_this ()), pi, flags);  /* EMIT SIGNAL */
 972                         int mode = rv.get_value_or (0);
 973                         switch (mode & 3) {
 974                                 case 1:
 975                                         to_skip.push_back (*i); // don't add this one;
 976                                         break;
 977                                 case 2:
 978                                         replace_processor (instrument, *i, err);
 979                                         to_skip.push_back (*i);
 980                                         break;
 981                                 default:
 982                                         break;
 983                         }
 984                         if ((mode & 5) == 4) {
 985                                 fanout = pi;
 986                         }
 987                 }
 988         }
 989
 990         {
 991                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 992                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 993                 ProcessorState pstate (this);
 994
 995                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
 996
 997                         if (*i == _meter) {
 998                                 continue;
 999                         }
1000                         ProcessorList::iterator check = find (to_skip.begin(), to_skip.end(), *i);
1001                         if (check != to_skip.end()) {
1002                                 continue;
1003                         }
1004
1005                         boost::shared_ptr<PluginInsert> pi;
1006
1007                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1008                                 pi->set_strict_io (_strict_io);
1009                         }
1010
1011                         if (*i == _amp) {
1012                                 /* Ensure that only one amp is in the list at any time */
1013                                 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), *i);
1014                                 if (check != _processors.end()) {
1015                                         if (before == _amp) {
1016                                                 /* Already in position; all is well */
1017                                                 continue;
1018                                         } else {
1019                                                 _processors.erase (check);
1020                                         }
1021                                 }
1022                         }
1023
1024                         assert (find (_processors.begin(), _processors.end(), *i) == _processors.end ());
1025
1026                         _processors.insert (loc, *i);
1027                         (*i)->set_owner (this);
1028
1029                         {
1030                                 if (configure_processors_unlocked (err, &lm)) {
1031                                         pstate.restore ();
1032                                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
1033                                         return -1;
1034                                 }
1035                         }
1036
1037                         if (pi && pi->has_sidechain ()) {
1038                                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
1039                         }
1040
1041                         if ((*i)->active()) {
1042                                 // emit ActiveChanged() and latency_changed() if needed
1043                                 (*i)->activate ();
1044                         }
1045
1046                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1047
1048                         boost::shared_ptr<Send> send;
1049                         if ((send = boost::dynamic_pointer_cast<Send> (*i))) {
1050                                 send->SelfDestruct.connect_same_thread (*this,
1051                                                 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (*i)));
1052                         }
1053                 }
1054
1055                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1056                         boost::shared_ptr<PluginInsert> pi;
1057
1058                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1059                                 if (pi->has_no_inputs ()) {
1060                                         _have_internal_generator = true;
1061                                         break;
1062                                 }
1063                         }
1064                 }
1065
1066                 _output->set_user_latency (0);
1067         }
1068
1069         reset_instrument_info ();
1070         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1071         set_processor_positions ();
1072
1073         if (fanout && fanout->configured ()
1074                         && fanout->output_streams().n_audio() > 2
1075                         && boost::dynamic_pointer_cast<PluginInsert> (the_instrument ()) == fanout) {
1076                 fan_out (); /* EMIT SIGNAL */
1077         }
1078         return 0;
1079 }
1080
1081 void
1082 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1083 {
1084         if (p == PreFader) {
1085                 start = _processors.begin();
1086                 end = find(_processors.begin(), _processors.end(), _amp);
1087         } else {
1088                 start = find(_processors.begin(), _processors.end(), _amp);
1089                 ++start;
1090                 end = _processors.end();
1091         }
1092 }
1093
1094 /** Turn off all processors with a given placement
1095  * @param p Placement of processors to disable
1096  */
1097 void
1098 Route::disable_processors (Placement p)
1099 {
1100         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1101
1102         ProcessorList::iterator start, end;
1103         placement_range(p, start, end);
1104
1105         for (ProcessorList::iterator i = start; i != end; ++i) {
1106                 (*i)->enable (false);
1107         }
1108
1109         _session.set_dirty ();
1110 }
1111
1112 /** Turn off all redirects
1113  */
1114 void
1115 Route::disable_processors ()
1116 {
1117         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1118
1119         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1120                 (*i)->enable (false);
1121         }
1122
1123         _session.set_dirty ();
1124 }
1125
1126 /** Turn off all redirects with a given placement
1127  * @param p Placement of redirects to disable
1128  */
1129 void
1130 Route::disable_plugins (Placement p)
1131 {
1132         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1133
1134         ProcessorList::iterator start, end;
1135         placement_range(p, start, end);
1136
1137         for (ProcessorList::iterator i = start; i != end; ++i) {
1138                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1139                         (*i)->enable (false);
1140                 }
1141         }
1142
1143         _session.set_dirty ();
1144 }
1145
1146 /** Turn off all plugins
1147  */
1148 void
1149 Route::disable_plugins ()
1150 {
1151         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1152
1153         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1154                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1155                         (*i)->enable (false);
1156                 }
1157         }
1158
1159         _session.set_dirty ();
1160 }
1161
1162
1163 void
1164 Route::ab_plugins (bool forward)
1165 {
1166         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1167
1168         if (forward) {
1169
1170                 /* forward = turn off all active redirects, and mark them so that the next time
1171                    we go the other way, we will revert them
1172                 */
1173
1174                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1175                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1176                                 continue;
1177                         }
1178                         if (!(*i)->display_to_user ()) {
1179                                 continue;
1180                         }
1181 #ifdef MIXBUS
1182                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1183                                 continue;
1184                         }
1185 #endif
1186
1187                         if ((*i)->enabled ()) {
1188                                 (*i)->enable (false);
1189                                 (*i)->set_next_ab_is_active (true);
1190                         } else {
1191                                 (*i)->set_next_ab_is_active (false);
1192                         }
1193                 }
1194
1195         } else {
1196
1197                 /* backward = if the redirect was marked to go active on the next ab, do so */
1198
1199                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1200                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1201                                 continue;
1202                         }
1203                         if (!(*i)->display_to_user ()) {
1204                                 continue;
1205                         }
1206 #ifdef MIXBUS
1207                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1208                                 continue;
1209                         }
1210 #endif
1211
1212                         (*i)->enable ((*i)->get_next_ab_is_active ());
1213                 }
1214         }
1215
1216         _session.set_dirty ();
1217 }
1218
1219
1220 /** Remove processors with a given placement.
1221  * @param p Placement of processors to remove.
1222  */
1223 void
1224 Route::clear_processors (Placement p)
1225 {
1226         if (!_session.engine().connected()) {
1227                 return;
1228         }
1229
1230         bool already_deleting = _session.deletion_in_progress();
1231         if (!already_deleting) {
1232                 _session.set_deletion_in_progress();
1233         }
1234
1235         ProcessorList old_list = _processors;
1236         {
1237                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1238                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1239                 ProcessorList new_list;
1240                 ProcessorStreams err;
1241                 bool seen_amp = false;
1242
1243                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1244
1245                         if (*i == _amp) {
1246                                 seen_amp = true;
1247                         }
1248
1249                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1250
1251                                 /* you can't remove these */
1252
1253                                 new_list.push_back (*i);
1254
1255                         } else {
1256                                 if (seen_amp) {
1257
1258                                         switch (p) {
1259                                         case PreFader:
1260                                                 new_list.push_back (*i);
1261                                                 break;
1262                                         case PostFader:
1263                                                 (*i)->drop_references ();
1264                                                 break;
1265                                         }
1266
1267                                 } else {
1268
1269                                         switch (p) {
1270                                         case PreFader:
1271                                                 (*i)->drop_references ();
1272                                                 break;
1273                                         case PostFader:
1274                                                 new_list.push_back (*i);
1275                                                 break;
1276                                         }
1277                                 }
1278                         }
1279                 }
1280
1281                 _processors = new_list;
1282                 configure_processors_unlocked (&err, &lm); // this can't fail
1283         }
1284         /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
1285         old_list.clear ();
1286
1287         processor_max_streams.reset();
1288         _have_internal_generator = false;
1289         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1290         set_processor_positions ();
1291
1292         reset_instrument_info ();
1293
1294         if (!already_deleting) {
1295                 _session.clear_deletion_in_progress();
1296         }
1297 }
1298
1299 int
1300 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1301 {
1302         // TODO once the export point can be configured properly, do something smarter here
1303         if (processor == _capturing_processor) {
1304                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1305                 if (need_process_lock) {
1306                         lx.acquire();
1307                 }
1308
1309                 _capturing_processor.reset();
1310
1311                 if (need_process_lock) {
1312                         lx.release();
1313                 }
1314         }
1315
1316         /* these can never be removed */
1317
1318         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1319                 return 0;
1320         }
1321
1322         if (!_session.engine().connected()) {
1323                 return 1;
1324         }
1325
1326         processor_max_streams.reset();
1327
1328         {
1329                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1330                 if (need_process_lock) {
1331                         lx.acquire();
1332                 }
1333
1334                 /* Caller must hold process lock */
1335                 assert (!AudioEngine::instance()->process_lock().trylock());
1336
1337                 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1338
1339                 ProcessorState pstate (this);
1340
1341                 ProcessorList::iterator i;
1342                 bool removed = false;
1343
1344                 for (i = _processors.begin(); i != _processors.end(); ) {
1345                         if (*i == processor) {
1346
1347                                 /* move along, see failure case for configure_processors()
1348                                    where we may need to reconfigure the processor.
1349                                 */
1350
1351                                 /* stop redirects that send signals to JACK ports
1352                                    from causing noise as a result of no longer being
1353                                    run.
1354                                 */
1355
1356                                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1357                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
1358
1359                                 if (pi != 0) {
1360                                         assert (iop == 0);
1361                                         iop = pi->sidechain();
1362                                 }
1363
1364                                 if (iop != 0) {
1365                                         iop->disconnect ();
1366                                 }
1367
1368                                 i = _processors.erase (i);
1369                                 removed = true;
1370                                 break;
1371
1372                         } else {
1373                                 ++i;
1374                         }
1375
1376                         _output->set_user_latency (0);
1377                 }
1378
1379                 if (!removed) {
1380                         /* what? */
1381                         return 1;
1382                 }
1383
1384                 if (configure_processors_unlocked (err, &lm)) {
1385                         pstate.restore ();
1386                         /* we know this will work, because it worked before :) */
1387                         configure_processors_unlocked (0, &lm);
1388                         return -1;
1389                 }
1390
1391                 _have_internal_generator = false;
1392
1393                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1394                         boost::shared_ptr<PluginInsert> pi;
1395
1396                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1397                                 if (pi->has_no_inputs ()) {
1398                                         _have_internal_generator = true;
1399                                         break;
1400                                 }
1401                         }
1402                 }
1403                 if (need_process_lock) {
1404                         lx.release();
1405                 }
1406         }
1407
1408         reset_instrument_info ();
1409         processor->drop_references ();
1410         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1411         set_processor_positions ();
1412
1413         return 0;
1414 }
1415
1416 int
1417 Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
1418 {
1419         /* these can never be removed */
1420         if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
1421                 return 1;
1422         }
1423         /* and can't be used as substitute, either */
1424         if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
1425                 return 1;
1426         }
1427
1428         /* I/Os are out, too */
1429         if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
1430                 return 1;
1431         }
1432
1433         /* this function cannot be used to swap/reorder processors */
1434         if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
1435                 return 1;
1436         }
1437
1438         if (!AudioEngine::instance()->connected() || !old || !sub) {
1439                 return 1;
1440         }
1441
1442         /* ensure that sub is not owned by another route */
1443         if (sub->owner ()) {
1444                 return 1;
1445         }
1446
1447         {
1448                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1449                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1450                 ProcessorState pstate (this);
1451
1452                 assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
1453
1454                 ProcessorList::iterator i;
1455                 bool replaced = false;
1456                 bool enable = old->enabled ();
1457
1458                 for (i = _processors.begin(); i != _processors.end(); ) {
1459                         if (*i == old) {
1460                                 i = _processors.erase (i);
1461                                 _processors.insert (i, sub);
1462                                 sub->set_owner (this);
1463                                 replaced = true;
1464                                 break;
1465                         } else {
1466                                 ++i;
1467                         }
1468                 }
1469
1470                 if (!replaced) {
1471                         return 1;
1472                 }
1473
1474                 if (_strict_io) {
1475                         boost::shared_ptr<PluginInsert> pi;
1476                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
1477                                 pi->set_strict_io (true);
1478                         }
1479                 }
1480
1481                 if (configure_processors_unlocked (err, &lm)) {
1482                         pstate.restore ();
1483                         configure_processors_unlocked (0, &lm);
1484                         return -1;
1485                 }
1486
1487                 _have_internal_generator = false;
1488
1489                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1490                         boost::shared_ptr<PluginInsert> pi;
1491                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1492                                 if (pi->has_no_inputs ()) {
1493                                         _have_internal_generator = true;
1494                                         break;
1495                                 }
1496                         }
1497                 }
1498
1499                 if (enable) {
1500                         sub->enable (true);
1501                 }
1502
1503                 sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1504                 _output->set_user_latency (0);
1505         }
1506
1507         reset_instrument_info ();
1508         old->drop_references ();
1509         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1510         set_processor_positions ();
1511         return 0;
1512 }
1513
1514 int
1515 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1516 {
1517         ProcessorList deleted;
1518
1519         if (!_session.engine().connected()) {
1520                 return 1;
1521         }
1522
1523         processor_max_streams.reset();
1524
1525         {
1526                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1527                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1528                 ProcessorState pstate (this);
1529
1530                 ProcessorList::iterator i;
1531                 boost::shared_ptr<Processor> processor;
1532
1533                 for (i = _processors.begin(); i != _processors.end(); ) {
1534
1535                         processor = *i;
1536
1537                         /* these can never be removed */
1538
1539                         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1540                                 ++i;
1541                                 continue;
1542                         }
1543
1544                         /* see if its in the list of processors to delete */
1545
1546                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1547                                 ++i;
1548                                 continue;
1549                         }
1550
1551                         /* stop IOProcessors that send to JACK ports
1552                            from causing noise as a result of no longer being
1553                            run.
1554                         */
1555
1556                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(processor);
1557                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
1558                         if (pi != 0) {
1559                                 assert (iop == 0);
1560                                 iop = pi->sidechain();
1561                         }
1562
1563                         if (iop != 0) {
1564                                 iop->disconnect ();
1565                         }
1566
1567                         deleted.push_back (processor);
1568                         i = _processors.erase (i);
1569                 }
1570
1571                 if (deleted.empty()) {
1572                         /* none of those in the requested list were found */
1573                         return 0;
1574                 }
1575
1576                 _output->set_user_latency (0);
1577
1578                 if (configure_processors_unlocked (err, &lm)) {
1579                         pstate.restore ();
1580                         /* we know this will work, because it worked before :) */
1581                         configure_processors_unlocked (0, &lm);
1582                         return -1;
1583                 }
1584                 //lx.unlock();
1585
1586                 _have_internal_generator = false;
1587
1588                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1589                         boost::shared_ptr<PluginInsert> pi;
1590
1591                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1592                                 if (pi->has_no_inputs ()) {
1593                                         _have_internal_generator = true;
1594                                         break;
1595                                 }
1596                         }
1597                 }
1598         }
1599
1600         /* now try to do what we need to so that those that were removed will be deleted */
1601
1602         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1603                 (*i)->drop_references ();
1604         }
1605
1606         reset_instrument_info ();
1607         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1608         set_processor_positions ();
1609
1610         return 0;
1611 }
1612
1613 void
1614 Route::reset_instrument_info ()
1615 {
1616         boost::shared_ptr<Processor> instr = the_instrument();
1617         if (instr) {
1618                 _instrument_info.set_internal_instrument (instr);
1619         }
1620 }
1621
1622 /** Caller must hold process lock */
1623 int
1624 Route::configure_processors (ProcessorStreams* err)
1625 {
1626 #ifndef PLATFORM_WINDOWS
1627         assert (!AudioEngine::instance()->process_lock().trylock());
1628 #endif
1629
1630         if (!_in_configure_processors) {
1631                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1632                 return configure_processors_unlocked (err, &lm);
1633         }
1634
1635         return 0;
1636 }
1637
1638 ChanCount
1639 Route::input_streams () const
1640 {
1641         return _input->n_ports ();
1642 }
1643
1644 list<pair<ChanCount, ChanCount> >
1645 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1646 {
1647         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1648
1649         return try_configure_processors_unlocked (in, err);
1650 }
1651
1652 list<pair<ChanCount, ChanCount> >
1653 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1654 {
1655         // Check each processor in order to see if we can configure as requested
1656         ChanCount out;
1657         list<pair<ChanCount, ChanCount> > configuration;
1658         uint32_t index = 0;
1659
1660         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1661         DEBUG_TRACE (DEBUG::Processors, "{\n");
1662
1663         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1664
1665                 if ((*p)->can_support_io_configuration(in, out)) {
1666
1667                         if (boost::dynamic_pointer_cast<Delivery> (*p)
1668                                         && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main
1669                                         && !is_auditioner()
1670                                         && (is_monitor() || _strict_io || Profile->get_mixbus ())) {
1671                                 /* with strict I/O the panner + output are forced to
1672                                  * follow the last processor's output.
1673                                  *
1674                                  * Delivery::can_support_io_configuration() will only add ports,
1675                                  * but not remove excess ports.
1676                                  *
1677                                  * This works because the delivery only requires
1678                                  * as many outputs as there are inputs.
1679                                  * Delivery::configure_io() will do the actual removal
1680                                  * by calling _output->ensure_io()
1681                                  */
1682                                 if (!is_master() && _session.master_out () && in.n_audio() > 0) {
1683                                         /* ..but at least as many as there are master-inputs, if
1684                                          * the delivery is dealing with audio */
1685                                         // XXX this may need special-casing for mixbus (master-outputs)
1686                                         // and should maybe be a preference anyway ?!
1687                                         out = ChanCount::max (in, _session.master_out ()->n_inputs ());
1688                                 } else {
1689                                         out = in;
1690                                 }
1691                         }
1692
1693                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1694                         configuration.push_back(make_pair(in, out));
1695
1696                         if (is_monitor()) {
1697                                 // restriction for Monitor Section Processors
1698                                 if (in.n_audio() != out.n_audio() || out.n_midi() > 0) {
1699                                         /* Note: The Monitor follows the master-bus and has no panner.
1700                                          *
1701                                          * The general idea is to only allow plugins that retain the channel-count
1702                                          * and plugins with MIDI in (e.g VSTs with control that will remain unconnected).
1703                                          * Then again 5.1 in, monitor stereo is a valid use-case.
1704                                          *
1705                                          * and worse: we only refuse adding plugins *here*.
1706                                          *
1707                                          * 1) stereo-master, stereo-mon, add a stereo-plugin, OK
1708                                          * 2) change master-bus, add a channel
1709                                          * 2a) monitor-secion follows
1710                                          * 3) monitor processors fail to re-reconfigure (stereo plugin)
1711                                          * 4) re-load session, monitor-processor remains unconfigured, crash.
1712                                          */
1713                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: Channel configuration change.\n");
1714                                 }
1715                                 if (boost::dynamic_pointer_cast<InternalSend> (*p)) {
1716                                         // internal sends make no sense, only feedback
1717                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1718                                         return list<pair<ChanCount, ChanCount> > ();
1719                                 }
1720                                 if (boost::dynamic_pointer_cast<PortInsert> (*p)) {
1721                                         /* External Sends can be problematic. one can add/remove ports
1722                                          * there signal leaves the DAW to external monitors anyway, so there's
1723                                          * no real use for allowing them here anyway.
1724                                          */
1725                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No External Sends allowed.\n");
1726                                         return list<pair<ChanCount, ChanCount> > ();
1727                                 }
1728                                 if (boost::dynamic_pointer_cast<Send> (*p)) {
1729                                         // ditto
1730                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1731                                         return list<pair<ChanCount, ChanCount> > ();
1732                                 }
1733                         }
1734                         in = out;
1735                 } else {
1736                         if (err) {
1737                                 err->index = index;
1738                                 err->count = in;
1739                         }
1740                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1741                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1742                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1743                         return list<pair<ChanCount, ChanCount> > ();
1744                 }
1745         }
1746
1747         DEBUG_TRACE (DEBUG::Processors, "}\n");
1748
1749         return configuration;
1750 }
1751
1752 /** Set the input/output configuration of each processor in the processors list.
1753  *  Caller must hold process lock.
1754  *  Return 0 on success, otherwise configuration is impossible.
1755  */
1756 int
1757 Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLock::WriterLock* lm)
1758 {
1759 #ifndef PLATFORM_WINDOWS
1760         assert (!AudioEngine::instance()->process_lock().trylock());
1761 #endif
1762
1763         if (_in_configure_processors) {
1764                 return 0;
1765         }
1766
1767         /* put invisible processors where they should be */
1768         setup_invisible_processors ();
1769
1770         _in_configure_processors = true;
1771
1772         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1773
1774         if (configuration.empty ()) {
1775                 _in_configure_processors = false;
1776                 return -1;
1777         }
1778
1779         ChanCount out;
1780         bool seen_mains_out = false;
1781         processor_out_streams = _input->n_ports();
1782         processor_max_streams.reset();
1783
1784         /* processor configure_io() may result in adding ports
1785          * e.g. Delivery::configure_io -> ARDOUR::IO::ensure_io ()
1786          *
1787          * with jack2 adding ports results in a graph-order callback,
1788          * which calls Session::resort_routes() and eventually
1789          * Route::direct_feeds_according_to_reality()
1790          * which takes a ReaderLock (_processor_lock).
1791          *
1792          * so we can't hold a WriterLock here until jack2 threading
1793          * is fixed.
1794          *
1795          * NB. we still hold the process lock
1796          *
1797          * (ardour's own engines do call graph-order from the
1798          * process-thread and hence do not have this issue; besides
1799          * merely adding ports won't trigger a graph-order, only
1800          * making connections does)
1801          */
1802         lm->release ();
1803
1804         // TODO check for a potential ReaderLock after ReaderLock ??
1805         Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
1806
1807         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1808         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1809
1810                 if (!(*p)->configure_io(c->first, c->second)) {
1811                         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
1812                         _in_configure_processors = false;
1813                         lr.release ();
1814                         lm->acquire ();
1815                         return -1;
1816                 }
1817                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1818                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1819
1820                 boost::shared_ptr<IOProcessor> iop;
1821                 boost::shared_ptr<PluginInsert> pi;
1822                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1823                         /* plugins connected via Split or Hide Match may have more channels.
1824                          * route/scratch buffers are needed for all of them
1825                          * The configuration may only be a subset (both input and output)
1826                          */
1827                         processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
1828                 }
1829                 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
1830                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
1831                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
1832                 }
1833                 out = c->second;
1834
1835                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1836                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1837                         /* main delivery will increase port count to match input.
1838                          * the Delivery::Main is usually the last processor - followed only by
1839                          * 'MeterOutput'.
1840                          */
1841                         seen_mains_out = true;
1842                 }
1843                 if (!seen_mains_out) {
1844                         processor_out_streams = out;
1845                 }
1846         }
1847
1848         lr.release ();
1849         lm->acquire ();
1850
1851
1852         if (_meter) {
1853                 _meter->set_max_channels (processor_max_streams);
1854         }
1855
1856         /* make sure we have sufficient scratch buffers to cope with the new processor
1857            configuration
1858         */
1859         _session.ensure_buffers (n_process_buffers ());
1860
1861         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1862
1863         _in_configure_processors = false;
1864         return 0;
1865 }
1866
1867 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1868  *  @param state New active state for those processors.
1869  */
1870 void
1871 Route::all_visible_processors_active (bool state)
1872 {
1873         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1874
1875         if (_processors.empty()) {
1876                 return;
1877         }
1878
1879         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1880                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1881                         continue;
1882                 }
1883 #ifdef MIXBUS
1884                 boost::shared_ptr<PluginInsert> pi;
1885                 if (0 != (pi = boost::dynamic_pointer_cast<PluginInsert>(*i))) {
1886                         if (pi->is_channelstrip ()) {
1887                                 continue;
1888                         }
1889                 }
1890 #endif
1891                 (*i)->enable (state);
1892         }
1893
1894         _session.set_dirty ();
1895 }
1896
1897 bool
1898 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
1899 {
1900         /* check if re-order requires re-configuration of any processors
1901          * -> compare channel configuration for all processors
1902          */
1903         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1904         ChanCount c = input_streams ();
1905
1906         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
1907                 bool found = false;
1908                 if (c != (*j)->input_streams()) {
1909                         return true;
1910                 }
1911                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1912                         if (*i == *j) {
1913                                 found = true;
1914                                 if ((*i)->input_streams() != c) {
1915                                         return true;
1916                                 }
1917                                 c = (*i)->output_streams();
1918                                 break;
1919                         }
1920                 }
1921                 if (!found) {
1922                         return true;
1923                 }
1924         }
1925         return false;
1926 }
1927
1928 #ifdef __clang__
1929 __attribute__((annotate("realtime")))
1930 #endif
1931 void
1932 Route::apply_processor_order (const ProcessorList& new_order)
1933 {
1934         /* need to hold processor_lock; either read or write lock
1935          * and the engine process_lock.
1936          * Due to r/w lock ambiguity we can only assert the latter
1937          */
1938         assert (!AudioEngine::instance()->process_lock().trylock());
1939
1940
1941         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1942          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1943          * processors in the current actual processor list that are hidden. Any visible processors
1944          *  in the current list but not in "new_order" will be assumed to be deleted.
1945          */
1946
1947         /* "as_it_will_be" and "_processors" are lists of shared pointers.
1948          * actual memory usage is small, but insert/erase is not actually rt-safe :(
1949          * (note though that  ::processors_reorder_needs_configure() ensured that
1950          * this function will only ever be called from the rt-thread if no processor were removed)
1951          *
1952          * either way, I can't proove it, but an x-run due to re-order here is less likley
1953          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
1954          */
1955
1956         ProcessorList as_it_will_be;
1957         ProcessorList::iterator oiter;
1958         ProcessorList::const_iterator niter;
1959
1960         oiter = _processors.begin();
1961         niter = new_order.begin();
1962
1963         while (niter !=  new_order.end()) {
1964
1965                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1966                    then append it to the temp list.
1967
1968                    Otherwise, see if the next processor in the old list is in the new list. if not,
1969                    its been deleted. If its there, append it to the temp list.
1970                    */
1971
1972                 if (oiter == _processors.end()) {
1973
1974                         /* no more elements in the old list, so just stick the rest of
1975                            the new order onto the temp list.
1976                            */
1977
1978                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1979                         while (niter != new_order.end()) {
1980                                 ++niter;
1981                         }
1982                         break;
1983
1984                 } else {
1985
1986                         if (!(*oiter)->display_to_user()) {
1987
1988                                 as_it_will_be.push_back (*oiter);
1989
1990                         } else {
1991
1992                                 /* visible processor: check that its in the new order */
1993
1994                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1995                                         /* deleted: do nothing, shared_ptr<> will clean up */
1996                                 } else {
1997                                         /* ignore this one, and add the next item from the new order instead */
1998                                         as_it_will_be.push_back (*niter);
1999                                         ++niter;
2000                                 }
2001                         }
2002
2003                         /* now remove from old order - its taken care of no matter what */
2004                         oiter = _processors.erase (oiter);
2005                 }
2006
2007         }
2008         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2009
2010         /* If the meter is in a custom position, find it and make a rough note of its position */
2011         maybe_note_meter_position ();
2012 }
2013
2014 void
2015 Route::move_instrument_down (bool postfader)
2016 {
2017         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2018         ProcessorList new_order;
2019         boost::shared_ptr<Processor> instrument;
2020         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2021                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
2022                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
2023                         instrument = *i;
2024                 } else if (instrument && *i == _amp) {
2025                         if (postfader) {
2026                                 new_order.push_back (*i);
2027                                 new_order.push_back (instrument);
2028                         } else {
2029                                 new_order.push_back (instrument);
2030                                 new_order.push_back (*i);
2031                         }
2032                 } else {
2033                         new_order.push_back (*i);
2034                 }
2035         }
2036         if (!instrument) {
2037                 return;
2038         }
2039         lm.release ();
2040         reorder_processors (new_order, 0);
2041 }
2042
2043 int
2044 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2045 {
2046         // it a change is already queued, wait for it
2047         // (unless engine is stopped. apply immediately and proceed
2048         while (g_atomic_int_get (&_pending_process_reorder)) {
2049                 if (!AudioEngine::instance()->running()) {
2050                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2051                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2052
2053                         apply_processor_order(_pending_processor_order);
2054                         setup_invisible_processors ();
2055
2056                         g_atomic_int_set (&_pending_process_reorder, 0);
2057
2058                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2059                         set_processor_positions ();
2060                 } else {
2061                         // TODO rather use a semaphore or something.
2062                         // but since ::reorder_processors() is called
2063                         // from the GUI thread, this is fine..
2064                         Glib::usleep(500);
2065                 }
2066         }
2067
2068         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2069
2070                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2071                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2072                 ProcessorState pstate (this);
2073
2074                 apply_processor_order (new_order);
2075
2076                 if (configure_processors_unlocked (err, &lm)) {
2077                         pstate.restore ();
2078                         return -1;
2079                 }
2080
2081                 lm.release();
2082                 lx.release();
2083
2084                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2085                 set_processor_positions ();
2086
2087         } else {
2088                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2089                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2090
2091                 // _pending_processor_order is protected by _processor_lock
2092                 _pending_processor_order = new_order;
2093                 g_atomic_int_set (&_pending_process_reorder, 1);
2094         }
2095
2096         return 0;
2097 }
2098
2099 bool
2100 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2101 {
2102         boost::shared_ptr<PluginInsert> pi;
2103         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2104                 return false;
2105         }
2106
2107         if (pi->has_sidechain () == add) {
2108                 return true; // ?? call failed, but result is as expected.
2109         }
2110
2111         {
2112                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2113                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2114                 if (i == _processors.end ()) {
2115                         return false;
2116                 }
2117         }
2118
2119         {
2120                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2121                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2122                 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2123
2124                 lx.release (); // IO::add_port() and ~IO takes process lock  - XXX check if this is safe
2125                 if (add) {
2126                         if (!pi->add_sidechain ()) {
2127                                 return false;
2128                         }
2129                 } else {
2130                         if (!pi->del_sidechain ()) {
2131                                 return false;
2132                         }
2133                 }
2134
2135                 lx.acquire ();
2136                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2137                 lx.release ();
2138
2139                 if (c.empty()) {
2140                         if (add) {
2141                                 pi->del_sidechain ();
2142                         } else {
2143                                 pi->add_sidechain ();
2144                                 // TODO restore side-chain's state.
2145                         }
2146                         return false;
2147                 }
2148                 lx.acquire ();
2149                 configure_processors_unlocked (0, &lm);
2150         }
2151
2152         if (pi->has_sidechain ()) {
2153                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2154         }
2155
2156         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2157         _session.set_dirty ();
2158         return true;
2159 }
2160
2161 bool
2162 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2163 {
2164         boost::shared_ptr<PluginInsert> pi;
2165         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2166                 return false;
2167         }
2168
2169         {
2170                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2171                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2172                 if (i == _processors.end ()) {
2173                         return false;
2174                 }
2175         }
2176
2177         {
2178                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2179                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2180
2181                 const ChanCount& old (pi->preset_out ());
2182                 if (!pi->set_preset_out (outs)) {
2183                         return true; // no change, OK
2184                 }
2185
2186                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2187                 if (c.empty()) {
2188                         /* not possible */
2189                         pi->set_preset_out (old);
2190                         return false;
2191                 }
2192                 configure_processors_unlocked (0, &lm);
2193         }
2194
2195         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2196         _session.set_dirty ();
2197         return true;
2198 }
2199
2200 bool
2201 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2202 {
2203         ChanCount unused;
2204         return customize_plugin_insert (proc, 0, unused, unused);
2205 }
2206
2207 bool
2208 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
2209 {
2210         boost::shared_ptr<PluginInsert> pi;
2211         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2212                 return false;
2213         }
2214
2215         {
2216                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2217                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2218                 if (i == _processors.end ()) {
2219                         return false;
2220                 }
2221         }
2222
2223         {
2224                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2225                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2226
2227                 bool      old_cust  = pi->custom_cfg ();
2228                 uint32_t  old_cnt   = pi->get_count ();
2229                 ChanCount old_chan  = pi->output_streams ();
2230                 ChanCount old_sinks = pi->natural_input_streams ();
2231
2232                 if (count == 0) {
2233                         pi->set_custom_cfg (false);
2234                 } else {
2235                         pi->set_custom_cfg (true);
2236                         pi->set_count (count);
2237                         pi->set_outputs (outs);
2238                         pi->set_sinks (sinks);
2239                 }
2240
2241                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2242                 if (c.empty()) {
2243                         /* not possible */
2244
2245                         pi->set_count (old_cnt);
2246                         pi->set_sinks (old_sinks);
2247                         pi->set_outputs (old_chan);
2248                         pi->set_custom_cfg (old_cust);
2249
2250                         return false;
2251                 }
2252                 configure_processors_unlocked (0, &lm);
2253         }
2254
2255         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2256         _session.set_dirty ();
2257         return true;
2258 }
2259
2260 bool
2261 Route::set_strict_io (const bool enable)
2262 {
2263         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2264
2265         if (_strict_io != enable) {
2266                 _strict_io = enable;
2267                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2268                 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2269                         boost::shared_ptr<PluginInsert> pi;
2270                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2271                                 pi->set_strict_io (_strict_io);
2272                         }
2273                 }
2274
2275                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2276
2277                 if (c.empty()) {
2278                         // not possible
2279                         _strict_io = !enable; // restore old value
2280                         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2281                                 boost::shared_ptr<PluginInsert> pi;
2282                                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2283                                         pi->set_strict_io (_strict_io);
2284                                 }
2285                         }
2286                         return false;
2287                 }
2288                 lm.release ();
2289
2290                 configure_processors (0);
2291                 lx.release ();
2292
2293                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2294                 _session.set_dirty ();
2295         }
2296         return true;
2297 }
2298
2299 XMLNode&
2300 Route::get_state()
2301 {
2302         return state(true);
2303 }
2304
2305 XMLNode&
2306 Route::get_template()
2307 {
2308         return state(false);
2309 }
2310
2311 XMLNode&
2312 Route::state(bool full_state)
2313 {
2314         if (!_session._template_state_dir.empty()) {
2315                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2316         }
2317
2318         XMLNode *node = new XMLNode("Route");
2319         ProcessorList::iterator i;
2320
2321         node->set_property ("id", id ());
2322         node->set_property ("name", name());
2323         node->set_property ("default-type", _default_type);
2324         node->set_property ("strict-io", _strict_io);
2325
2326         node->add_child_nocopy (_presentation_info.get_state());
2327
2328         node->set_property ("active", _active);
2329         node->set_property ("denormal-protection", _denormal_protection);
2330         node->set_property ("meter-point", _meter_point);
2331
2332         node->set_property ("meter-type", _meter_type);
2333
2334         if (_route_group) {
2335                 node->set_property ("route-group", _route_group->name());
2336         }
2337
2338         node->add_child_nocopy (_solo_control->get_state ());
2339         node->add_child_nocopy (_solo_isolate_control->get_state ());
2340         node->add_child_nocopy (_solo_safe_control->get_state ());
2341
2342         node->add_child_nocopy (_input->state (full_state));
2343         node->add_child_nocopy (_output->state (full_state));
2344         node->add_child_nocopy (_mute_master->get_state ());
2345
2346         node->add_child_nocopy (_mute_control->get_state ());
2347         node->add_child_nocopy (_phase_control->get_state ());
2348
2349         if (full_state) {
2350                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2351         }
2352
2353         if (_comment.length()) {
2354                 XMLNode *cmt = node->add_child ("Comment");
2355                 cmt->add_content (_comment);
2356         }
2357
2358         if (_pannable) {
2359                 node->add_child_nocopy (_pannable->state (full_state));
2360         }
2361
2362         {
2363                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2364                 for (i = _processors.begin(); i != _processors.end(); ++i) {
2365                         if (!full_state) {
2366                                 /* template save: do not include internal sends functioning as
2367                                          aux sends because the chance of the target ID
2368                                          in the session where this template is used
2369                                          is not very likely.
2370
2371                                          similarly, do not save listen sends which connect to
2372                                          the monitor section, because these will always be
2373                                          added if necessary.
2374                                          */
2375                                 boost::shared_ptr<InternalSend> is;
2376
2377                                 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2378                                         if (is->role() == Delivery::Listen) {
2379                                                 continue;
2380                                         }
2381                                 }
2382                         }
2383                         node->add_child_nocopy((*i)->state (full_state));
2384                 }
2385         }
2386
2387         if (_extra_xml) {
2388                 node->add_child_copy (*_extra_xml);
2389         }
2390
2391         if (_custom_meter_position_noted) {
2392                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2393                 if (after) {
2394                         node->set_property (X_("processor-after-last-custom-meter"), after->id());
2395                 }
2396         }
2397
2398         if (!_session._template_state_dir.empty()) {
2399                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2400         }
2401
2402         node->add_child_copy (Slavable::get_state());
2403
2404         return *node;
2405 }
2406
2407 int
2408 Route::set_state (const XMLNode& node, int version)
2409 {
2410         if (version < 3000) {
2411                 return set_state_2X (node, version);
2412         }
2413
2414         XMLNodeList nlist;
2415         XMLNodeConstIterator niter;
2416         XMLNode *child;
2417
2418         if (node.name() != "Route"){
2419                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2420                 return -1;
2421         }
2422
2423         std::string route_name;
2424         if (node.get_property (X_("name"), route_name)) {
2425                 Route::set_name (route_name);
2426         }
2427
2428         set_id (node);
2429         _initial_io_setup = true;
2430
2431         Stripable::set_state (node, version);
2432
2433         node.get_property (X_("strict-io"), _strict_io);
2434
2435         if (is_monitor()) {
2436                 /* monitor bus does not get a panner, but if (re)created
2437                    via XML, it will already have one by the time we
2438                    call ::set_state(). so ... remove it.
2439                 */
2440                 unpan ();
2441         }
2442
2443         /* add all processors (except amp, which is always present) */
2444
2445         nlist = node.children();
2446         XMLNode processor_state (X_("processor_state"));
2447
2448         Stateful::save_extra_xml (node);
2449
2450         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2451
2452                 child = *niter;
2453
2454                 if (child->name() == IO::state_node_name) {
2455                         std::string direction;
2456                         if (!child->get_property (X_("direction"), direction)) {
2457                                 continue;
2458                         }
2459
2460                         if (direction == "Input") {
2461                                 _input->set_state (*child, version);
2462                         } else if (direction == "Output") {
2463                                 _output->set_state (*child, version);
2464                         }
2465
2466                 } else if (child->name() == X_("Processor")) {
2467                         processor_state.add_child_copy (*child);
2468                 } else if (child->name() == X_("Pannable")) {
2469                         if (_pannable) {
2470                                 _pannable->set_state (*child, version);
2471                         } else {
2472                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2473                         }
2474                 } else if (child->name() == Slavable::xml_node_name) {
2475                         Slavable::set_state (*child, version);
2476                 }
2477         }
2478
2479         MeterPoint mp;
2480         if (node.get_property (X_("meter-point"), mp)) {
2481                 set_meter_point (mp, true);
2482                 if (_meter) {
2483                         _meter->set_display_to_user (_meter_point == MeterCustom);
2484                 }
2485         }
2486
2487         node.get_property (X_("meter-type"), _meter_type);
2488
2489         _initial_io_setup = false;
2490
2491         set_processor_state (processor_state);
2492
2493         // this looks up the internal instrument in processors
2494         reset_instrument_info();
2495
2496         bool denormal_protection;
2497         if (node.get_property (X_("denormal-protection"), denormal_protection)) {
2498                 set_denormal_protection (denormal_protection);
2499         }
2500
2501         /* convert old 3001 state */
2502         std::string phase_invert_str;
2503         if (node.get_property (X_("phase-invert"), phase_invert_str)) {
2504                 _phase_control->set_phase_invert (boost::dynamic_bitset<> (phase_invert_str));
2505         }
2506
2507         bool is_active;
2508         if (node.get_property (X_("active"), is_active)) {
2509                 set_active (is_active, this);
2510         }
2511
2512         std::string id_string;
2513         if (node.get_property (X_("processor-after-last-custom-meter"), id_string)) {
2514                 PBD::ID id (id_string);
2515                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2516                 ProcessorList::const_iterator i = _processors.begin ();
2517                 while (i != _processors.end() && (*i)->id() != id) {
2518                         ++i;
2519                 }
2520
2521                 if (i != _processors.end ()) {
2522                         _processor_after_last_custom_meter = *i;
2523                         _custom_meter_position_noted = true;
2524                 }
2525         }
2526
2527         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2528                 child = *niter;
2529
2530                 if (child->name() == X_("Comment")) {
2531
2532                         /* XXX this is a terrible API design in libxml++ */
2533
2534                         XMLNode *cmt = *(child->children().begin());
2535                         _comment = cmt->content();
2536
2537                 }  else if (child->name() == Controllable::xml_node_name) {
2538                         std::string control_name;
2539                         if (!child->get_property (X_("name"), control_name)) {
2540                                 continue;
2541                         }
2542
2543                         if (control_name == _solo_control->name()) {
2544                                 _solo_control->set_state (*child, version);
2545                         } else if (control_name == _solo_safe_control->name()) {
2546                                 _solo_safe_control->set_state (*child, version);
2547                         } else if (control_name == _solo_isolate_control->name()) {
2548                                 _solo_isolate_control->set_state (*child, version);
2549                         } else if (control_name == _mute_control->name()) {
2550                                 _mute_control->set_state (*child, version);
2551                         } else if (control_name == _phase_control->name()) {
2552                                 _phase_control->set_state (*child, version);
2553                         } else {
2554                                 Evoral::Parameter p = EventTypeMap::instance().from_symbol (control_name);
2555                                 if (p.type () >= MidiCCAutomation && p.type () < MidiSystemExclusiveAutomation) {
2556                                         boost::shared_ptr<AutomationControl> ac = automation_control (p, true);
2557                                         if (ac) {
2558                                                 ac->set_state (*child, version);
2559                                         }
2560                                 }
2561                         }
2562                 } else if (child->name() == MuteMaster::xml_node_name) {
2563                         _mute_master->set_state (*child, version);
2564
2565                 } else if (child->name() == Automatable::xml_node_name) {
2566                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2567                 }
2568         }
2569
2570         return 0;
2571 }
2572
2573 int
2574 Route::set_state_2X (const XMLNode& node, int version)
2575 {
2576         LocaleGuard lg;
2577         XMLNodeList nlist;
2578         XMLNodeConstIterator niter;
2579         XMLNode *child;
2580         XMLProperty const * prop;
2581
2582         /* 2X things which still remain to be handled:
2583          * default-type
2584          * automation
2585          * controlouts
2586          */
2587
2588         if (node.name() != "Route") {
2589                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2590                 return -1;
2591         }
2592
2593         Stripable::set_state (node, version);
2594
2595         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2596                 set_denormal_protection (string_to<bool> (prop->value()));
2597         }
2598
2599         if ((prop = node.property (X_("muted"))) != 0) {
2600
2601                 bool first = true;
2602                 bool muted = string_to<bool> (prop->value());
2603
2604                 if (muted) {
2605
2606                         string mute_point;
2607
2608                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2609
2610                                 if (string_to<bool> (prop->value())){
2611                                         mute_point = mute_point + "PreFader";
2612                                         first = false;
2613                                 }
2614                         }
2615
2616                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2617
2618                                 if (string_to<bool> (prop->value())){
2619
2620                                         if (!first) {
2621                                                 mute_point = mute_point + ",";
2622                                         }
2623
2624                                         mute_point = mute_point + "PostFader";
2625                                         first = false;
2626                                 }
2627                         }
2628
2629                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2630
2631                                 if (string_to<bool> (prop->value())){
2632
2633                                         if (!first) {
2634                                                 mute_point = mute_point + ",";
2635                                         }
2636
2637                                         mute_point = mute_point + "Listen";
2638                                         first = false;
2639                                 }
2640                         }
2641
2642                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2643
2644                                 if (string_to<bool> (prop->value())){
2645
2646                                         if (!first) {
2647                                                 mute_point = mute_point + ",";
2648                                         }
2649
2650                                         mute_point = mute_point + "Main";
2651                                 }
2652                         }
2653
2654                         _mute_master->set_mute_points (mute_point);
2655                         _mute_master->set_muted_by_self (true);
2656                 }
2657         }
2658
2659         if ((prop = node.property (X_("meter-point"))) != 0) {
2660                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2661         }
2662
2663         /* IOs */
2664
2665         nlist = node.children ();
2666         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2667
2668                 child = *niter;
2669
2670                 if (child->name() == IO::state_node_name) {
2671
2672                         /* there is a note in IO::set_state_2X() about why we have to call
2673                            this directly.
2674                            */
2675
2676                         _input->set_state_2X (*child, version, true);
2677                         _output->set_state_2X (*child, version, false);
2678
2679                         if ((prop = child->property (X_("name"))) != 0) {
2680                                 Route::set_name (prop->value ());
2681                         }
2682
2683                         set_id (*child);
2684
2685                         if ((prop = child->property (X_("active"))) != 0) {
2686                                 bool yn = string_to<bool> (prop->value());
2687                                 _active = !yn; // force switch
2688                                 set_active (yn, this);
2689                         }
2690
2691                         if ((prop = child->property (X_("gain"))) != 0) {
2692                                 gain_t val;
2693
2694                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2695                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
2696                                 }
2697                         }
2698
2699                         /* Set up Panners in the IO */
2700                         XMLNodeList io_nlist = child->children ();
2701
2702                         XMLNodeConstIterator io_niter;
2703                         XMLNode *io_child;
2704
2705                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2706
2707                                 io_child = *io_niter;
2708
2709                                 if (io_child->name() == X_("Panner")) {
2710                                         _main_outs->panner_shell()->set_state(*io_child, version);
2711                                 } else if (io_child->name() == X_("Automation")) {
2712                                         /* IO's automation is for the fader */
2713                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2714                                 }
2715                         }
2716                 }
2717         }
2718
2719         XMLNodeList redirect_nodes;
2720
2721         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2722
2723                 child = *niter;
2724
2725                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2726                         redirect_nodes.push_back(child);
2727                 }
2728
2729         }
2730
2731         set_processor_state_2X (redirect_nodes, version);
2732
2733         Stateful::save_extra_xml (node);
2734
2735         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2736                 child = *niter;
2737
2738                 if (child->name() == X_("Comment")) {
2739
2740                         /* XXX this is a terrible API design in libxml++ */
2741
2742                         XMLNode *cmt = *(child->children().begin());
2743                         _comment = cmt->content();
2744
2745                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2746                         if (prop->value() == X_("solo")) {
2747                                 _solo_control->set_state (*child, version);
2748                         } else if (prop->value() == X_("mute")) {
2749                                 _mute_control->set_state (*child, version);
2750                         }
2751
2752                 }
2753         }
2754
2755         return 0;
2756 }
2757
2758 XMLNode&
2759 Route::get_processor_state ()
2760 {
2761         XMLNode* root = new XMLNode (X_("redirects"));
2762         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2763                 root->add_child_nocopy ((*i)->state (true));
2764         }
2765
2766         return *root;
2767 }
2768
2769 void
2770 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2771 {
2772         /* We don't bother removing existing processors not in nList, as this
2773            method will only be called when creating a Route from scratch, not
2774            for undo purposes.  Just put processors in at the appropriate place
2775            in the list.
2776         */
2777
2778         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2779                 add_processor_from_xml_2X (**i, version);
2780         }
2781 }
2782
2783 void
2784 Route::set_processor_state (const XMLNode& node)
2785 {
2786         const XMLNodeList &nlist = node.children();
2787         XMLNodeConstIterator niter;
2788         ProcessorList new_order;
2789         bool must_configure = false;
2790
2791         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2792
2793                 XMLProperty* prop = (*niter)->property ("type");
2794
2795                 if (prop->value() == "amp") {
2796                         _amp->set_state (**niter, Stateful::current_state_version);
2797                         new_order.push_back (_amp);
2798                 } else if (prop->value() == "trim") {
2799                         _trim->set_state (**niter, Stateful::current_state_version);
2800                         new_order.push_back (_trim);
2801                 } else if (prop->value() == "meter") {
2802                         _meter->set_state (**niter, Stateful::current_state_version);
2803                         new_order.push_back (_meter);
2804                 } else if (prop->value() == "delay") {
2805                         if (_delayline) {
2806                                 _delayline->set_state (**niter, Stateful::current_state_version);
2807                                 new_order.push_back (_delayline);
2808                         }
2809                 } else if (prop->value() == "main-outs") {
2810                         _main_outs->set_state (**niter, Stateful::current_state_version);
2811                 } else if (prop->value() == "intreturn") {
2812                         if (!_intreturn) {
2813                                 _intreturn.reset (new InternalReturn (_session));
2814                                 must_configure = true;
2815                         }
2816                         _intreturn->set_state (**niter, Stateful::current_state_version);
2817                 } else if (is_monitor() && prop->value() == "monitor") {
2818                         if (!_monitor_control) {
2819                                 _monitor_control.reset (new MonitorProcessor (_session));
2820                                 must_configure = true;
2821                         }
2822                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2823                 } else if (prop->value() == "capture") {
2824                         /* CapturingProcessor should never be restored, it's always
2825                            added explicitly when needed */
2826                 } else {
2827                         ProcessorList::iterator o;
2828
2829                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2830                                 XMLProperty const * id_prop = (*niter)->property(X_("id"));
2831                                 if (id_prop && (*o)->id() == id_prop->value()) {
2832                                         (*o)->set_state (**niter, Stateful::current_state_version);
2833                                         new_order.push_back (*o);
2834                                         break;
2835                                 }
2836                         }
2837
2838                         // If the processor (*niter) is not on the route then create it
2839
2840                         if (o == _processors.end()) {
2841
2842                                 boost::shared_ptr<Processor> processor;
2843
2844                                 if (prop->value() == "intsend") {
2845
2846                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2847
2848                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2849                                            prop->value() == "lv2" ||
2850                                            prop->value() == "windows-vst" ||
2851                                            prop->value() == "mac-vst" ||
2852                                            prop->value() == "lxvst" ||
2853                                            prop->value() == "luaproc" ||
2854                                            prop->value() == "audiounit") {
2855
2856                                         if (_session.get_disable_all_loaded_plugins ()) {
2857                                                 processor.reset (new UnknownProcessor (_session, **niter));
2858                                         } else {
2859                                                 processor.reset (new PluginInsert (_session));
2860                                                 processor->set_owner (this);
2861                                                 if (_strict_io) {
2862                                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
2863                                                         pi->set_strict_io (true);
2864                                                 }
2865
2866                                         }
2867                                 } else if (prop->value() == "port") {
2868
2869                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2870
2871                                 } else if (prop->value() == "send") {
2872
2873                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2874                                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
2875                                         send->SelfDestruct.connect_same_thread (*this,
2876                                                         boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
2877
2878                                 } else {
2879                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2880                                         continue;
2881                                 }
2882
2883                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2884                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2885                                         processor.reset (new UnknownProcessor (_session, **niter));
2886                                 }
2887
2888                                 /* subscribe to Sidechain IO changes */
2889                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
2890                                 if (pi && pi->has_sidechain ()) {
2891                                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2892                                 }
2893
2894                                 /* we have to note the monitor send here, otherwise a new one will be created
2895                                    and the state of this one will be lost.
2896                                 */
2897                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2898                                 if (isend && isend->role() == Delivery::Listen) {
2899                                         _monitor_send = isend;
2900                                 }
2901
2902                                 /* it doesn't matter if invisible processors are added here, as they
2903                                    will be sorted out by setup_invisible_processors () shortly.
2904                                 */
2905
2906                                 new_order.push_back (processor);
2907                                 must_configure = true;
2908                         }
2909                 }
2910         }
2911
2912         ProcessorList old_list = _processors; // keep a copy
2913         {
2914                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2915                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2916                 /* re-assign _processors w/o process-lock.
2917                  * if there's an IO-processor present in _processors but
2918                  * not in new_order, it will be deleted and ~IO takes
2919                  * a process lock.
2920                  */
2921                 _processors = new_order;
2922
2923                 if (must_configure) {
2924                         configure_processors_unlocked (0, &lm);
2925                 }
2926
2927                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2928
2929                         (*i)->set_owner (this);
2930                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2931
2932                         boost::shared_ptr<PluginInsert> pi;
2933
2934                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2935                                 if (pi->has_no_inputs ()) {
2936                                         _have_internal_generator = true;
2937                                         break;
2938                                 }
2939                         }
2940                 }
2941         }
2942         /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
2943         old_list.clear ();
2944
2945         reset_instrument_info ();
2946         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2947         set_processor_positions ();
2948 }
2949
2950 void
2951 Route::curve_reallocate ()
2952 {
2953 //      _gain_automation_curve.finish_resize ();
2954 //      _pan_automation_curve.finish_resize ();
2955 }
2956
2957 void
2958 Route::silence (framecnt_t nframes)
2959 {
2960         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2961         if (!lm.locked()) {
2962                 return;
2963         }
2964
2965         silence_unlocked (nframes);
2966 }
2967
2968 void
2969 Route::silence_unlocked (framecnt_t nframes)
2970 {
2971         /* Must be called with the processor lock held */
2972
2973         const framepos_t now = _session.transport_frame ();
2974
2975         if (!_silent) {
2976
2977                 _output->silence (nframes);
2978
2979                 // update owned automated controllables
2980                 automation_run (now, nframes);
2981
2982                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2983                         boost::shared_ptr<PluginInsert> pi;
2984
2985                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2986                                 /* evaluate automated automation controls */
2987                                 pi->automation_run (now, nframes);
2988                                 /* skip plugins, they don't need anything when we're not active */
2989                                 continue;
2990                         }
2991
2992                         (*i)->silence (nframes, now);
2993                 }
2994
2995                 if (nframes == _session.get_block_size()) {
2996                         // _silent = true;
2997                 }
2998         }
2999 }
3000
3001 void
3002 Route::add_internal_return ()
3003 {
3004         if (!_intreturn) {
3005                 _intreturn.reset (new InternalReturn (_session));
3006                 add_processor (_intreturn, PreFader);
3007         }
3008 }
3009
3010 void
3011 Route::add_send_to_internal_return (InternalSend* send)
3012 {
3013         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3014
3015         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3016                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3017
3018                 if (d) {
3019                         return d->add_send (send);
3020                 }
3021         }
3022 }
3023
3024 void
3025 Route::remove_send_from_internal_return (InternalSend* send)
3026 {
3027         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3028
3029         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3030                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3031
3032                 if (d) {
3033                         return d->remove_send (send);
3034                 }
3035         }
3036 }
3037
3038 void
3039 Route::enable_monitor_send ()
3040 {
3041         /* Caller must hold process lock */
3042         assert (!AudioEngine::instance()->process_lock().trylock());
3043
3044         /* master never sends to monitor section via the normal mechanism */
3045         assert (!is_master ());
3046         assert (!is_monitor ());
3047
3048         /* make sure we have one */
3049         if (!_monitor_send) {
3050                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3051                 _monitor_send->set_display_to_user (false);
3052         }
3053
3054         /* set it up */
3055         configure_processors (0);
3056 }
3057
3058 /** Add an aux send to a route.
3059  *  @param route route to send to.
3060  *  @param before Processor to insert before, or 0 to insert at the end.
3061  */
3062 int
3063 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3064 {
3065         assert (route != _session.monitor_out ());
3066
3067         {
3068                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3069
3070                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3071
3072                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3073
3074                         if (d && d->target_route() == route) {
3075                                 /* already listening via the specified IO: do nothing */
3076                                 return 0;
3077                         }
3078                 }
3079         }
3080
3081         try {
3082
3083                 boost::shared_ptr<InternalSend> listener;
3084
3085                 {
3086                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3087                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3088                 }
3089
3090                 add_processor (listener, before);
3091
3092         } catch (failed_constructor& err) {
3093                 return -1;
3094         }
3095
3096         return 0;
3097 }
3098
3099 void
3100 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3101 {
3102         ProcessorStreams err;
3103         ProcessorList::iterator tmp;
3104
3105         {
3106                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3107
3108                 /* have to do this early because otherwise processor reconfig
3109                  * will put _monitor_send back in the list
3110                  */
3111
3112                 if (route == _session.monitor_out()) {
3113                         _monitor_send.reset ();
3114                 }
3115
3116           again:
3117                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3118
3119                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3120
3121                         if (d && d->target_route() == route) {
3122                                 rl.release ();
3123                                 if (remove_processor (*x, &err, false) > 0) {
3124                                         rl.acquire ();
3125                                         continue;
3126                                 }
3127                                 rl.acquire ();
3128
3129                                 /* list could have been demolished while we dropped the lock
3130                                    so start over.
3131                                 */
3132                                 if (_session.engine().connected()) {
3133                                         /* i/o processors cannot be removed if the engine is not running
3134                                          * so don't live-loop in case the engine is N/A or dies
3135                                          */
3136                                         goto again;
3137                                 }
3138                         }
3139                 }
3140         }
3141 }
3142
3143 void
3144 Route::set_comment (string cmt, void *src)
3145 {
3146         _comment = cmt;
3147         comment_changed ();
3148         _session.set_dirty ();
3149 }
3150
3151 bool
3152 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3153 {
3154         FeedRecord fr (other, via_sends_only);
3155
3156         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3157
3158         if (!result.second) {
3159
3160                 /* already a record for "other" - make sure sends-only information is correct */
3161                 if (!via_sends_only && result.first->sends_only) {
3162                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3163                         frp->sends_only = false;
3164                 }
3165         }
3166
3167         return result.second;
3168 }
3169
3170 void
3171 Route::clear_fed_by ()
3172 {
3173         _fed_by.clear ();
3174 }
3175
3176 bool
3177 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3178 {
3179         const FedBy& fed_by (other->fed_by());
3180
3181         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3182                 boost::shared_ptr<Route> sr = f->r.lock();
3183
3184                 if (sr && (sr.get() == this)) {
3185
3186                         if (via_sends_only) {
3187                                 *via_sends_only = f->sends_only;
3188                         }
3189
3190                         return true;
3191                 }
3192         }
3193
3194         return false;
3195 }
3196
3197 IOVector
3198 Route::all_inputs () const
3199 {
3200         /* TODO, if this works as expected,
3201          * cache the IOVector and maintain it via
3202          * input_change_handler(), sidechain_change_handler() etc
3203          */
3204         IOVector ios;
3205         ios.push_back (_input);
3206
3207         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3208         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3209
3210                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3211                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3212                 if (pi != 0) {
3213                         assert (iop == 0);
3214                         iop = pi->sidechain();
3215                 }
3216
3217                 if (iop != 0 && iop->input()) {
3218                         ios.push_back (iop->input());
3219                 }
3220         }
3221         return ios;
3222 }
3223
3224 IOVector
3225 Route::all_outputs () const
3226 {
3227         IOVector ios;
3228         // _output is included via Delivery
3229         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3230         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3231                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3232                 if (iop != 0 && iop->output()) {
3233                         ios.push_back (iop->output());
3234                 }
3235         }
3236         return ios;
3237 }
3238
3239 bool
3240 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3241 {
3242         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3243         if (other->all_inputs().fed_by (_output)) {
3244                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3245                 if (via_send_only) {
3246                         *via_send_only = false;
3247                 }
3248
3249                 return true;
3250         }
3251
3252         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3253
3254         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3255
3256                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3257                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3258                 if (pi != 0) {
3259                         assert (iop == 0);
3260                         iop = pi->sidechain();
3261                 }
3262
3263                 if (iop != 0) {
3264                         boost::shared_ptr<const IO> iop_out = iop->output();
3265                         if (other.get() == this && iop_out && iop->input() && iop_out->connected_to (iop->input())) {
3266                                 // TODO this needs a delaylines in the Insert to align connections (!)
3267                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed its own return (%2)\n", iop->name(), other->name()));
3268                                 continue;
3269                         }
3270                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3271                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3272                                 if (via_send_only) {
3273                                         *via_send_only = true;
3274                                 }
3275                                 return true;
3276                         } else {
3277                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3278                         }
3279                 } else {
3280                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3281                 }
3282
3283         }
3284
3285         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3286         return false;
3287 }
3288
3289 bool
3290 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3291 {
3292         return _session._current_route_graph.has (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other, via_send_only);
3293 }
3294
3295 bool
3296 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3297 {
3298         return _session._current_route_graph.feeds (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other);
3299 }
3300
3301 /** Called from the (non-realtime) butler thread when the transport is stopped */
3302 void
3303 Route::non_realtime_transport_stop (framepos_t now, bool flush)
3304 {
3305         {
3306                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3307
3308                 Automatable::non_realtime_transport_stop (now, flush);
3309
3310                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3311
3312                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
3313                                 (*i)->flush ();
3314                         }
3315
3316                         (*i)->non_realtime_transport_stop (now, flush);
3317                 }
3318         }
3319
3320         _roll_delay = _initial_delay;
3321 }
3322
3323 void
3324 Route::input_change_handler (IOChange change, void * /*src*/)
3325 {
3326         if ((change.type & IOChange::ConfigurationChanged)) {
3327                 /* This is called with the process lock held if change
3328                    contains ConfigurationChanged
3329                 */
3330                 configure_processors (0);
3331                 _phase_control->resize (_input->n_ports().n_audio ());
3332                 io_changed (); /* EMIT SIGNAL */
3333         }
3334
3335         if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3336                 int sbou = 0;
3337                 int ibou = 0;
3338                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3339                 if (_input->connected()) {
3340                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3341                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3342                                         continue;
3343                                 }
3344                                 bool sends_only;
3345                                 bool does_feed = (*i)->direct_feeds_according_to_reality (boost::dynamic_pointer_cast<Route> (shared_from_this()), &sends_only);
3346                                 if (does_feed && !sends_only) {
3347                                         if ((*i)->soloed()) {
3348                                                 ++sbou;
3349                                         }
3350                                         if ((*i)->solo_isolate_control()->solo_isolated()) {
3351                                                 ++ibou;
3352                                         }
3353                                 }
3354                         }
3355                 }
3356
3357                 int delta  = sbou - _solo_control->soloed_by_others_upstream();
3358                 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3359
3360                 if (idelta < -1) {
3361                         PBD::warning << string_compose (
3362                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3363                                         _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3364                                      << endmsg;
3365
3366                 }
3367
3368                 if (_solo_control->soloed_by_others_upstream()) {
3369                         // ignore new connections (they're not propagated)
3370                         if (delta <= 0) {
3371                                 _solo_control->mod_solo_by_others_upstream (delta);
3372                         }
3373                 }
3374
3375                 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3376                         // solo-isolate currently only propagates downstream
3377                         if (idelta < 0) {
3378                                 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3379                         }
3380                         //_solo_isolated_by_upstream = ibou;
3381                 }
3382
3383                 // Session::route_solo_changed  does not propagate indirect solo-changes
3384                 // propagate downstream to tracks
3385                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3386                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3387                                 continue;
3388                         }
3389                         bool sends_only;
3390                         bool does_feed = feeds (*i, &sends_only);
3391                         if (delta <= 0 && does_feed && !sends_only) {
3392                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3393                         }
3394
3395                         if (idelta < 0 && does_feed && !sends_only) {
3396                                 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3397                         }
3398                 }
3399         }
3400 }
3401
3402 void
3403 Route::output_change_handler (IOChange change, void * /*src*/)
3404 {
3405         if (_initial_io_setup) {
3406                 return;
3407         }
3408
3409         if ((change.type & IOChange::ConfigurationChanged)) {
3410                 /* This is called with the process lock held if change
3411                    contains ConfigurationChanged
3412                 */
3413                 configure_processors (0);
3414
3415                 if (is_master()) {
3416                         _session.reset_monitor_section();
3417                 }
3418
3419                 io_changed (); /* EMIT SIGNAL */
3420         }
3421
3422         if ((change.type & IOChange::ConnectionsChanged)) {
3423
3424                 /* do this ONLY if connections have changed. Configuration
3425                  * changes do not, by themselves alter solo upstream or
3426                  * downstream status.
3427                  */
3428
3429                 if (_solo_control->soloed_by_others_downstream()) {
3430                         int sbod = 0;
3431                         /* checking all all downstream routes for
3432                          * explicit of implict solo is a rather drastic measure,
3433                          * ideally the input_change_handler() of the other route
3434                          * would propagate the change to us.
3435                          */
3436                         boost::shared_ptr<RouteList> routes = _session.get_routes ();
3437                         if (_output->connected()) {
3438                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3439                                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3440                                                 continue;
3441                                         }
3442                                         bool sends_only;
3443                                         bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3444                                         if (does_feed && !sends_only) {
3445                                                 if ((*i)->soloed()) {
3446                                                         ++sbod;
3447                                                         break;
3448                                                 }
3449                                         }
3450                                 }
3451                         }
3452
3453                         int delta = sbod - _solo_control->soloed_by_others_downstream();
3454                         if (delta <= 0) {
3455                                 // do not allow new connections to change implicit solo (no propagation)
3456                                 _solo_control->mod_solo_by_others_downstream (delta);
3457                                 // Session::route_solo_changed() does not propagate indirect solo-changes
3458                                 // propagate upstream to tracks
3459                                 boost::shared_ptr<Route> shared_this = boost::dynamic_pointer_cast<Route> (shared_from_this());
3460                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3461                                         if ((*i).get() == this || !can_solo()) {
3462                                                 continue;
3463                                         }
3464                                         bool sends_only;
3465                                         bool does_feed = (*i)->feeds (shared_this, &sends_only);
3466                                         if (delta != 0 && does_feed && !sends_only) {
3467                                                 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3468                                         }
3469                                 }
3470
3471                         }
3472                 }
3473         }
3474 }
3475
3476 void
3477 Route::sidechain_change_handler (IOChange change, void* src)
3478 {
3479         if (_initial_io_setup || _in_sidechain_setup) {
3480                 return;
3481         }
3482
3483         input_change_handler (change, src);
3484 }
3485
3486 uint32_t
3487 Route::pans_required () const
3488 {
3489         if (n_outputs().n_audio() < 2) {
3490                 return 0;
3491         }
3492
3493         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3494 }
3495
3496 void
3497 Route::flush_processor_buffers_locked (framecnt_t nframes)
3498 {
3499         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3500                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
3501                 if (d) {
3502                         d->flush_buffers (nframes);
3503                 } else {
3504                         boost::shared_ptr<PortInsert> p = boost::dynamic_pointer_cast<PortInsert> (*i);
3505                         if (p) {
3506                                 p->flush_buffers (nframes);
3507                         }
3508                 }
3509         }
3510 }
3511
3512 int
3513 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3514 {
3515         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3516
3517         if (!lm.locked()) {
3518                 return 0;
3519         }
3520
3521         if (!_active) {
3522                 silence_unlocked (nframes);
3523                 return 0;
3524         }
3525
3526         if (session_state_changing) {
3527                 if (_session.transport_speed() != 0.0f) {
3528                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3529                            so we cannot use them. Be silent till this is over.
3530
3531                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3532                         */
3533                         silence_unlocked (nframes);
3534                         return 0;
3535                 }
3536                 /* we're really not rolling, so we're either delivery silence or actually
3537                    monitoring, both of which are safe to do while session_state_changing is true.
3538                 */
3539         }
3540
3541         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3542
3543         fill_buffers_with_input (bufs, _input, nframes);
3544
3545         if (_meter_point == MeterInput) {
3546                 _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true);
3547         }
3548
3549         _amp->apply_gain_automation (false);
3550         _trim->apply_gain_automation (false);
3551         passthru (bufs, start_frame, end_frame, nframes, 0);
3552
3553         flush_processor_buffers_locked (nframes);
3554
3555         return 0;
3556 }
3557
3558 int
3559 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3560 {
3561         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3562         if (!lm.locked()) {
3563                 return 0;
3564         }
3565
3566         if (!_active) {
3567                 silence_unlocked (nframes);
3568                 return 0;
3569         }
3570
3571         framepos_t unused = 0;
3572
3573         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3574                 return 0;
3575         }
3576
3577         _silent = false;
3578
3579         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3580
3581         fill_buffers_with_input (bufs, _input, nframes);
3582
3583         if (_meter_point == MeterInput) {
3584                 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
3585         }
3586
3587         passthru (bufs, start_frame, end_frame, nframes, declick);
3588
3589         flush_processor_buffers_locked (nframes);
3590
3591         return 0;
3592 }
3593
3594 int
3595 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3596 {
3597         silence (nframes);
3598         flush_processor_buffers_locked (nframes);
3599         return 0;
3600 }
3601
3602 void
3603 Route::flush_processors ()
3604 {
3605         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3606
3607         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3608                 (*i)->flush ();
3609         }
3610 }
3611
3612 #ifdef __clang__
3613 __attribute__((annotate("realtime")))
3614 #endif
3615 bool
3616 Route::apply_processor_changes_rt ()
3617 {
3618         int emissions = EmitNone;
3619
3620         if (_pending_meter_point != _meter_point) {
3621                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3622                 if (pwl.locked()) {
3623                         /* meters always have buffers for 'processor_max_streams'
3624                          * they can be re-positioned without re-allocation */
3625                         if (set_meter_point_unlocked()) {
3626                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3627                         } else {
3628                                 emissions |= EmitMeterChanged;
3629                         }
3630                 }
3631         }
3632
3633         bool changed = false;
3634
3635         if (g_atomic_int_get (&_pending_process_reorder)) {
3636                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3637                 if (pwl.locked()) {
3638                         apply_processor_order (_pending_processor_order);
3639                         setup_invisible_processors ();
3640                         changed = true;
3641                         g_atomic_int_set (&_pending_process_reorder, 0);
3642                         emissions |= EmitRtProcessorChange;
3643                 }
3644         }
3645         if (changed) {
3646                 set_processor_positions ();
3647         }
3648         if (emissions != 0) {
3649                 g_atomic_int_set (&_pending_signals, emissions);
3650                 return true;
3651         }
3652         return (!selfdestruct_sequence.empty ());
3653 }
3654
3655 void
3656 Route::emit_pending_signals ()
3657 {
3658         int sig = g_atomic_int_and (&_pending_signals, 0);
3659         if (sig & EmitMeterChanged) {
3660                 _meter->emit_configuration_changed();
3661                 meter_change (); /* EMIT SIGNAL */
3662                 if (sig & EmitMeterVisibilityChange) {
3663                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3664                 } else {
3665                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3666                 }
3667         }
3668         if (sig & EmitRtProcessorChange) {
3669                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3670         }
3671
3672         /* this would be a job for the butler.
3673          * Conceptually we should not take processe/processor locks here.
3674          * OTOH its more efficient (less overhead for summoning the butler and
3675          * telling her what do do) and signal emission is called
3676          * directly after the process callback, which decreases the chance
3677          * of x-runs when taking the locks.
3678          */
3679         while (!selfdestruct_sequence.empty ()) {
3680                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3681                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3682                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3683                 selfdestruct_sequence.pop_back ();
3684                 lx.release ();
3685                 if (proc) {
3686                         remove_processor (proc);
3687                 }
3688         }
3689 }
3690
3691 void
3692 Route::set_meter_point (MeterPoint p, bool force)
3693 {
3694         if (_pending_meter_point == p && !force) {
3695                 return;
3696         }
3697
3698         if (force || !AudioEngine::instance()->running()) {
3699                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3700                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3701                 _pending_meter_point = p;
3702                 _meter->emit_configuration_changed();
3703                 meter_change (); /* EMIT SIGNAL */
3704                 if (set_meter_point_unlocked()) {
3705                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3706                 } else {
3707                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3708                 }
3709         } else {
3710                 _pending_meter_point = p;
3711         }
3712 }
3713
3714
3715 #ifdef __clang__
3716 __attribute__((annotate("realtime")))
3717 #endif
3718 bool
3719 Route::set_meter_point_unlocked ()
3720 {
3721 #ifndef NDEBUG
3722         /* Caller must hold process and processor write lock */
3723         assert (!AudioEngine::instance()->process_lock().trylock());
3724         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3725         assert (!lm.locked ());
3726 #endif
3727
3728         _meter_point = _pending_meter_point;
3729
3730         bool meter_was_visible_to_user = _meter->display_to_user ();
3731
3732         if (!_custom_meter_position_noted) {
3733                 maybe_note_meter_position ();
3734         }
3735
3736         if (_meter_point != MeterCustom) {
3737
3738                 _meter->set_display_to_user (false);
3739
3740                 setup_invisible_processors ();
3741
3742         } else {
3743                 _meter->set_display_to_user (true);
3744
3745                 /* If we have a previous position for the custom meter, try to put it there */
3746                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3747                 if (after) {
3748                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3749                         if (i != _processors.end ()) {
3750                                 _processors.remove (_meter);
3751                                 _processors.insert (i, _meter);
3752                         }
3753                 } else {// at end, right before the mains_out/panner
3754                         _processors.remove (_meter);
3755                         ProcessorList::iterator main = _processors.end();
3756                         _processors.insert (--main, _meter);
3757                 }
3758         }
3759
3760         /* Set up the meter for its new position */
3761
3762         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3763
3764         ChanCount m_in;
3765
3766         if (loc == _processors.begin()) {
3767                 m_in = _input->n_ports();
3768         } else {
3769                 ProcessorList::iterator before = loc;
3770                 --before;
3771                 m_in = (*before)->output_streams ();
3772         }
3773
3774         _meter->reflect_inputs (m_in);
3775
3776         /* we do not need to reconfigure the processors, because the meter
3777            (a) is always ready to handle processor_max_streams
3778            (b) is always an N-in/N-out processor, and thus moving
3779            it doesn't require any changes to the other processors.
3780         */
3781
3782         /* these should really be done after releasing the lock
3783          * but all those signals are subscribed to with gui_thread()
3784          * so we're safe.
3785          */
3786          return (_meter->display_to_user() != meter_was_visible_to_user);
3787 }
3788
3789 void
3790 Route::listen_position_changed ()
3791 {
3792         {
3793                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3794                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3795                 ProcessorState pstate (this);
3796
3797                 if (configure_processors_unlocked (0, &lm)) {
3798                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
3799                         pstate.restore ();
3800                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
3801                         return;
3802                 }
3803         }
3804
3805         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3806         _session.set_dirty ();
3807 }
3808
3809 boost::shared_ptr<CapturingProcessor>
3810 Route::add_export_point()
3811 {
3812         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3813         if (!_capturing_processor) {
3814                 lm.release();
3815                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3816                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3817
3818                 // this aligns all tracks; but not tracks + busses
3819                 assert (_session.worst_track_latency () >= _initial_delay);
3820                 _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay));
3821                 _capturing_processor->activate ();
3822
3823                 configure_processors_unlocked (0, &lw);
3824
3825         }
3826
3827         return _capturing_processor;
3828 }
3829
3830 framecnt_t
3831 Route::update_signal_latency ()
3832 {
3833         framecnt_t l = _output->user_latency();
3834         framecnt_t lamp = 0;
3835         bool before_amp = true;
3836         framecnt_t ltrim = 0;
3837         bool before_trim = true;
3838
3839         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3840                 if ((*i)->active ()) {
3841                         l += (*i)->signal_latency ();
3842                 }
3843                 if ((*i) == _amp) {
3844                         before_amp = false;
3845                 }
3846                 if ((*i) == _trim) {
3847                         before_amp = false;
3848                 }
3849                 if (before_amp) {
3850                         lamp = l;
3851                 }
3852                 if (before_trim) {
3853                         lamp = l;
3854                 }
3855         }
3856
3857         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3858
3859         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
3860         _signal_latency_at_amp_position = lamp;
3861         _signal_latency_at_trim_position = ltrim;
3862
3863         if (_signal_latency != l) {
3864                 _signal_latency = l;
3865                 signal_latency_changed (); /* EMIT SIGNAL */
3866         }
3867
3868         return _signal_latency;
3869 }
3870
3871 void
3872 Route::set_user_latency (framecnt_t nframes)
3873 {
3874         _output->set_user_latency (nframes);
3875         _session.update_latency_compensation ();
3876 }
3877
3878 void
3879 Route::set_latency_compensation (framecnt_t longest_session_latency)
3880 {
3881         framecnt_t old = _initial_delay;
3882
3883         if (_signal_latency < longest_session_latency) {
3884                 _initial_delay = longest_session_latency - _signal_latency;
3885         } else {
3886                 _initial_delay = 0;
3887         }
3888
3889         DEBUG_TRACE (DEBUG::Latency, string_compose (
3890                              "%1: compensate for maximum latency of %2,"
3891                              "given own latency of %3, using initial delay of %4\n",
3892                              name(), longest_session_latency, _signal_latency, _initial_delay));
3893
3894         if (_initial_delay != old) {
3895                 initial_delay_changed (); /* EMIT SIGNAL */
3896         }
3897
3898         if (_session.transport_stopped()) {
3899                 _roll_delay = _initial_delay;
3900         }
3901 }
3902
3903 void
3904 Route::set_block_size (pframes_t nframes)
3905 {
3906         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3907                 (*i)->set_block_size (nframes);
3908         }
3909
3910         _session.ensure_buffers (n_process_buffers ());
3911 }
3912
3913 void
3914 Route::protect_automation ()
3915 {
3916         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3917                 (*i)->protect_automation();
3918 }
3919
3920 /** @param declick 1 to set a pending declick fade-in,
3921  *                -1 to set a pending declick fade-out
3922  */
3923 void
3924 Route::set_pending_declick (int declick)
3925 {
3926         if (_declickable) {
3927                 /* this call is not allowed to turn off a pending declick */
3928                 if (declick) {
3929                         _pending_declick = declick;
3930                 }
3931         } else {
3932                 _pending_declick = 0;
3933         }
3934 }
3935
3936 /** Shift automation forwards from a particular place, thereby inserting time.
3937  *  Adds undo commands for any shifts that are performed.
3938  *
3939  * @param pos Position to start shifting from.
3940  * @param frames Amount to shift forwards by.
3941  */
3942
3943 void
3944 Route::shift (framepos_t pos, framecnt_t frames)
3945 {
3946         /* gain automation */
3947         {
3948                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3949
3950                 XMLNode &before = gc->alist()->get_state ();
3951                 gc->alist()->shift (pos, frames);
3952                 XMLNode &after = gc->alist()->get_state ();
3953                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3954         }
3955
3956         /* gain automation */
3957         {
3958                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3959
3960                 XMLNode &before = gc->alist()->get_state ();
3961                 gc->alist()->shift (pos, frames);
3962                 XMLNode &after = gc->alist()->get_state ();
3963                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3964         }
3965
3966         // TODO mute automation ??
3967
3968         /* pan automation */
3969         if (_pannable) {
3970                 ControlSet::Controls& c (_pannable->controls());
3971
3972                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3973                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3974                         if (pc) {
3975                                 boost::shared_ptr<AutomationList> al = pc->alist();
3976                                 XMLNode& before = al->get_state ();
3977                                 al->shift (pos, frames);
3978                                 XMLNode& after = al->get_state ();
3979                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3980                         }
3981                 }
3982         }
3983
3984         /* redirect automation */
3985         {
3986                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3987                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3988
3989                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3990
3991                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3992                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3993                                 if (ac) {
3994                                         boost::shared_ptr<AutomationList> al = ac->alist();
3995                                         XMLNode &before = al->get_state ();
3996                                         al->shift (pos, frames);
3997                                         XMLNode &after = al->get_state ();
3998                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3999                                 }
4000                         }
4001                 }
4002         }
4003 }
4004
4005 void
4006 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4007 {
4008         boost::shared_ptr<Processor> processor (p.lock ());
4009         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4010         if (!pi) {
4011                 return;
4012         }
4013         pi->set_state_dir (d);
4014 }
4015
4016 int
4017 Route::save_as_template (const string& path, const string& name)
4018 {
4019         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4020         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4021
4022         XMLNode& node (state (false));
4023         node.set_property (X_("name"), name);
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         Automatable::non_realtime_locate (pos);
4775
4776         if (_pannable) {
4777                 _pannable->non_realtime_locate (pos);
4778         }
4779
4780         if (_delayline.get()) {
4781                 _delayline.get()->flush();
4782         }
4783
4784         {
4785                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4786                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4787
4788                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4789                         (*i)->non_realtime_locate (pos);
4790                 }
4791         }
4792         _roll_delay = _initial_delay;
4793 }
4794
4795 void
4796 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4797 {
4798         size_t n_buffers;
4799         size_t i;
4800
4801         /* MIDI
4802          *
4803          * We don't currently mix MIDI input together, so we don't need the
4804          * complex logic of the audio case.
4805          */
4806
4807         n_buffers = bufs.count().n_midi ();
4808
4809         for (i = 0; i < n_buffers; ++i) {
4810
4811                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4812                 MidiBuffer& buf (bufs.get_midi (i));
4813
4814                 if (source_port) {
4815                         buf.copy (source_port->get_midi_buffer(nframes));
4816                 } else {
4817                         buf.silence (nframes);
4818                 }
4819         }
4820
4821         /* AUDIO */
4822
4823         n_buffers = bufs.count().n_audio();
4824
4825         size_t n_ports = io->n_ports().n_audio();
4826         float scaling = 1.0f;
4827
4828         if (n_ports > n_buffers) {
4829                 scaling = ((float) n_buffers) / n_ports;
4830         }
4831
4832         for (i = 0; i < n_ports; ++i) {
4833
4834                 /* if there are more ports than buffers, map them onto buffers
4835                  * in a round-robin fashion
4836                  */
4837
4838                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4839                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4840
4841
4842                 if (i < n_buffers) {
4843
4844                         /* first time through just copy a channel into
4845                            the output buffer.
4846                         */
4847
4848                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4849
4850                         if (scaling != 1.0f) {
4851                                 buf.apply_gain (scaling, nframes);
4852                         }
4853
4854                 } else {
4855
4856                         /* on subsequent times around, merge data from
4857                          * the port with what is already there
4858                          */
4859
4860                         if (scaling != 1.0f) {
4861                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4862                         } else {
4863                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4864                         }
4865                 }
4866         }
4867
4868         /* silence any remaining buffers */
4869
4870         for (; i < n_buffers; ++i) {
4871                 AudioBuffer& buf (bufs.get_audio (i));
4872                 buf.silence (nframes);
4873         }
4874
4875         /* establish the initial setup of the buffer set, reflecting what was
4876            copied into it. unless, of course, we are the auditioner, in which
4877            case nothing was fed into it from the inputs at all.
4878         */
4879
4880         if (!is_auditioner()) {
4881                 bufs.set_count (io->n_ports());
4882         }
4883 }
4884
4885 boost::shared_ptr<AutomationControl>
4886 Route::pan_azimuth_control() const
4887 {
4888 #ifdef MIXBUS
4889 # undef MIXBUS_PORTS_H
4890 # include "../../gtk2_ardour/mixbus_ports.h"
4891         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
4892         if (!plug) {
4893                 return boost::shared_ptr<AutomationControl>();
4894         }
4895         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
4896 #else
4897         if (!_pannable || !panner()) {
4898                 return boost::shared_ptr<AutomationControl>();
4899         }
4900         return _pannable->pan_azimuth_control;
4901 #endif
4902 }
4903
4904 boost::shared_ptr<AutomationControl>
4905 Route::pan_elevation_control() const
4906 {
4907         if (Profile->get_mixbus() || !_pannable || !panner()) {
4908                 return boost::shared_ptr<AutomationControl>();
4909         }
4910
4911         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4912
4913         if (c.find (PanElevationAutomation) != c.end()) {
4914                 return _pannable->pan_elevation_control;
4915         } else {
4916                 return boost::shared_ptr<AutomationControl>();
4917         }
4918 }
4919 boost::shared_ptr<AutomationControl>
4920 Route::pan_width_control() const
4921 {
4922 #ifdef MIXBUS
4923         if (mixbus() && _ch_pre) {
4924                 //mono blend
4925                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 5)));
4926         }
4927 #endif
4928         if (Profile->get_mixbus() || !_pannable || !panner()) {
4929                 return boost::shared_ptr<AutomationControl>();
4930         }
4931
4932         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4933
4934         if (c.find (PanWidthAutomation) != c.end()) {
4935                 return _pannable->pan_width_control;
4936         } else {
4937                 return boost::shared_ptr<AutomationControl>();
4938         }
4939 }
4940 boost::shared_ptr<AutomationControl>
4941 Route::pan_frontback_control() const
4942 {
4943         if (Profile->get_mixbus() || !_pannable || !panner()) {
4944                 return boost::shared_ptr<AutomationControl>();
4945         }
4946
4947         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4948
4949         if (c.find (PanFrontBackAutomation) != c.end()) {
4950                 return _pannable->pan_frontback_control;
4951         } else {
4952                 return boost::shared_ptr<AutomationControl>();
4953         }
4954 }
4955 boost::shared_ptr<AutomationControl>
4956 Route::pan_lfe_control() const
4957 {
4958         if (Profile->get_mixbus() || !_pannable || !panner()) {
4959                 return boost::shared_ptr<AutomationControl>();
4960         }
4961
4962         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4963
4964         if (c.find (PanLFEAutomation) != c.end()) {
4965                 return _pannable->pan_lfe_control;
4966         } else {
4967                 return boost::shared_ptr<AutomationControl>();
4968         }
4969 }
4970
4971 uint32_t
4972 Route::eq_band_cnt () const
4973 {
4974         if (Profile->get_mixbus()) {
4975 #ifdef MIXBUS32C
4976                 if (is_master() || mixbus()) {
4977                         return 3;
4978                 } else {
4979                         return 4;
4980                 }
4981 #else
4982                 return 3;
4983 #endif
4984         } else {
4985                 /* Ardour has no well-known EQ object */
4986                 return 0;
4987         }
4988 }
4989
4990 boost::shared_ptr<AutomationControl>
4991 Route::eq_gain_controllable (uint32_t band) const
4992 {
4993 #ifdef MIXBUS
4994         boost::shared_ptr<PluginInsert> eq = ch_eq();
4995
4996         if (!eq) {
4997                 return boost::shared_ptr<AutomationControl>();
4998         }
4999
5000         uint32_t port_number;
5001         if (is_master() || mixbus()) {
5002                 switch (band) {
5003                         case 0: port_number = 4; break;
5004                         case 1: port_number = 3; break;
5005                         case 2: port_number = 2; break;
5006                         default:
5007                                 return boost::shared_ptr<AutomationControl>();
5008                 }
5009         } else {
5010 #ifdef MIXBUS32C
5011                 switch (band) {
5012                         case 0: port_number = 14; break;
5013                         case 1: port_number = 12; break;
5014                         case 2: port_number = 10; break;
5015                         case 3: port_number =  8; break;
5016                         default:
5017                                 return boost::shared_ptr<AutomationControl>();
5018                 }
5019 #else
5020                 switch (band) {
5021                         case 0: port_number = 8; break;
5022                         case 1: port_number = 6; break;
5023                         case 2: port_number = 4; break;
5024                         default:
5025                                 return boost::shared_ptr<AutomationControl>();
5026                 }
5027 #endif
5028         }
5029
5030         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5031 #else
5032         return boost::shared_ptr<AutomationControl>();
5033 #endif
5034 }
5035 boost::shared_ptr<AutomationControl>
5036 Route::eq_freq_controllable (uint32_t band) const
5037 {
5038 #ifdef MIXBUS
5039         if (mixbus() || is_master()) {
5040                 /* no frequency controls for mixbusses or master */
5041                 return boost::shared_ptr<AutomationControl>();
5042         }
5043
5044         boost::shared_ptr<PluginInsert> eq = ch_eq();
5045
5046         if (!eq) {
5047                 return boost::shared_ptr<AutomationControl>();
5048         }
5049
5050         uint32_t port_number;
5051 #ifdef MIXBUS32C
5052         switch (band) {
5053                 case 0: port_number = 13; break; // lo
5054                 case 1: port_number = 11; break; // lo mid
5055                 case 2: port_number = 9; break; // hi mid
5056                 case 3: port_number = 7; break; // hi
5057                 default:
5058                         return boost::shared_ptr<AutomationControl>();
5059         }
5060 #else
5061         switch (band) {
5062                 case 0: port_number = 7; break;
5063                 case 1: port_number = 5; break;
5064                 case 2: port_number = 3; break;
5065                 default:
5066                         return boost::shared_ptr<AutomationControl>();
5067         }
5068 #endif
5069
5070         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5071 #else
5072         return boost::shared_ptr<AutomationControl>();
5073 #endif
5074 }
5075
5076 boost::shared_ptr<AutomationControl>
5077 Route::eq_q_controllable (uint32_t band) const
5078 {
5079         return boost::shared_ptr<AutomationControl>();
5080 }
5081
5082 boost::shared_ptr<AutomationControl>
5083 Route::eq_shape_controllable (uint32_t band) const
5084 {
5085 #ifdef MIXBUS32C
5086         boost::shared_ptr<PluginInsert> eq = ch_eq();
5087         if (is_master() || mixbus() || !eq) {
5088                 return boost::shared_ptr<AutomationControl>();
5089         }
5090         switch (band) {
5091                 case 0:
5092                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4))); // lo bell
5093                         break;
5094                 case 3:
5095                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3))); // hi bell
5096                         break;
5097                 default:
5098                         break;
5099         }
5100 #endif
5101         return boost::shared_ptr<AutomationControl>();
5102 }
5103
5104 boost::shared_ptr<AutomationControl>
5105 Route::eq_enable_controllable () const
5106 {
5107 #ifdef MIXBUS
5108         boost::shared_ptr<PluginInsert> eq = ch_eq();
5109
5110         if (!eq) {
5111                 return boost::shared_ptr<AutomationControl>();
5112         }
5113
5114         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5115 #else
5116         return boost::shared_ptr<AutomationControl>();
5117 #endif
5118 }
5119
5120 boost::shared_ptr<AutomationControl>
5121 Route::filter_freq_controllable (bool hpf) const
5122 {
5123 #ifdef MIXBUS
5124         boost::shared_ptr<PluginInsert> eq = ch_eq();
5125
5126         if (is_master() || mixbus() || !eq) {
5127                 return boost::shared_ptr<AutomationControl>();
5128         }
5129         if (hpf) {
5130 #ifdef MIXBUS32C
5131                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5))); // HPF freq
5132 #else
5133                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5134 #endif
5135         } else {
5136 #ifdef MIXBUS32C
5137                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6))); // LPF freq
5138 #else
5139                 return boost::shared_ptr<AutomationControl>();
5140 #endif
5141         }
5142
5143 #else
5144         return boost::shared_ptr<AutomationControl>();
5145 #endif
5146 }
5147
5148 boost::shared_ptr<AutomationControl>
5149 Route::filter_slope_controllable (bool) const
5150 {
5151         return boost::shared_ptr<AutomationControl>();
5152 }
5153
5154 boost::shared_ptr<AutomationControl>
5155 Route::filter_enable_controllable (bool) const
5156 {
5157 #ifdef MIXBUS32C
5158         boost::shared_ptr<PluginInsert> eq = ch_eq();
5159
5160         if (is_master() || mixbus() || !eq) {
5161                 return boost::shared_ptr<AutomationControl>();
5162         }
5163
5164         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5165 #else
5166         return boost::shared_ptr<AutomationControl>();
5167 #endif
5168 }
5169
5170 string
5171 Route::eq_band_name (uint32_t band) const
5172 {
5173 #ifdef MIXBUS32C
5174         if (is_master() || mixbus()) {
5175 #endif
5176         if (Profile->get_mixbus()) {
5177                 switch (band) {
5178                         case 0: return _("lo");
5179                         case 1: return _("mid");
5180                         case 2: return _("hi");
5181                         default: return string();
5182                 }
5183         } else {
5184                 return string ();
5185         }
5186 #ifdef MIXBUS32C
5187         } else {
5188                 switch (band) {
5189                         case 0: return _("lo");
5190                         case 1: return _("lo mid");
5191                         case 2: return _("hi mid");
5192                         case 3: return _("hi");
5193                         default: return string();
5194                 }
5195         }
5196 #endif
5197 }
5198
5199 boost::shared_ptr<AutomationControl>
5200 Route::comp_enable_controllable () const
5201 {
5202 #ifdef MIXBUS
5203         boost::shared_ptr<PluginInsert> comp = ch_comp();
5204
5205         if (!comp) {
5206                 return boost::shared_ptr<AutomationControl>();
5207         }
5208
5209         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5210 #else
5211         return boost::shared_ptr<AutomationControl>();
5212 #endif
5213 }
5214 boost::shared_ptr<AutomationControl>
5215 Route::comp_threshold_controllable () const
5216 {
5217 #ifdef MIXBUS
5218         boost::shared_ptr<PluginInsert> comp = ch_comp();
5219
5220         if (!comp) {
5221                 return boost::shared_ptr<AutomationControl>();
5222         }
5223
5224         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5225
5226 #else
5227         return boost::shared_ptr<AutomationControl>();
5228 #endif
5229 }
5230 boost::shared_ptr<AutomationControl>
5231 Route::comp_speed_controllable () const
5232 {
5233 #ifdef MIXBUS
5234         boost::shared_ptr<PluginInsert> comp = ch_comp();
5235
5236         if (!comp) {
5237                 return boost::shared_ptr<AutomationControl>();
5238         }
5239
5240         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5241 #else
5242         return boost::shared_ptr<AutomationControl>();
5243 #endif
5244 }
5245 boost::shared_ptr<AutomationControl>
5246 Route::comp_mode_controllable () const
5247 {
5248 #ifdef MIXBUS
5249         boost::shared_ptr<PluginInsert> comp = ch_comp();
5250
5251         if (!comp) {
5252                 return boost::shared_ptr<AutomationControl>();
5253         }
5254
5255         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5256 #else
5257         return boost::shared_ptr<AutomationControl>();
5258 #endif
5259 }
5260 boost::shared_ptr<AutomationControl>
5261 Route::comp_makeup_controllable () const
5262 {
5263 #ifdef MIXBUS
5264         boost::shared_ptr<PluginInsert> comp = ch_comp();
5265
5266         if (!comp) {
5267                 return boost::shared_ptr<AutomationControl>();
5268         }
5269
5270         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5271 #else
5272         return boost::shared_ptr<AutomationControl>();
5273 #endif
5274 }
5275 boost::shared_ptr<ReadOnlyControl>
5276 Route::comp_redux_controllable () const
5277 {
5278 #ifdef MIXBUS
5279         boost::shared_ptr<PluginInsert> comp = ch_comp();
5280
5281         if (!comp) {
5282                 return boost::shared_ptr<ReadOnlyControl>();
5283         }
5284         if (is_master()) {
5285                 return comp->control_output (2);
5286         } else {
5287                 return comp->control_output (6);
5288         }
5289
5290 #else
5291         return boost::shared_ptr<ReadOnlyControl>();
5292 #endif
5293 }
5294
5295 string
5296 Route::comp_mode_name (uint32_t mode) const
5297 {
5298 #ifdef MIXBUS
5299         switch (mode) {
5300         case 0:
5301                 return _("Leveler");
5302         case 1:
5303                 return _("Compressor");
5304         case 2:
5305                 return _("Limiter");
5306         case 3:
5307                 return mixbus() ? _("Sidechain") : _("Limiter");
5308         }
5309
5310         return _("???");
5311 #else
5312         return _("???");
5313 #endif
5314 }
5315
5316 string
5317 Route::comp_speed_name (uint32_t mode) const
5318 {
5319 #ifdef MIXBUS
5320         switch (mode) {
5321         case 0:
5322                 return _("Attk");
5323         case 1:
5324                 return _("Ratio");
5325         case 2:
5326         case 3:
5327                 return _("Rels");
5328         }
5329         return _("???");
5330 #else
5331         return _("???");
5332 #endif
5333 }
5334
5335 boost::shared_ptr<AutomationControl>
5336 Route::send_level_controllable (uint32_t n) const
5337 {
5338 #ifdef  MIXBUS
5339 # undef MIXBUS_PORTS_H
5340 # include "../../gtk2_ardour/mixbus_ports.h"
5341         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5342         if (plug && !mixbus()) {
5343                 uint32_t port_id = 0;
5344                 switch (n) {
5345                         case  0: port_id = port_channel_post_aux1_level; break;
5346                         case  1: port_id = port_channel_post_aux2_level; break;
5347                         case  2: port_id = port_channel_post_aux3_level; break;
5348                         case  3: port_id = port_channel_post_aux4_level; break;
5349                         case  4: port_id = port_channel_post_aux5_level; break;
5350                         case  5: port_id = port_channel_post_aux6_level; break;
5351                         case  6: port_id = port_channel_post_aux7_level; break;
5352                         case  7: port_id = port_channel_post_aux8_level; break;
5353 # ifdef MIXBUS32C
5354                         case  8: port_id = port_channel_post_aux9_level; break;
5355                         case  9: port_id = port_channel_post_aux10_level; break;
5356                         case 10: port_id = port_channel_post_aux11_level; break;
5357                         case 11: port_id = port_channel_post_aux12_level; break;
5358 # endif
5359                         default:
5360                                 break;
5361                 }
5362
5363                 if (port_id > 0) {
5364                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5365                 }
5366 # ifdef MIXBUS32C
5367                 assert (n > 11);
5368                 n -= 12;
5369 # else
5370                 assert (n > 7);
5371                 n -= 8;
5372 # endif
5373         }
5374 #endif
5375         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5376         if (!s) {
5377                 return boost::shared_ptr<AutomationControl>();
5378         }
5379         return s->gain_control ();
5380 }
5381
5382 boost::shared_ptr<AutomationControl>
5383 Route::send_enable_controllable (uint32_t n) const
5384 {
5385 #ifdef  MIXBUS
5386 # undef MIXBUS_PORTS_H
5387 # include "../../gtk2_ardour/mixbus_ports.h"
5388         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5389         if (plug && !mixbus()) {
5390                 uint32_t port_id = 0;
5391                 switch (n) {
5392                         case  0: port_id = port_channel_post_aux1_asgn; break;
5393                         case  1: port_id = port_channel_post_aux2_asgn; break;
5394                         case  2: port_id = port_channel_post_aux3_asgn; break;
5395                         case  3: port_id = port_channel_post_aux4_asgn; break;
5396                         case  4: port_id = port_channel_post_aux5_asgn; break;
5397                         case  5: port_id = port_channel_post_aux6_asgn; break;
5398                         case  6: port_id = port_channel_post_aux7_asgn; break;
5399                         case  7: port_id = port_channel_post_aux8_asgn; break;
5400 # ifdef MIXBUS32C
5401                         case  8: port_id = port_channel_post_aux9_asgn; break;
5402                         case  9: port_id = port_channel_post_aux10_asgn; break;
5403                         case 10: port_id = port_channel_post_aux11_asgn; break;
5404                         case 11: port_id = port_channel_post_aux12_asgn; break;
5405 # endif
5406                         default:
5407                                 break;
5408                 }
5409
5410                 if (port_id > 0) {
5411                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5412                 }
5413 # ifdef MIXBUS32C
5414                 assert (n > 11);
5415                 n -= 12;
5416 # else
5417                 assert (n > 7);
5418                 n -= 8;
5419 # endif
5420         }
5421 #endif
5422         /* although Ardour sends have enable/disable as part of the Processor
5423          * API, it is not exposed as a controllable.
5424          *
5425          * XXX: we should fix this (make it click-free, automatable enable-control)
5426          */
5427         return boost::shared_ptr<AutomationControl>();
5428 }
5429
5430 string
5431 Route::send_name (uint32_t n) const
5432 {
5433 #ifdef MIXBUS
5434         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5435         if (plug && !mixbus()) {
5436 # ifdef MIXBUS32C
5437                 if (n < 12) {
5438                         return _session.get_mixbus (n)->name();
5439                 }
5440                 n -= 12;
5441 #else
5442                 if (n < 8) {
5443                         return _session.get_mixbus (n)->name();
5444                 }
5445                 n -= 8;
5446 # endif
5447 #endif
5448         }
5449         boost::shared_ptr<Processor> p = nth_send (n);
5450         if (p) {
5451                 return p->name();
5452         } else {
5453                 return string();
5454         }
5455 }
5456
5457 boost::shared_ptr<AutomationControl>
5458 Route::master_send_enable_controllable () const
5459 {
5460 #ifdef  MIXBUS
5461         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5462         if (!plug) {
5463                 return boost::shared_ptr<AutomationControl>();
5464         }
5465 # undef MIXBUS_PORTS_H
5466 # include "../../gtk2_ardour/mixbus_ports.h"
5467         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5468 #else
5469         return boost::shared_ptr<AutomationControl>();
5470 #endif
5471 }
5472
5473 bool
5474 Route::slaved () const
5475 {
5476         if (!_gain_control) {
5477                 return false;
5478         }
5479         /* just test one particular control, not all of them */
5480         return _gain_control->slaved ();
5481 }
5482
5483 bool
5484 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5485 {
5486         if (!vca || !_gain_control) {
5487                 return false;
5488         }
5489
5490         /* just test one particular control, not all of them */
5491
5492         return _gain_control->slaved_to (vca->gain_control());
5493 }
5494
5495 bool
5496 Route::muted_by_others_soloing () const
5497 {
5498         if (!can_be_muted_by_others ()) {
5499                 return false;
5500         }
5501
5502         return  _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5503 }
5504
5505 void
5506 Route::clear_all_solo_state ()
5507 {
5508         _solo_control->clear_all_solo_state ();
5509 }
5510
5511 boost::shared_ptr<AutomationControl>
5512 Route::automation_control_recurse (PBD::ID const & id) const
5513 {
5514         boost::shared_ptr<AutomationControl> ac = Automatable::automation_control (id);
5515
5516         if (ac) {
5517                 return ac;
5518         }
5519
5520         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5521
5522         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5523                 if ((ac = (*i)->automation_control (id))) {
5524                         return ac;
5525                 }
5526         }
5527
5528         return boost::shared_ptr<AutomationControl> ();
5529 }
5530
5531 SlavableControlList
5532 Route::slavables () const
5533 {
5534         SlavableControlList rv;
5535         rv.push_back (_gain_control);
5536         rv.push_back (_mute_control);
5537         rv.push_back (_solo_control);
5538         return rv;
5539 }