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