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/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/unknown_processor.h"
  75 #include "ardour/utils.h"
  76 #include "ardour/vca.h"
  77
  78 #include "pbd/i18n.h"
  79
  80 using namespace std;
  81 using namespace ARDOUR;
  82 using namespace PBD;
  83
  84 PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, Route::PluginSetupOptions > Route::PluginSetup;
  85
  86 /** Base class for all routable/mixable objects (tracks and busses) */
  87 Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType default_type)
  88         : Stripable (sess, name, PresentationInfo (flag))
  89         , GraphNode (sess._process_graph)
  90         , Muteable (sess, name)
  91         , Automatable (sess)
  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> (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_is_affirmative (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 (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         char buf[32];
2320
2321         id().print (buf, sizeof (buf));
2322         node->add_property("id", buf);
2323         node->add_property ("name", _name);
2324         node->add_property("default-type", _default_type.to_string());
2325         node->add_property ("strict-io", _strict_io);
2326
2327         node->add_child_nocopy (_presentation_info.get_state());
2328
2329         node->add_property("active", _active?"yes":"no");
2330         string p;
2331         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2332         node->add_property("meter-point", enum_2_string (_meter_point));
2333
2334         node->add_property("meter-type", enum_2_string (_meter_type));
2335
2336         if (_route_group) {
2337                 node->add_property("route-group", _route_group->name());
2338         }
2339
2340         node->add_child_nocopy (_solo_control->get_state ());
2341         node->add_child_nocopy (_solo_isolate_control->get_state ());
2342         node->add_child_nocopy (_solo_safe_control->get_state ());
2343
2344         node->add_child_nocopy (_input->state (full_state));
2345         node->add_child_nocopy (_output->state (full_state));
2346         node->add_child_nocopy (_mute_master->get_state ());
2347
2348         node->add_child_nocopy (_mute_control->get_state ());
2349         node->add_child_nocopy (_phase_control->get_state ());
2350
2351         if (full_state) {
2352                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2353         }
2354
2355         if (_comment.length()) {
2356                 XMLNode *cmt = node->add_child ("Comment");
2357                 cmt->add_content (_comment);
2358         }
2359
2360         if (_pannable) {
2361                 node->add_child_nocopy (_pannable->state (full_state));
2362         }
2363
2364         {
2365                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2366                 for (i = _processors.begin(); i != _processors.end(); ++i) {
2367                         if (!full_state) {
2368                                 /* template save: do not include internal sends functioning as
2369                                          aux sends because the chance of the target ID
2370                                          in the session where this template is used
2371                                          is not very likely.
2372
2373                                          similarly, do not save listen sends which connect to
2374                                          the monitor section, because these will always be
2375                                          added if necessary.
2376                                          */
2377                                 boost::shared_ptr<InternalSend> is;
2378
2379                                 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2380                                         if (is->role() == Delivery::Listen) {
2381                                                 continue;
2382                                         }
2383                                 }
2384                         }
2385                         node->add_child_nocopy((*i)->state (full_state));
2386                 }
2387         }
2388
2389         if (_extra_xml) {
2390                 node->add_child_copy (*_extra_xml);
2391         }
2392
2393         if (_custom_meter_position_noted) {
2394                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2395                 if (after) {
2396                         after->id().print (buf, sizeof (buf));
2397                         node->add_property (X_("processor-after-last-custom-meter"), buf);
2398                 }
2399         }
2400
2401         if (!_session._template_state_dir.empty()) {
2402                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2403         }
2404
2405         node->add_child_copy (Slavable::get_state());
2406
2407         return *node;
2408 }
2409
2410 int
2411 Route::set_state (const XMLNode& node, int version)
2412 {
2413         if (version < 3000) {
2414                 return set_state_2X (node, version);
2415         }
2416
2417         XMLNodeList nlist;
2418         XMLNodeConstIterator niter;
2419         XMLNode *child;
2420         XMLProperty const * prop;
2421
2422         if (node.name() != "Route"){
2423                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2424                 return -1;
2425         }
2426
2427         if ((prop = node.property (X_("name"))) != 0) {
2428                 Route::set_name (prop->value());
2429         }
2430
2431         set_id (node);
2432         _initial_io_setup = true;
2433
2434         Stripable::set_state (node, version);
2435
2436         if ((prop = node.property (X_("strict-io"))) != 0) {
2437                 _strict_io = string_is_affirmative (prop->value());
2438         }
2439
2440         if (is_monitor()) {
2441                 /* monitor bus does not get a panner, but if (re)created
2442                    via XML, it will already have one by the time we
2443                    call ::set_state(). so ... remove it.
2444                 */
2445                 unpan ();
2446         }
2447
2448         /* add all processors (except amp, which is always present) */
2449
2450         nlist = node.children();
2451         XMLNode processor_state (X_("processor_state"));
2452
2453         Stateful::save_extra_xml (node);
2454
2455         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2456
2457                 child = *niter;
2458
2459                 if (child->name() == IO::state_node_name) {
2460                         if ((prop = child->property (X_("direction"))) == 0) {
2461                                 continue;
2462                         }
2463
2464                         if (prop->value() == "Input") {
2465                                 _input->set_state (*child, version);
2466                         } else if (prop->value() == "Output") {
2467                                 _output->set_state (*child, version);
2468                         }
2469
2470                 } else if (child->name() == X_("Processor")) {
2471                         processor_state.add_child_copy (*child);
2472                 } else if (child->name() == X_("Pannable")) {
2473                         if (_pannable) {
2474                                 _pannable->set_state (*child, version);
2475                         } else {
2476                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2477                         }
2478                 } else if (child->name() == Slavable::xml_node_name) {
2479                         Slavable::set_state (*child, version);
2480                 }
2481         }
2482
2483         if ((prop = node.property (X_("meter-point"))) != 0) {
2484                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2485                 set_meter_point (mp, true);
2486                 if (_meter) {
2487                         _meter->set_display_to_user (_meter_point == MeterCustom);
2488                 }
2489         }
2490
2491         if ((prop = node.property (X_("meter-type"))) != 0) {
2492                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2493         }
2494
2495         _initial_io_setup = false;
2496
2497         set_processor_state (processor_state);
2498
2499         // this looks up the internal instrument in processors
2500         reset_instrument_info();
2501
2502         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2503                 set_denormal_protection (string_is_affirmative (prop->value()));
2504         }
2505
2506         /* convert old 3001 state */
2507         if ((prop = node.property (X_("phase-invert"))) != 0) {
2508                 _phase_control->set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2509         }
2510
2511         if ((prop = node.property (X_("active"))) != 0) {
2512                 bool yn = string_is_affirmative (prop->value());
2513                 set_active (yn, this);
2514         }
2515
2516         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2517                 PBD::ID id (prop->value ());
2518                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2519                 ProcessorList::const_iterator i = _processors.begin ();
2520                 while (i != _processors.end() && (*i)->id() != id) {
2521                         ++i;
2522                 }
2523
2524                 if (i != _processors.end ()) {
2525                         _processor_after_last_custom_meter = *i;
2526                         _custom_meter_position_noted = true;
2527                 }
2528         }
2529
2530         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2531                 child = *niter;
2532
2533                 if (child->name() == X_("Comment")) {
2534
2535                         /* XXX this is a terrible API design in libxml++ */
2536
2537                         XMLNode *cmt = *(child->children().begin());
2538                         _comment = cmt->content();
2539
2540                 }  else if (child->name() == Controllable::xml_node_name) {
2541                         if ((prop = child->property (X_("name"))) == 0) {
2542                                 continue;
2543                         }
2544
2545                         if (prop->value() == _gain_control->name()) {
2546                                 _gain_control->set_state (*child, version);
2547                         } else if (prop->value() == _solo_control->name()) {
2548                                 _solo_control->set_state (*child, version);
2549                         } else if (prop->value() == _solo_safe_control->name()) {
2550                                 _solo_safe_control->set_state (*child, version);
2551                         } else if (prop->value() == _solo_isolate_control->name()) {
2552                                 _solo_isolate_control->set_state (*child, version);
2553                         } else if (prop->value() == _mute_control->name()) {
2554                                 _mute_control->set_state (*child, version);
2555                         } else if (prop->value() == _phase_control->name()) {
2556                                 _phase_control->set_state (*child, version);
2557                         } else {
2558                                 Evoral::Parameter p = EventTypeMap::instance().from_symbol (prop->value());
2559                                 if (p.type () >= MidiCCAutomation && p.type () < MidiSystemExclusiveAutomation) {
2560                                         boost::shared_ptr<AutomationControl> ac = automation_control (p, true);
2561                                         if (ac) {
2562                                                 ac->set_state (*child, version);
2563                                         }
2564                                 }
2565                         }
2566                 } else if (child->name() == MuteMaster::xml_node_name) {
2567                         _mute_master->set_state (*child, version);
2568
2569                 } else if (child->name() == Automatable::xml_node_name) {
2570                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2571                 }
2572         }
2573
2574         return 0;
2575 }
2576
2577 int
2578 Route::set_state_2X (const XMLNode& node, int version)
2579 {
2580         LocaleGuard lg;
2581         XMLNodeList nlist;
2582         XMLNodeConstIterator niter;
2583         XMLNode *child;
2584         XMLProperty const * prop;
2585
2586         /* 2X things which still remain to be handled:
2587          * default-type
2588          * automation
2589          * controlouts
2590          */
2591
2592         if (node.name() != "Route") {
2593                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2594                 return -1;
2595         }
2596
2597         Stripable::set_state (node, version);
2598
2599         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2600                 set_denormal_protection (string_is_affirmative (prop->value()));
2601         }
2602
2603         if ((prop = node.property (X_("muted"))) != 0) {
2604
2605                 bool first = true;
2606                 bool muted = string_is_affirmative (prop->value());
2607
2608                 if (muted) {
2609
2610                         string mute_point;
2611
2612                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2613
2614                                 if (string_is_affirmative (prop->value())){
2615                                         mute_point = mute_point + "PreFader";
2616                                         first = false;
2617                                 }
2618                         }
2619
2620                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2621
2622                                 if (string_is_affirmative (prop->value())){
2623
2624                                         if (!first) {
2625                                                 mute_point = mute_point + ",";
2626                                         }
2627
2628                                         mute_point = mute_point + "PostFader";
2629                                         first = false;
2630                                 }
2631                         }
2632
2633                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2634
2635                                 if (string_is_affirmative (prop->value())){
2636
2637                                         if (!first) {
2638                                                 mute_point = mute_point + ",";
2639                                         }
2640
2641                                         mute_point = mute_point + "Listen";
2642                                         first = false;
2643                                 }
2644                         }
2645
2646                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2647
2648                                 if (string_is_affirmative (prop->value())){
2649
2650                                         if (!first) {
2651                                                 mute_point = mute_point + ",";
2652                                         }
2653
2654                                         mute_point = mute_point + "Main";
2655                                 }
2656                         }
2657
2658                         _mute_master->set_mute_points (mute_point);
2659                         _mute_master->set_muted_by_self (true);
2660                 }
2661         }
2662
2663         if ((prop = node.property (X_("meter-point"))) != 0) {
2664                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2665         }
2666
2667         /* IOs */
2668
2669         nlist = node.children ();
2670         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2671
2672                 child = *niter;
2673
2674                 if (child->name() == IO::state_node_name) {
2675
2676                         /* there is a note in IO::set_state_2X() about why we have to call
2677                            this directly.
2678                            */
2679
2680                         _input->set_state_2X (*child, version, true);
2681                         _output->set_state_2X (*child, version, false);
2682
2683                         if ((prop = child->property (X_("name"))) != 0) {
2684                                 Route::set_name (prop->value ());
2685                         }
2686
2687                         set_id (*child);
2688
2689                         if ((prop = child->property (X_("active"))) != 0) {
2690                                 bool yn = string_is_affirmative (prop->value());
2691                                 _active = !yn; // force switch
2692                                 set_active (yn, this);
2693                         }
2694
2695                         if ((prop = child->property (X_("gain"))) != 0) {
2696                                 gain_t val;
2697
2698                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2699                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
2700                                 }
2701                         }
2702
2703                         /* Set up Panners in the IO */
2704                         XMLNodeList io_nlist = child->children ();
2705
2706                         XMLNodeConstIterator io_niter;
2707                         XMLNode *io_child;
2708
2709                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2710
2711                                 io_child = *io_niter;
2712
2713                                 if (io_child->name() == X_("Panner")) {
2714                                         _main_outs->panner_shell()->set_state(*io_child, version);
2715                                 } else if (io_child->name() == X_("Automation")) {
2716                                         /* IO's automation is for the fader */
2717                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2718                                 }
2719                         }
2720                 }
2721         }
2722
2723         XMLNodeList redirect_nodes;
2724
2725         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2726
2727                 child = *niter;
2728
2729                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2730                         redirect_nodes.push_back(child);
2731                 }
2732
2733         }
2734
2735         set_processor_state_2X (redirect_nodes, version);
2736
2737         Stateful::save_extra_xml (node);
2738
2739         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2740                 child = *niter;
2741
2742                 if (child->name() == X_("Comment")) {
2743
2744                         /* XXX this is a terrible API design in libxml++ */
2745
2746                         XMLNode *cmt = *(child->children().begin());
2747                         _comment = cmt->content();
2748
2749                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2750                         if (prop->value() == X_("solo")) {
2751                                 _solo_control->set_state (*child, version);
2752                         } else if (prop->value() == X_("mute")) {
2753                                 _mute_control->set_state (*child, version);
2754                         }
2755
2756                 }
2757         }
2758
2759         return 0;
2760 }
2761
2762 XMLNode&
2763 Route::get_processor_state ()
2764 {
2765         XMLNode* root = new XMLNode (X_("redirects"));
2766         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2767                 root->add_child_nocopy ((*i)->state (true));
2768         }
2769
2770         return *root;
2771 }
2772
2773 void
2774 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2775 {
2776         /* We don't bother removing existing processors not in nList, as this
2777            method will only be called when creating a Route from scratch, not
2778            for undo purposes.  Just put processors in at the appropriate place
2779            in the list.
2780         */
2781
2782         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2783                 add_processor_from_xml_2X (**i, version);
2784         }
2785 }
2786
2787 void
2788 Route::set_processor_state (const XMLNode& node)
2789 {
2790         const XMLNodeList &nlist = node.children();
2791         XMLNodeConstIterator niter;
2792         ProcessorList new_order;
2793         bool must_configure = false;
2794
2795         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2796
2797                 XMLProperty* prop = (*niter)->property ("type");
2798
2799                 if (prop->value() == "amp") {
2800                         _amp->set_state (**niter, Stateful::current_state_version);
2801                         new_order.push_back (_amp);
2802                 } else if (prop->value() == "trim") {
2803                         _trim->set_state (**niter, Stateful::current_state_version);
2804                         new_order.push_back (_trim);
2805                 } else if (prop->value() == "meter") {
2806                         _meter->set_state (**niter, Stateful::current_state_version);
2807                         new_order.push_back (_meter);
2808                 } else if (prop->value() == "delay") {
2809                         if (_delayline) {
2810                                 _delayline->set_state (**niter, Stateful::current_state_version);
2811                                 new_order.push_back (_delayline);
2812                         }
2813                 } else if (prop->value() == "main-outs") {
2814                         _main_outs->set_state (**niter, Stateful::current_state_version);
2815                 } else if (prop->value() == "intreturn") {
2816                         if (!_intreturn) {
2817                                 _intreturn.reset (new InternalReturn (_session));
2818                                 must_configure = true;
2819                         }
2820                         _intreturn->set_state (**niter, Stateful::current_state_version);
2821                 } else if (is_monitor() && prop->value() == "monitor") {
2822                         if (!_monitor_control) {
2823                                 _monitor_control.reset (new MonitorProcessor (_session));
2824                                 must_configure = true;
2825                         }
2826                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2827                 } else if (prop->value() == "capture") {
2828                         /* CapturingProcessor should never be restored, it's always
2829                            added explicitly when needed */
2830                 } else {
2831                         ProcessorList::iterator o;
2832
2833                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2834                                 XMLProperty const * id_prop = (*niter)->property(X_("id"));
2835                                 if (id_prop && (*o)->id() == id_prop->value()) {
2836                                         (*o)->set_state (**niter, Stateful::current_state_version);
2837                                         new_order.push_back (*o);
2838                                         break;
2839                                 }
2840                         }
2841
2842                         // If the processor (*niter) is not on the route then create it
2843
2844                         if (o == _processors.end()) {
2845
2846                                 boost::shared_ptr<Processor> processor;
2847
2848                                 if (prop->value() == "intsend") {
2849
2850                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
2851
2852                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2853                                            prop->value() == "lv2" ||
2854                                            prop->value() == "windows-vst" ||
2855                                            prop->value() == "mac-vst" ||
2856                                            prop->value() == "lxvst" ||
2857                                            prop->value() == "luaproc" ||
2858                                            prop->value() == "audiounit") {
2859
2860                                         if (_session.get_disable_all_loaded_plugins ()) {
2861                                                 processor.reset (new UnknownProcessor (_session, **niter));
2862                                         } else {
2863                                                 processor.reset (new PluginInsert (_session));
2864                                                 processor->set_owner (this);
2865                                                 if (_strict_io) {
2866                                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
2867                                                         pi->set_strict_io (true);
2868                                                 }
2869
2870                                         }
2871                                 } else if (prop->value() == "port") {
2872
2873                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2874
2875                                 } else if (prop->value() == "send") {
2876
2877                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
2878                                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
2879                                         send->SelfDestruct.connect_same_thread (*this,
2880                                                         boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
2881
2882                                 } else {
2883                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2884                                         continue;
2885                                 }
2886
2887                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2888                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2889                                         processor.reset (new UnknownProcessor (_session, **niter));
2890                                 }
2891
2892                                 /* subscribe to Sidechain IO changes */
2893                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
2894                                 if (pi && pi->has_sidechain ()) {
2895                                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2896                                 }
2897
2898                                 /* we have to note the monitor send here, otherwise a new one will be created
2899                                    and the state of this one will be lost.
2900                                 */
2901                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2902                                 if (isend && isend->role() == Delivery::Listen) {
2903                                         _monitor_send = isend;
2904                                 }
2905
2906                                 /* it doesn't matter if invisible processors are added here, as they
2907                                    will be sorted out by setup_invisible_processors () shortly.
2908                                 */
2909
2910                                 new_order.push_back (processor);
2911                                 must_configure = true;
2912                         }
2913                 }
2914         }
2915
2916         {
2917                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2918                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2919                 /* re-assign _processors w/o process-lock.
2920                  * if there's an IO-processor present in _processors but
2921                  * not in new_order, it will be deleted and ~IO takes
2922                  * a process lock.
2923                  */
2924                 _processors = new_order;
2925
2926                 if (must_configure) {
2927                         configure_processors_unlocked (0, &lm);
2928                 }
2929
2930                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2931
2932                         (*i)->set_owner (this);
2933                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2934
2935                         boost::shared_ptr<PluginInsert> pi;
2936
2937                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2938                                 if (pi->has_no_inputs ()) {
2939                                         _have_internal_generator = true;
2940                                         break;
2941                                 }
2942                         }
2943                 }
2944         }
2945
2946         reset_instrument_info ();
2947         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2948         set_processor_positions ();
2949 }
2950
2951 void
2952 Route::curve_reallocate ()
2953 {
2954 //      _gain_automation_curve.finish_resize ();
2955 //      _pan_automation_curve.finish_resize ();
2956 }
2957
2958 void
2959 Route::silence (framecnt_t nframes)
2960 {
2961         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2962         if (!lm.locked()) {
2963                 return;
2964         }
2965
2966         silence_unlocked (nframes);
2967 }
2968
2969 void
2970 Route::silence_unlocked (framecnt_t nframes)
2971 {
2972         /* Must be called with the processor lock held */
2973
2974         const framepos_t now = _session.transport_frame ();
2975
2976         if (!_silent) {
2977
2978                 _output->silence (nframes);
2979
2980                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2981                         boost::shared_ptr<PluginInsert> pi;
2982
2983                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2984                                 // skip plugins, they don't need anything when we're not active
2985                                 continue;
2986                         }
2987
2988                         (*i)->silence (nframes, now);
2989                 }
2990
2991                 if (nframes == _session.get_block_size()) {
2992                         // _silent = true;
2993                 }
2994         }
2995 }
2996
2997 void
2998 Route::add_internal_return ()
2999 {
3000         if (!_intreturn) {
3001                 _intreturn.reset (new InternalReturn (_session));
3002                 add_processor (_intreturn, PreFader);
3003         }
3004 }
3005
3006 void
3007 Route::add_send_to_internal_return (InternalSend* send)
3008 {
3009         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3010
3011         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3012                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3013
3014                 if (d) {
3015                         return d->add_send (send);
3016                 }
3017         }
3018 }
3019
3020 void
3021 Route::remove_send_from_internal_return (InternalSend* send)
3022 {
3023         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3024
3025         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3026                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3027
3028                 if (d) {
3029                         return d->remove_send (send);
3030                 }
3031         }
3032 }
3033
3034 void
3035 Route::enable_monitor_send ()
3036 {
3037         /* Caller must hold process lock */
3038         assert (!AudioEngine::instance()->process_lock().trylock());
3039
3040         /* master never sends to monitor section via the normal mechanism */
3041         assert (!is_master ());
3042         assert (!is_monitor ());
3043
3044         /* make sure we have one */
3045         if (!_monitor_send) {
3046                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3047                 _monitor_send->set_display_to_user (false);
3048         }
3049
3050         /* set it up */
3051         configure_processors (0);
3052 }
3053
3054 /** Add an aux send to a route.
3055  *  @param route route to send to.
3056  *  @param before Processor to insert before, or 0 to insert at the end.
3057  */
3058 int
3059 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3060 {
3061         assert (route != _session.monitor_out ());
3062
3063         {
3064                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3065
3066                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3067
3068                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3069
3070                         if (d && d->target_route() == route) {
3071                                 /* already listening via the specified IO: do nothing */
3072                                 return 0;
3073                         }
3074                 }
3075         }
3076
3077         try {
3078
3079                 boost::shared_ptr<InternalSend> listener;
3080
3081                 {
3082                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3083                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3084                 }
3085
3086                 add_processor (listener, before);
3087
3088         } catch (failed_constructor& err) {
3089                 return -1;
3090         }
3091
3092         return 0;
3093 }
3094
3095 void
3096 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3097 {
3098         ProcessorStreams err;
3099         ProcessorList::iterator tmp;
3100
3101         {
3102                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3103
3104                 /* have to do this early because otherwise processor reconfig
3105                  * will put _monitor_send back in the list
3106                  */
3107
3108                 if (route == _session.monitor_out()) {
3109                         _monitor_send.reset ();
3110                 }
3111
3112           again:
3113                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3114
3115                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3116
3117                         if (d && d->target_route() == route) {
3118                                 rl.release ();
3119                                 if (remove_processor (*x, &err, false) > 0) {
3120                                         rl.acquire ();
3121                                         continue;
3122                                 }
3123                                 rl.acquire ();
3124
3125                                 /* list could have been demolished while we dropped the lock
3126                                    so start over.
3127                                 */
3128                                 if (_session.engine().connected()) {
3129                                         /* i/o processors cannot be removed if the engine is not running
3130                                          * so don't live-loop in case the engine is N/A or dies
3131                                          */
3132                                         goto again;
3133                                 }
3134                         }
3135                 }
3136         }
3137 }
3138
3139 void
3140 Route::set_comment (string cmt, void *src)
3141 {
3142         _comment = cmt;
3143         comment_changed ();
3144         _session.set_dirty ();
3145 }
3146
3147 bool
3148 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3149 {
3150         FeedRecord fr (other, via_sends_only);
3151
3152         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3153
3154         if (!result.second) {
3155
3156                 /* already a record for "other" - make sure sends-only information is correct */
3157                 if (!via_sends_only && result.first->sends_only) {
3158                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3159                         frp->sends_only = false;
3160                 }
3161         }
3162
3163         return result.second;
3164 }
3165
3166 void
3167 Route::clear_fed_by ()
3168 {
3169         _fed_by.clear ();
3170 }
3171
3172 bool
3173 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3174 {
3175         const FedBy& fed_by (other->fed_by());
3176
3177         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3178                 boost::shared_ptr<Route> sr = f->r.lock();
3179
3180                 if (sr && (sr.get() == this)) {
3181
3182                         if (via_sends_only) {
3183                                 *via_sends_only = f->sends_only;
3184                         }
3185
3186                         return true;
3187                 }
3188         }
3189
3190         return false;
3191 }
3192
3193 IOVector
3194 Route::all_inputs () const
3195 {
3196         /* TODO, if this works as expected,
3197          * cache the IOVector and maintain it via
3198          * input_change_handler(), sidechain_change_handler() etc
3199          */
3200         IOVector ios;
3201         ios.push_back (_input);
3202
3203         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3204         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3205
3206                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3207                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3208                 if (pi != 0) {
3209                         assert (iop == 0);
3210                         iop = pi->sidechain();
3211                 }
3212
3213                 if (iop != 0 && iop->input()) {
3214                         ios.push_back (iop->input());
3215                 }
3216         }
3217         return ios;
3218 }
3219
3220 IOVector
3221 Route::all_outputs () const
3222 {
3223         IOVector ios;
3224         // _output is included via Delivery
3225         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3226         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3227                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3228                 if (iop != 0 && iop->output()) {
3229                         ios.push_back (iop->output());
3230                 }
3231         }
3232         return ios;
3233 }
3234
3235 bool
3236 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3237 {
3238         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3239         if (other->all_inputs().fed_by (_output)) {
3240                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3241                 if (via_send_only) {
3242                         *via_send_only = false;
3243                 }
3244
3245                 return true;
3246         }
3247
3248         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3249
3250         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3251
3252                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3253                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3254                 if (pi != 0) {
3255                         assert (iop == 0);
3256                         iop = pi->sidechain();
3257                 }
3258
3259                 if (iop != 0) {
3260                         boost::shared_ptr<const IO> iop_out = iop->output();
3261                         if (other.get() == this && iop_out && iop->input() && iop_out->connected_to (iop->input())) {
3262                                 // TODO this needs a delaylines in the Insert to align connections (!)
3263                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed its own return (%2)\n", iop->name(), other->name()));
3264                                 continue;
3265                         }
3266                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3267                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3268                                 if (via_send_only) {
3269                                         *via_send_only = true;
3270                                 }
3271                                 return true;
3272                         } else {
3273                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3274                         }
3275                 } else {
3276                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3277                 }
3278
3279         }
3280
3281         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3282         return false;
3283 }
3284
3285 bool
3286 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3287 {
3288         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3289 }
3290
3291 bool
3292 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3293 {
3294         return _session._current_route_graph.feeds (shared_from_this (), other);
3295 }
3296
3297 /** Called from the (non-realtime) butler thread when the transport is stopped */
3298 void
3299 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3300 {
3301         framepos_t now = _session.transport_frame();
3302
3303         {
3304                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3305
3306                 Automatable::transport_stopped (now);
3307
3308                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3309
3310                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3311                                 (*i)->flush ();
3312                         }
3313
3314                         (*i)->transport_stopped (now);
3315                 }
3316         }
3317
3318         _roll_delay = _initial_delay;
3319 }
3320
3321 void
3322 Route::input_change_handler (IOChange change, void * /*src*/)
3323 {
3324         if ((change.type & IOChange::ConfigurationChanged)) {
3325                 /* This is called with the process lock held if change
3326                    contains ConfigurationChanged
3327                 */
3328                 configure_processors (0);
3329                 _phase_control->resize (_input->n_ports().n_audio ());
3330                 io_changed (); /* EMIT SIGNAL */
3331         }
3332
3333         if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3334                 int sbou = 0;
3335                 int ibou = 0;
3336                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3337                 if (_input->connected()) {
3338                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3339                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3340                                         continue;
3341                                 }
3342                                 bool sends_only;
3343                                 bool does_feed = (*i)->direct_feeds_according_to_reality (shared_from_this(), &sends_only);
3344                                 if (does_feed && !sends_only) {
3345                                         if ((*i)->soloed()) {
3346                                                 ++sbou;
3347                                         }
3348                                         if ((*i)->solo_isolate_control()->solo_isolated()) {
3349                                                 ++ibou;
3350                                         }
3351                                 }
3352                         }
3353                 }
3354
3355                 int delta  = sbou - _solo_control->soloed_by_others_upstream();
3356                 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3357
3358                 if (idelta < -1) {
3359                         PBD::warning << string_compose (
3360                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3361                                         _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3362                                      << endmsg;
3363
3364                 }
3365
3366                 if (_solo_control->soloed_by_others_upstream()) {
3367                         // ignore new connections (they're not propagated)
3368                         if (delta <= 0) {
3369                                 _solo_control->mod_solo_by_others_upstream (delta);
3370                         }
3371                 }
3372
3373                 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3374                         // solo-isolate currently only propagates downstream
3375                         if (idelta < 0) {
3376                                 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3377                         }
3378                         //_solo_isolated_by_upstream = ibou;
3379                 }
3380
3381                 // Session::route_solo_changed  does not propagate indirect solo-changes
3382                 // propagate downstream to tracks
3383                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3384                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3385                                 continue;
3386                         }
3387                         bool sends_only;
3388                         bool does_feed = feeds (*i, &sends_only);
3389                         if (delta <= 0 && does_feed && !sends_only) {
3390                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3391                         }
3392
3393                         if (idelta < 0 && does_feed && !sends_only) {
3394                                 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3395                         }
3396                 }
3397         }
3398 }
3399
3400 void
3401 Route::output_change_handler (IOChange change, void * /*src*/)
3402 {
3403         if (_initial_io_setup) {
3404                 return;
3405         }
3406
3407         if ((change.type & IOChange::ConfigurationChanged)) {
3408                 /* This is called with the process lock held if change
3409                    contains ConfigurationChanged
3410                 */
3411                 configure_processors (0);
3412
3413                 if (is_master()) {
3414                         _session.reset_monitor_section();
3415                 }
3416
3417                 io_changed (); /* EMIT SIGNAL */
3418         }
3419
3420         if ((change.type & IOChange::ConnectionsChanged)) {
3421
3422                 /* do this ONLY if connections have changed. Configuration
3423                  * changes do not, by themselves alter solo upstream or
3424                  * downstream status.
3425                  */
3426
3427                 if (_solo_control->soloed_by_others_downstream()) {
3428                         int sbod = 0;
3429                         /* checking all all downstream routes for
3430                          * explicit of implict solo is a rather drastic measure,
3431                          * ideally the input_change_handler() of the other route
3432                          * would propagate the change to us.
3433                          */
3434                         boost::shared_ptr<RouteList> routes = _session.get_routes ();
3435                         if (_output->connected()) {
3436                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3437                                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3438                                                 continue;
3439                                         }
3440                                         bool sends_only;
3441                                         bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3442                                         if (does_feed && !sends_only) {
3443                                                 if ((*i)->soloed()) {
3444                                                         ++sbod;
3445                                                         break;
3446                                                 }
3447                                         }
3448                                 }
3449                         }
3450
3451                         int delta = sbod - _solo_control->soloed_by_others_downstream();
3452                         if (delta <= 0) {
3453                                 // do not allow new connections to change implicit solo (no propagation)
3454                                 _solo_control->mod_solo_by_others_downstream (delta);
3455                                 // Session::route_solo_changed() does not propagate indirect solo-changes
3456                                 // propagate upstream to tracks
3457                                 boost::shared_ptr<Route> shared_this = shared_from_this();
3458                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3459                                         if ((*i).get() == this || !can_solo()) {
3460                                                 continue;
3461                                         }
3462                                         bool sends_only;
3463                                         bool does_feed = (*i)->feeds (shared_this, &sends_only);
3464                                         if (delta != 0 && does_feed && !sends_only) {
3465                                                 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3466                                         }
3467                                 }
3468
3469                         }
3470                 }
3471         }
3472 }
3473
3474 void
3475 Route::sidechain_change_handler (IOChange change, void* src)
3476 {
3477         if (_initial_io_setup || _in_sidechain_setup) {
3478                 return;
3479         }
3480
3481         input_change_handler (change, src);
3482 }
3483
3484 uint32_t
3485 Route::pans_required () const
3486 {
3487         if (n_outputs().n_audio() < 2) {
3488                 return 0;
3489         }
3490
3491         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3492 }
3493
3494 void
3495 Route::flush_processor_buffers_locked (framecnt_t nframes)
3496 {
3497         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3498                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
3499                 if (d) {
3500                         d->flush_buffers (nframes);
3501                 } else {
3502                         boost::shared_ptr<PortInsert> p = boost::dynamic_pointer_cast<PortInsert> (*i);
3503                         if (p) {
3504                                 p->flush_buffers (nframes);
3505                         }
3506                 }
3507         }
3508 }
3509
3510 int
3511 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
3512 {
3513         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3514
3515         if (!lm.locked()) {
3516                 return 0;
3517         }
3518
3519         //MB has its own output path, regardless of physical outs
3520         if (!Profile->get_mixbus()) {
3521                 if (n_outputs().n_total() == 0) {
3522                         return 0;
3523                 }
3524
3525                 if (!_active || n_inputs() == ChanCount::ZERO)  {
3526                         silence_unlocked (nframes);
3527                         return 0;
3528                 }
3529         }
3530
3531         if (session_state_changing) {
3532                 if (_session.transport_speed() != 0.0f) {
3533                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3534                            so we cannot use them. Be silent till this is over.
3535
3536                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3537                         */
3538                         silence_unlocked (nframes);
3539                         return 0;
3540                 }
3541                 /* we're really not rolling, so we're either delivery silence or actually
3542                    monitoring, both of which are safe to do while session_state_changing is true.
3543                 */
3544         }
3545
3546         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3547
3548         fill_buffers_with_input (bufs, _input, nframes);
3549
3550         if (_meter_point == MeterInput) {
3551                 _meter->run (bufs, start_frame, end_frame, 0.0, nframes, true);
3552         }
3553
3554         _amp->apply_gain_automation (false);
3555         _trim->apply_gain_automation (false);
3556         passthru (bufs, start_frame, end_frame, nframes, 0);
3557
3558         flush_processor_buffers_locked (nframes);
3559
3560         return 0;
3561 }
3562
3563 int
3564 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3565 {
3566         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3567         if (!lm.locked()) {
3568                 return 0;
3569         }
3570
3571         //MB has its own signal path, regardless of I/O -- TODO handle !active for tracks & aux-busses)
3572         if (!Profile->get_mixbus()) {
3573                 if (n_outputs().n_total() == 0) {
3574                         return 0;
3575                 }
3576
3577                 if (!_active || n_inputs().n_total() == 0) {
3578                         silence_unlocked (nframes);
3579                         return 0;
3580                 }
3581         }
3582
3583         framepos_t unused = 0;
3584
3585         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3586                 return 0;
3587         }
3588
3589         _silent = false;
3590
3591         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3592
3593         fill_buffers_with_input (bufs, _input, nframes);
3594
3595         if (_meter_point == MeterInput) {
3596                 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
3597         }
3598
3599         passthru (bufs, start_frame, end_frame, nframes, declick);
3600
3601         flush_processor_buffers_locked (nframes);
3602
3603         return 0;
3604 }
3605
3606 int
3607 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3608 {
3609         silence (nframes);
3610         flush_processor_buffers_locked (nframes);
3611         return 0;
3612 }
3613
3614 void
3615 Route::flush_processors ()
3616 {
3617         /* XXX shouldn't really try to take this lock, since
3618            this is called from the RT audio thread.
3619         */
3620
3621         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3622
3623         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3624                 (*i)->flush ();
3625         }
3626 }
3627
3628 #ifdef __clang__
3629 __attribute__((annotate("realtime")))
3630 #endif
3631 bool
3632 Route::apply_processor_changes_rt ()
3633 {
3634         int emissions = EmitNone;
3635
3636         if (_pending_meter_point != _meter_point) {
3637                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3638                 if (pwl.locked()) {
3639                         /* meters always have buffers for 'processor_max_streams'
3640                          * they can be re-positioned without re-allocation */
3641                         if (set_meter_point_unlocked()) {
3642                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3643                         } else {
3644                                 emissions |= EmitMeterChanged;
3645                         }
3646                 }
3647         }
3648
3649         bool changed = false;
3650
3651         if (g_atomic_int_get (&_pending_process_reorder)) {
3652                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3653                 if (pwl.locked()) {
3654                         apply_processor_order (_pending_processor_order);
3655                         setup_invisible_processors ();
3656                         changed = true;
3657                         g_atomic_int_set (&_pending_process_reorder, 0);
3658                         emissions |= EmitRtProcessorChange;
3659                 }
3660         }
3661         if (changed) {
3662                 set_processor_positions ();
3663         }
3664         if (emissions != 0) {
3665                 g_atomic_int_set (&_pending_signals, emissions);
3666                 return true;
3667         }
3668         return (!selfdestruct_sequence.empty ());
3669 }
3670
3671 void
3672 Route::emit_pending_signals ()
3673 {
3674         int sig = g_atomic_int_and (&_pending_signals, 0);
3675         if (sig & EmitMeterChanged) {
3676                 _meter->emit_configuration_changed();
3677                 meter_change (); /* EMIT SIGNAL */
3678                 if (sig & EmitMeterVisibilityChange) {
3679                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3680                 } else {
3681                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3682                 }
3683         }
3684         if (sig & EmitRtProcessorChange) {
3685                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3686         }
3687
3688         /* this would be a job for the butler.
3689          * Conceptually we should not take processe/processor locks here.
3690          * OTOH its more efficient (less overhead for summoning the butler and
3691          * telling her what do do) and signal emission is called
3692          * directly after the process callback, which decreases the chance
3693          * of x-runs when taking the locks.
3694          */
3695         while (!selfdestruct_sequence.empty ()) {
3696                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3697                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3698                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3699                 selfdestruct_sequence.pop_back ();
3700                 lx.release ();
3701                 if (proc) {
3702                         remove_processor (proc);
3703                 }
3704         }
3705 }
3706
3707 void
3708 Route::set_meter_point (MeterPoint p, bool force)
3709 {
3710         if (_pending_meter_point == p && !force) {
3711                 return;
3712         }
3713
3714         if (force || !AudioEngine::instance()->running()) {
3715                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3716                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3717                 _pending_meter_point = p;
3718                 _meter->emit_configuration_changed();
3719                 meter_change (); /* EMIT SIGNAL */
3720                 if (set_meter_point_unlocked()) {
3721                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3722                 } else {
3723                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3724                 }
3725         } else {
3726                 _pending_meter_point = p;
3727         }
3728 }
3729
3730
3731 #ifdef __clang__
3732 __attribute__((annotate("realtime")))
3733 #endif
3734 bool
3735 Route::set_meter_point_unlocked ()
3736 {
3737 #ifndef NDEBUG
3738         /* Caller must hold process and processor write lock */
3739         assert (!AudioEngine::instance()->process_lock().trylock());
3740         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3741         assert (!lm.locked ());
3742 #endif
3743
3744         _meter_point = _pending_meter_point;
3745
3746         bool meter_was_visible_to_user = _meter->display_to_user ();
3747
3748         if (!_custom_meter_position_noted) {
3749                 maybe_note_meter_position ();
3750         }
3751
3752         if (_meter_point != MeterCustom) {
3753
3754                 _meter->set_display_to_user (false);
3755
3756                 setup_invisible_processors ();
3757
3758         } else {
3759                 _meter->set_display_to_user (true);
3760
3761                 /* If we have a previous position for the custom meter, try to put it there */
3762                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3763                 if (after) {
3764                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3765                         if (i != _processors.end ()) {
3766                                 _processors.remove (_meter);
3767                                 _processors.insert (i, _meter);
3768                         }
3769                 } else {// at end, right before the mains_out/panner
3770                         _processors.remove (_meter);
3771                         ProcessorList::iterator main = _processors.end();
3772                         _processors.insert (--main, _meter);
3773                 }
3774         }
3775
3776         /* Set up the meter for its new position */
3777
3778         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3779
3780         ChanCount m_in;
3781
3782         if (loc == _processors.begin()) {
3783                 m_in = _input->n_ports();
3784         } else {
3785                 ProcessorList::iterator before = loc;
3786                 --before;
3787                 m_in = (*before)->output_streams ();
3788         }
3789
3790         _meter->reflect_inputs (m_in);
3791
3792         /* we do not need to reconfigure the processors, because the meter
3793            (a) is always ready to handle processor_max_streams
3794            (b) is always an N-in/N-out processor, and thus moving
3795            it doesn't require any changes to the other processors.
3796         */
3797
3798         /* these should really be done after releasing the lock
3799          * but all those signals are subscribed to with gui_thread()
3800          * so we're safe.
3801          */
3802          return (_meter->display_to_user() != meter_was_visible_to_user);
3803 }
3804
3805 void
3806 Route::listen_position_changed ()
3807 {
3808         {
3809                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3810                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3811                 ProcessorState pstate (this);
3812
3813                 if (configure_processors_unlocked (0, &lm)) {
3814                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
3815                         pstate.restore ();
3816                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
3817                         return;
3818                 }
3819         }
3820
3821         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3822         _session.set_dirty ();
3823 }
3824
3825 boost::shared_ptr<CapturingProcessor>
3826 Route::add_export_point()
3827 {
3828         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3829         if (!_capturing_processor) {
3830                 lm.release();
3831                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3832                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
3833
3834                 // this aligns all tracks; but not tracks + busses
3835                 assert (_session.worst_track_latency () >= _initial_delay);
3836                 _capturing_processor.reset (new CapturingProcessor (_session, _session.worst_track_latency () - _initial_delay));
3837                 _capturing_processor->activate ();
3838
3839                 configure_processors_unlocked (0, &lw);
3840
3841         }
3842
3843         return _capturing_processor;
3844 }
3845
3846 framecnt_t
3847 Route::update_signal_latency ()
3848 {
3849         framecnt_t l = _output->user_latency();
3850         framecnt_t lamp = 0;
3851         bool before_amp = true;
3852         framecnt_t ltrim = 0;
3853         bool before_trim = true;
3854
3855         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3856                 if ((*i)->active ()) {
3857                         l += (*i)->signal_latency ();
3858                 }
3859                 if ((*i) == _amp) {
3860                         before_amp = false;
3861                 }
3862                 if ((*i) == _trim) {
3863                         before_amp = false;
3864                 }
3865                 if (before_amp) {
3866                         lamp = l;
3867                 }
3868                 if (before_trim) {
3869                         lamp = l;
3870                 }
3871         }
3872
3873         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3874
3875         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
3876         _signal_latency_at_amp_position = lamp;
3877         _signal_latency_at_trim_position = ltrim;
3878
3879         if (_signal_latency != l) {
3880                 _signal_latency = l;
3881                 signal_latency_changed (); /* EMIT SIGNAL */
3882         }
3883
3884         return _signal_latency;
3885 }
3886
3887 void
3888 Route::set_user_latency (framecnt_t nframes)
3889 {
3890         _output->set_user_latency (nframes);
3891         _session.update_latency_compensation ();
3892 }
3893
3894 void
3895 Route::set_latency_compensation (framecnt_t longest_session_latency)
3896 {
3897         framecnt_t old = _initial_delay;
3898
3899         if (_signal_latency < longest_session_latency) {
3900                 _initial_delay = longest_session_latency - _signal_latency;
3901         } else {
3902                 _initial_delay = 0;
3903         }
3904
3905         DEBUG_TRACE (DEBUG::Latency, string_compose (
3906                              "%1: compensate for maximum latency of %2,"
3907                              "given own latency of %3, using initial delay of %4\n",
3908                              name(), longest_session_latency, _signal_latency, _initial_delay));
3909
3910         if (_initial_delay != old) {
3911                 initial_delay_changed (); /* EMIT SIGNAL */
3912         }
3913
3914         if (_session.transport_stopped()) {
3915                 _roll_delay = _initial_delay;
3916         }
3917 }
3918
3919 void
3920 Route::set_block_size (pframes_t nframes)
3921 {
3922         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3923                 (*i)->set_block_size (nframes);
3924         }
3925
3926         _session.ensure_buffers (n_process_buffers ());
3927 }
3928
3929 void
3930 Route::protect_automation ()
3931 {
3932         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3933                 (*i)->protect_automation();
3934 }
3935
3936 /** @param declick 1 to set a pending declick fade-in,
3937  *                -1 to set a pending declick fade-out
3938  */
3939 void
3940 Route::set_pending_declick (int declick)
3941 {
3942         if (_declickable) {
3943                 /* this call is not allowed to turn off a pending declick */
3944                 if (declick) {
3945                         _pending_declick = declick;
3946                 }
3947         } else {
3948                 _pending_declick = 0;
3949         }
3950 }
3951
3952 /** Shift automation forwards from a particular place, thereby inserting time.
3953  *  Adds undo commands for any shifts that are performed.
3954  *
3955  * @param pos Position to start shifting from.
3956  * @param frames Amount to shift forwards by.
3957  */
3958
3959 void
3960 Route::shift (framepos_t pos, framecnt_t frames)
3961 {
3962         /* gain automation */
3963         {
3964                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3965
3966                 XMLNode &before = gc->alist()->get_state ();
3967                 gc->alist()->shift (pos, frames);
3968                 XMLNode &after = gc->alist()->get_state ();
3969                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3970         }
3971
3972         /* gain automation */
3973         {
3974                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
3975
3976                 XMLNode &before = gc->alist()->get_state ();
3977                 gc->alist()->shift (pos, frames);
3978                 XMLNode &after = gc->alist()->get_state ();
3979                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3980         }
3981
3982         // TODO mute automation ??
3983
3984         /* pan automation */
3985         if (_pannable) {
3986                 ControlSet::Controls& c (_pannable->controls());
3987
3988                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3989                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3990                         if (pc) {
3991                                 boost::shared_ptr<AutomationList> al = pc->alist();
3992                                 XMLNode& before = al->get_state ();
3993                                 al->shift (pos, frames);
3994                                 XMLNode& after = al->get_state ();
3995                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3996                         }
3997                 }
3998         }
3999
4000         /* redirect automation */
4001         {
4002                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4003                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
4004
4005                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
4006
4007                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
4008                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
4009                                 if (ac) {
4010                                         boost::shared_ptr<AutomationList> al = ac->alist();
4011                                         XMLNode &before = al->get_state ();
4012                                         al->shift (pos, frames);
4013                                         XMLNode &after = al->get_state ();
4014                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4015                                 }
4016                         }
4017                 }
4018         }
4019 }
4020
4021 void
4022 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4023 {
4024         boost::shared_ptr<Processor> processor (p.lock ());
4025         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4026         if (!pi) {
4027                 return;
4028         }
4029         pi->set_state_dir (d);
4030 }
4031
4032 int
4033 Route::save_as_template (const string& path, const string& name)
4034 {
4035         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4036         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4037
4038         XMLNode& node (state (false));
4039
4040         XMLTree tree;
4041
4042         IO::set_name_in_state (*node.children().front(), name);
4043
4044         tree.set_root (&node);
4045
4046         /* return zero on success, non-zero otherwise */
4047         return !tree.write (path.c_str());
4048 }
4049
4050
4051 bool
4052 Route::set_name (const string& str)
4053 {
4054         if (str.empty ()) {
4055                 return false;
4056         }
4057
4058         if (str == name()) {
4059                 return true;
4060         }
4061
4062         string name = Route::ensure_track_or_route_name (str, _session);
4063         SessionObject::set_name (name);
4064
4065         bool ret = (_input->set_name(name) && _output->set_name(name));
4066
4067         if (ret) {
4068                 /* rename the main outs. Leave other IO processors
4069                  * with whatever name they already have, because its
4070                  * just fine as it is (it will not contain the route
4071                  * name if its a port insert, port send or port return).
4072                  */
4073
4074                 if (_main_outs) {
4075                         if (_main_outs->set_name (name)) {
4076                                 /* XXX returning false here is stupid because
4077                                    we already changed the route name.
4078                                 */
4079                                 return false;
4080                         }
4081                 }
4082         }
4083
4084         return ret;
4085 }
4086
4087 /** Set the name of a route in an XML description.
4088  *  @param node XML <Route> node to set the name in.
4089  *  @param name New name.
4090  */
4091 void
4092 Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
4093 {
4094         node.add_property (X_("name"), name);
4095
4096         XMLNodeList children = node.children();
4097         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4098
4099                 if ((*i)->name() == X_("IO")) {
4100
4101                         IO::set_name_in_state (**i, name);
4102
4103                 } else if ((*i)->name() == X_("Processor")) {
4104
4105                         XMLProperty const * role = (*i)->property (X_("role"));
4106                         if (role && role->value() == X_("Main")) {
4107                                 (*i)->add_property (X_("name"), name);
4108                         }
4109
4110                 } else if ((*i)->name() == X_("Diskstream")) {
4111
4112                         if (rename_playlist) {
4113                                 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
4114                         }
4115                         (*i)->add_property (X_("name"), name);
4116
4117                 }
4118         }
4119 }
4120
4121 boost::shared_ptr<Send>
4122 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4123 {
4124         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4125
4126         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4127                 boost::shared_ptr<InternalSend> send;
4128
4129                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4130                         if (send->target_route() == target) {
4131                                 return send;
4132                         }
4133                 }
4134         }
4135
4136         return boost::shared_ptr<Send>();
4137 }
4138
4139 void
4140 Route::set_denormal_protection (bool yn)
4141 {
4142         if (_denormal_protection != yn) {
4143                 _denormal_protection = yn;
4144                 denormal_protection_changed (); /* EMIT SIGNAL */
4145         }
4146 }
4147
4148 bool
4149 Route::denormal_protection () const
4150 {
4151         return _denormal_protection;
4152 }
4153
4154 void
4155 Route::set_active (bool yn, void* src)
4156 {
4157         if (_session.transport_rolling()) {
4158                 return;
4159         }
4160
4161         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4162                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4163                 return;
4164         }
4165
4166         if (_active != yn) {
4167                 _active = yn;
4168                 _input->set_active (yn);
4169                 _output->set_active (yn);
4170                 active_changed (); // EMIT SIGNAL
4171                 _session.set_dirty ();
4172         }
4173 }
4174
4175 boost::shared_ptr<Pannable>
4176 Route::pannable() const
4177 {
4178         return _pannable;
4179 }
4180
4181 boost::shared_ptr<Panner>
4182 Route::panner() const
4183 {
4184         /* may be null ! */
4185         return _main_outs->panner_shell()->panner();
4186 }
4187
4188 boost::shared_ptr<PannerShell>
4189 Route::panner_shell() const
4190 {
4191         return _main_outs->panner_shell();
4192 }
4193
4194 boost::shared_ptr<GainControl>
4195 Route::gain_control() const
4196 {
4197         return _gain_control;
4198 }
4199
4200 boost::shared_ptr<GainControl>
4201 Route::trim_control() const
4202 {
4203         return _trim_control;
4204 }
4205
4206 boost::shared_ptr<PhaseControl>
4207 Route::phase_control() const
4208 {
4209         return _phase_control;
4210 }
4211
4212 boost::shared_ptr<AutomationControl>
4213 Route::get_control (const Evoral::Parameter& param)
4214 {
4215         /* either we own the control or .... */
4216
4217         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4218
4219         if (!c) {
4220
4221                 /* maybe one of our processors does or ... */
4222
4223                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4224                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4225                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4226                                 break;
4227                         }
4228                 }
4229         }
4230
4231         if (!c) {
4232
4233                 /* nobody does so we'll make a new one */
4234
4235                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4236                 add_control(c);
4237         }
4238
4239         return c;
4240 }
4241
4242 boost::shared_ptr<Processor>
4243 Route::nth_plugin (uint32_t n) const
4244 {
4245         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4246         ProcessorList::const_iterator i;
4247
4248         for (i = _processors.begin(); i != _processors.end(); ++i) {
4249                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4250                         if (n-- == 0) {
4251                                 return *i;
4252                         }
4253                 }
4254         }
4255
4256         return boost::shared_ptr<Processor> ();
4257 }
4258
4259 boost::shared_ptr<Processor>
4260 Route::nth_send (uint32_t n) const
4261 {
4262         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4263         ProcessorList::const_iterator i;
4264
4265         for (i = _processors.begin(); i != _processors.end(); ++i) {
4266                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4267
4268                         if ((*i)->name().find (_("Monitor")) == 0) {
4269                                 /* send to monitor section is not considered
4270                                    to be an accessible send.
4271                                 */
4272                                 continue;
4273                         }
4274
4275                         if (n-- == 0) {
4276                                 return *i;
4277                         }
4278                 }
4279         }
4280
4281         return boost::shared_ptr<Processor> ();
4282 }
4283
4284 bool
4285 Route::has_io_processor_named (const string& name)
4286 {
4287         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4288         ProcessorList::iterator i;
4289
4290         for (i = _processors.begin(); i != _processors.end(); ++i) {
4291                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4292                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4293                         if ((*i)->name() == name) {
4294                                 return true;
4295                         }
4296                 }
4297         }
4298
4299         return false;
4300 }
4301
4302 void
4303 Route::set_processor_positions ()
4304 {
4305         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4306
4307         bool had_amp = false;
4308         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4309                 (*i)->set_pre_fader (!had_amp);
4310                 if (*i == _amp) {
4311                         had_amp = true;
4312                 }
4313         }
4314 }
4315
4316 /** Called when there is a proposed change to the input port count */
4317 bool
4318 Route::input_port_count_changing (ChanCount to)
4319 {
4320         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4321         if (c.empty()) {
4322                 /* The processors cannot be configured with the new input arrangement, so
4323                    block the change.
4324                 */
4325                 return true;
4326         }
4327
4328         /* The change is ok */
4329         return false;
4330 }
4331
4332 /** Called when there is a proposed change to the output port count */
4333 bool
4334 Route::output_port_count_changing (ChanCount to)
4335 {
4336         if (_strict_io && !_in_configure_processors) {
4337                 return true;
4338         }
4339         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4340                 if (processor_out_streams.get(*t) > to.get(*t)) {
4341                         return true;
4342                 }
4343         }
4344         /* The change is ok */
4345         return false;
4346 }
4347
4348 list<string>
4349 Route::unknown_processors () const
4350 {
4351         list<string> p;
4352
4353         if (_session.get_disable_all_loaded_plugins ()) {
4354                 // Do not list "missing plugins" if they are explicitly disabled
4355                 return p;
4356         }
4357
4358         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4359         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4360                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4361                         p.push_back ((*i)->name ());
4362                 }
4363         }
4364
4365         return p;
4366 }
4367
4368
4369 framecnt_t
4370 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4371 {
4372         /* we assume that all our input ports feed all our output ports. its not
4373            universally true, but the alternative is way too corner-case to worry about.
4374         */
4375
4376         LatencyRange all_connections;
4377
4378         if (from.empty()) {
4379                 all_connections.min = 0;
4380                 all_connections.max = 0;
4381         } else {
4382                 all_connections.min = ~((pframes_t) 0);
4383                 all_connections.max = 0;
4384
4385                 /* iterate over all "from" ports and determine the latency range for all of their
4386                    connections to the "outside" (outside of this Route).
4387                 */
4388
4389                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4390
4391                         LatencyRange range;
4392
4393                         p->get_connected_latency_range (range, playback);
4394
4395                         all_connections.min = min (all_connections.min, range.min);
4396                         all_connections.max = max (all_connections.max, range.max);
4397                 }
4398         }
4399
4400         /* set the "from" port latencies to the max/min range of all their connections */
4401
4402         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4403                 p->set_private_latency_range (all_connections, playback);
4404         }
4405
4406         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4407
4408         all_connections.min += our_latency;
4409         all_connections.max += our_latency;
4410
4411         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4412                 p->set_private_latency_range (all_connections, playback);
4413         }
4414
4415         return all_connections.max;
4416 }
4417
4418 framecnt_t
4419 Route::set_private_port_latencies (bool playback) const
4420 {
4421         framecnt_t own_latency = 0;
4422
4423         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4424            OR LATENCY CALLBACK.
4425
4426            This is called (early) from the latency callback. It computes the REAL
4427            latency associated with each port and stores the result as the "private"
4428            latency of the port. A later call to Route::set_public_port_latencies()
4429            sets all ports to the same value to reflect the fact that we do latency
4430            compensation and so all signals are delayed by the same amount as they
4431            flow through ardour.
4432         */
4433
4434         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4435                 if ((*i)->active ()) {
4436                         own_latency += (*i)->signal_latency ();
4437                 }
4438         }
4439
4440         if (playback) {
4441                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4442                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4443         } else {
4444                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4445                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4446         }
4447 }
4448
4449 void
4450 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4451 {
4452         /* this is called to set the JACK-visible port latencies, which take
4453            latency compensation into account.
4454         */
4455
4456         LatencyRange range;
4457
4458         range.min = value;
4459         range.max = value;
4460
4461         {
4462                 const PortSet& ports (_input->ports());
4463                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4464                         p->set_public_latency_range (range, playback);
4465                 }
4466         }
4467
4468         {
4469                 const PortSet& ports (_output->ports());
4470                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4471                         p->set_public_latency_range (range, playback);
4472                 }
4473         }
4474 }
4475
4476 /** Put the invisible processors in the right place in _processors.
4477  *  Must be called with a writer lock on _processor_lock held.
4478  */
4479 #ifdef __clang__
4480 __attribute__((annotate("realtime")))
4481 #endif
4482 void
4483 Route::setup_invisible_processors ()
4484 {
4485 #ifndef NDEBUG
4486         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4487         assert (!lm.locked ());
4488 #endif
4489
4490         if (!_main_outs) {
4491                 /* too early to be doing this stuff */
4492                 return;
4493         }
4494
4495         /* we'll build this new list here and then use it
4496          *
4497          * TODO put the ProcessorList is on the stack for RT-safety.
4498          */
4499
4500         ProcessorList new_processors;
4501
4502         /* find visible processors */
4503
4504         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4505                 if ((*i)->display_to_user ()) {
4506                         new_processors.push_back (*i);
4507                 }
4508         }
4509
4510         /* find the amp */
4511
4512         ProcessorList::iterator amp = find (new_processors.begin(), new_processors.end(), _amp);
4513
4514         if (amp == new_processors.end ()) {
4515                 error << string_compose (_("Amp/Fader on Route '%1' went AWOL. Re-added."), name()) << endmsg;
4516                 new_processors.push_front (_amp);
4517                 amp = find (new_processors.begin(), new_processors.end(), _amp);
4518         }
4519
4520         /* and the processor after the amp */
4521
4522         ProcessorList::iterator after_amp = amp;
4523         ++after_amp;
4524
4525         /* METER */
4526
4527         if (_meter) {
4528                 switch (_meter_point) {
4529                 case MeterInput:
4530                         assert (!_meter->display_to_user ());
4531                         new_processors.push_front (_meter);
4532                         break;
4533                 case MeterPreFader:
4534                         assert (!_meter->display_to_user ());
4535                         new_processors.insert (amp, _meter);
4536                         break;
4537                 case MeterPostFader:
4538                         /* do nothing here */
4539                         break;
4540                 case MeterOutput:
4541                         /* do nothing here */
4542                         break;
4543                 case MeterCustom:
4544                         /* the meter is visible, so we don't touch it here */
4545                         break;
4546                 }
4547         }
4548
4549         /* MAIN OUTS */
4550
4551         assert (_main_outs);
4552         assert (!_main_outs->display_to_user ());
4553         new_processors.push_back (_main_outs);
4554
4555         /* iterator for the main outs */
4556
4557         ProcessorList::iterator main = new_processors.end();
4558         --main;
4559
4560         /* OUTPUT METERING */
4561
4562         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4563                 assert (!_meter->display_to_user ());
4564
4565                 /* add the processor just before or just after the main outs */
4566
4567                 ProcessorList::iterator meter_point = main;
4568
4569                 if (_meter_point == MeterOutput) {
4570                         ++meter_point;
4571                 }
4572                 new_processors.insert (meter_point, _meter);
4573         }
4574
4575         /* MONITOR SEND */
4576
4577         if (_monitor_send && !is_monitor ()) {
4578                 assert (!_monitor_send->display_to_user ());
4579                 switch (Config->get_listen_position ()) {
4580                 case PreFaderListen:
4581                         switch (Config->get_pfl_position ()) {
4582                         case PFLFromBeforeProcessors:
4583                                 new_processors.push_front (_monitor_send);
4584                                 break;
4585                         case PFLFromAfterProcessors:
4586                                 new_processors.insert (amp, _monitor_send);
4587                                 break;
4588                         }
4589                         _monitor_send->set_can_pan (false);
4590                         break;
4591                 case AfterFaderListen:
4592                         switch (Config->get_afl_position ()) {
4593                         case AFLFromBeforeProcessors:
4594                                 new_processors.insert (after_amp, _monitor_send);
4595                                 break;
4596                         case AFLFromAfterProcessors:
4597                                 new_processors.insert (new_processors.end(), _monitor_send);
4598                                 break;
4599                         }
4600                         _monitor_send->set_can_pan (true);
4601                         break;
4602                 }
4603         }
4604
4605 #if 0 // not used - just yet
4606         if (!is_master() && !is_monitor() && !is_auditioner()) {
4607                 new_processors.push_front (_delayline);
4608         }
4609 #endif
4610
4611         /* MONITOR CONTROL */
4612
4613         if (_monitor_control && is_monitor ()) {
4614                 assert (!_monitor_control->display_to_user ());
4615                 new_processors.insert (amp, _monitor_control);
4616         }
4617
4618         /* TRIM CONTROL */
4619
4620         if (_trim && _trim->active()) {
4621                 assert (!_trim->display_to_user ());
4622                 new_processors.push_front (_trim);
4623         }
4624
4625         /* INTERNAL RETURN */
4626
4627         /* doing this here means that any monitor control will come after
4628            the return and trim.
4629         */
4630
4631         if (_intreturn) {
4632                 assert (!_intreturn->display_to_user ());
4633                 new_processors.push_front (_intreturn);
4634         }
4635
4636         /* EXPORT PROCESSOR */
4637
4638         if (_capturing_processor) {
4639                 assert (!_capturing_processor->display_to_user ());
4640                 new_processors.push_front (_capturing_processor);
4641         }
4642
4643         _processors = new_processors;
4644
4645         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4646                 if (!(*i)->display_to_user () && !(*i)->enabled () && (*i) != _monitor_send) {
4647                         (*i)->enable (true);
4648                 }
4649         }
4650
4651         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4652         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4653                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4654         }
4655 }
4656
4657 void
4658 Route::unpan ()
4659 {
4660         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4661         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4662
4663         _pannable.reset ();
4664
4665         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4666                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4667                 if (d) {
4668                         d->unpan ();
4669                 }
4670         }
4671 }
4672
4673 /** If the meter point is `Custom', make a note of where the meter is.
4674  *  This is so that if the meter point is subsequently set to something else,
4675  *  and then back to custom, we can put the meter back where it was last time
4676  *  custom was enabled.
4677  *
4678  *  Must be called with the _processor_lock held.
4679  */
4680 void
4681 Route::maybe_note_meter_position ()
4682 {
4683         if (_meter_point != MeterCustom) {
4684                 return;
4685         }
4686
4687         _custom_meter_position_noted = true;
4688         /* custom meter points range from after trim to before panner/main_outs
4689          * this is a limitation by the current processor UI
4690          */
4691         bool seen_trim = false;
4692         _processor_after_last_custom_meter.reset();
4693         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4694                 if ((*i) == _trim) {
4695                         seen_trim = true;
4696                 }
4697                 if ((*i) == _main_outs) {
4698                         _processor_after_last_custom_meter = *i;
4699                         break;
4700                 }
4701                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4702                         if (!seen_trim) {
4703                                 _processor_after_last_custom_meter = _trim;
4704                         } else {
4705                                 ProcessorList::iterator j = i;
4706                                 ++j;
4707                                 assert(j != _processors.end ()); // main_outs should be before
4708                                 _processor_after_last_custom_meter = *j;
4709                         }
4710                         break;
4711                 }
4712         }
4713         assert(_processor_after_last_custom_meter.lock());
4714 }
4715
4716 boost::shared_ptr<Processor>
4717 Route::processor_by_id (PBD::ID id) const
4718 {
4719         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4720         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4721                 if ((*i)->id() == id) {
4722                         return *i;
4723                 }
4724         }
4725
4726         return boost::shared_ptr<Processor> ();
4727 }
4728
4729 /** @return the monitoring state, or in other words what data we are pushing
4730  *  into the route (data from the inputs, data from disk or silence)
4731  */
4732 MonitorState
4733 Route::monitoring_state () const
4734 {
4735         return MonitoringInput;
4736 }
4737
4738 /** @return what we should be metering; either the data coming from the input
4739  *  IO or the data that is flowing through the route.
4740  */
4741 MeterState
4742 Route::metering_state () const
4743 {
4744         return MeteringRoute;
4745 }
4746
4747 bool
4748 Route::has_external_redirects () const
4749 {
4750         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4751
4752                 /* ignore inactive processors and obviously ignore the main
4753                  * outs since everything has them and we don't care.
4754                  */
4755
4756                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4757                         return true;;
4758                 }
4759         }
4760
4761         return false;
4762 }
4763
4764 boost::shared_ptr<Processor>
4765 Route::the_instrument () const
4766 {
4767         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4768         return the_instrument_unlocked ();
4769 }
4770
4771 boost::shared_ptr<Processor>
4772 Route::the_instrument_unlocked () const
4773 {
4774         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4775                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
4776                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
4777                         return (*i);
4778                 }
4779         }
4780         return boost::shared_ptr<Processor>();
4781 }
4782
4783
4784
4785 void
4786 Route::non_realtime_locate (framepos_t pos)
4787 {
4788         if (_pannable) {
4789                 _pannable->transport_located (pos);
4790         }
4791
4792         if (_delayline.get()) {
4793                 _delayline.get()->flush();
4794         }
4795
4796         {
4797                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4798                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4799
4800                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4801                         (*i)->transport_located (pos);
4802                 }
4803         }
4804         _roll_delay = _initial_delay;
4805 }
4806
4807 void
4808 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4809 {
4810         size_t n_buffers;
4811         size_t i;
4812
4813         /* MIDI
4814          *
4815          * We don't currently mix MIDI input together, so we don't need the
4816          * complex logic of the audio case.
4817          */
4818
4819         n_buffers = bufs.count().n_midi ();
4820
4821         for (i = 0; i < n_buffers; ++i) {
4822
4823                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4824                 MidiBuffer& buf (bufs.get_midi (i));
4825
4826                 if (source_port) {
4827                         buf.copy (source_port->get_midi_buffer(nframes));
4828                 } else {
4829                         buf.silence (nframes);
4830                 }
4831         }
4832
4833         /* AUDIO */
4834
4835         n_buffers = bufs.count().n_audio();
4836
4837         size_t n_ports = io->n_ports().n_audio();
4838         float scaling = 1.0f;
4839
4840         if (n_ports > n_buffers) {
4841                 scaling = ((float) n_buffers) / n_ports;
4842         }
4843
4844         for (i = 0; i < n_ports; ++i) {
4845
4846                 /* if there are more ports than buffers, map them onto buffers
4847                  * in a round-robin fashion
4848                  */
4849
4850                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4851                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4852
4853
4854                 if (i < n_buffers) {
4855
4856                         /* first time through just copy a channel into
4857                            the output buffer.
4858                         */
4859
4860                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4861
4862                         if (scaling != 1.0f) {
4863                                 buf.apply_gain (scaling, nframes);
4864                         }
4865
4866                 } else {
4867
4868                         /* on subsequent times around, merge data from
4869                          * the port with what is already there
4870                          */
4871
4872                         if (scaling != 1.0f) {
4873                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4874                         } else {
4875                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4876                         }
4877                 }
4878         }
4879
4880         /* silence any remaining buffers */
4881
4882         for (; i < n_buffers; ++i) {
4883                 AudioBuffer& buf (bufs.get_audio (i));
4884                 buf.silence (nframes);
4885         }
4886
4887         /* establish the initial setup of the buffer set, reflecting what was
4888            copied into it. unless, of course, we are the auditioner, in which
4889            case nothing was fed into it from the inputs at all.
4890         */
4891
4892         if (!is_auditioner()) {
4893                 bufs.set_count (io->n_ports());
4894         }
4895 }
4896
4897 boost::shared_ptr<AutomationControl>
4898 Route::pan_azimuth_control() const
4899 {
4900 #ifdef MIXBUS
4901 # undef MIXBUS_PORTS_H
4902 # include "../../gtk2_ardour/mixbus_ports.h"
4903         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
4904         if (!plug) {
4905                 return boost::shared_ptr<AutomationControl>();
4906         }
4907         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
4908 #else
4909         if (!_pannable || !panner()) {
4910                 return boost::shared_ptr<AutomationControl>();
4911         }
4912         return _pannable->pan_azimuth_control;
4913 #endif
4914 }
4915
4916 boost::shared_ptr<AutomationControl>
4917 Route::pan_elevation_control() const
4918 {
4919         if (Profile->get_mixbus() || !_pannable || !panner()) {
4920                 return boost::shared_ptr<AutomationControl>();
4921         }
4922
4923         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4924
4925         if (c.find (PanElevationAutomation) != c.end()) {
4926                 return _pannable->pan_elevation_control;
4927         } else {
4928                 return boost::shared_ptr<AutomationControl>();
4929         }
4930 }
4931 boost::shared_ptr<AutomationControl>
4932 Route::pan_width_control() const
4933 {
4934 #ifdef MIXBUS
4935         if (mixbus() && _ch_pre) {
4936                 //mono blend
4937                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 5)));
4938         }
4939 #endif
4940         if (Profile->get_mixbus() || !_pannable || !panner()) {
4941                 return boost::shared_ptr<AutomationControl>();
4942         }
4943
4944         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4945
4946         if (c.find (PanWidthAutomation) != c.end()) {
4947                 return _pannable->pan_width_control;
4948         } else {
4949                 return boost::shared_ptr<AutomationControl>();
4950         }
4951 }
4952 boost::shared_ptr<AutomationControl>
4953 Route::pan_frontback_control() const
4954 {
4955         if (Profile->get_mixbus() || !_pannable || !panner()) {
4956                 return boost::shared_ptr<AutomationControl>();
4957         }
4958
4959         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4960
4961         if (c.find (PanFrontBackAutomation) != c.end()) {
4962                 return _pannable->pan_frontback_control;
4963         } else {
4964                 return boost::shared_ptr<AutomationControl>();
4965         }
4966 }
4967 boost::shared_ptr<AutomationControl>
4968 Route::pan_lfe_control() const
4969 {
4970         if (Profile->get_mixbus() || !_pannable || !panner()) {
4971                 return boost::shared_ptr<AutomationControl>();
4972         }
4973
4974         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
4975
4976         if (c.find (PanLFEAutomation) != c.end()) {
4977                 return _pannable->pan_lfe_control;
4978         } else {
4979                 return boost::shared_ptr<AutomationControl>();
4980         }
4981 }
4982
4983 uint32_t
4984 Route::eq_band_cnt () const
4985 {
4986         if (Profile->get_mixbus()) {
4987 #ifdef MIXBUS32C
4988                 if (is_master() || mixbus()) {
4989                         return 3;
4990                 } else {
4991                         return 4;
4992                 }
4993 #else
4994                 return 3;
4995 #endif
4996         } else {
4997                 /* Ardour has no well-known EQ object */
4998                 return 0;
4999         }
5000 }
5001
5002 boost::shared_ptr<AutomationControl>
5003 Route::eq_gain_controllable (uint32_t band) const
5004 {
5005 #ifdef MIXBUS
5006         boost::shared_ptr<PluginInsert> eq = ch_eq();
5007
5008         if (!eq) {
5009                 return boost::shared_ptr<AutomationControl>();
5010         }
5011
5012         uint32_t port_number;
5013         if (is_master() || mixbus()) {
5014                 switch (band) {
5015                         case 0: port_number = 4; break;
5016                         case 1: port_number = 3; break;
5017                         case 2: port_number = 2; break;
5018                         default:
5019                                 return boost::shared_ptr<AutomationControl>();
5020                 }
5021         } else {
5022 #ifdef MIXBUS32C
5023                 switch (band) {
5024                         case 0: port_number = 14; break;
5025                         case 1: port_number = 12; break;
5026                         case 2: port_number = 10; break;
5027                         case 3: port_number =  8; break;
5028                         default:
5029                                 return boost::shared_ptr<AutomationControl>();
5030                 }
5031 #else
5032                 switch (band) {
5033                         case 0: port_number = 8; break;
5034                         case 1: port_number = 6; break;
5035                         case 2: port_number = 4; break;
5036                         default:
5037                                 return boost::shared_ptr<AutomationControl>();
5038                 }
5039 #endif
5040         }
5041
5042         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5043 #else
5044         return boost::shared_ptr<AutomationControl>();
5045 #endif
5046 }
5047 boost::shared_ptr<AutomationControl>
5048 Route::eq_freq_controllable (uint32_t band) const
5049 {
5050 #ifdef MIXBUS
5051         if (mixbus() || is_master()) {
5052                 /* no frequency controls for mixbusses or master */
5053                 return boost::shared_ptr<AutomationControl>();
5054         }
5055
5056         boost::shared_ptr<PluginInsert> eq = ch_eq();
5057
5058         if (!eq) {
5059                 return boost::shared_ptr<AutomationControl>();
5060         }
5061
5062         uint32_t port_number;
5063 #ifdef MIXBUS32C
5064         switch (band) {
5065                 case 0: port_number = 13; break;
5066                 case 1: port_number = 11; break;
5067                 case 2: port_number = 9; break;
5068                 case 3: port_number = 7; break;
5069                 default:
5070                         return boost::shared_ptr<AutomationControl>();
5071         }
5072 #else
5073         switch (band) {
5074                 case 0: port_number = 7; break;
5075                 case 1: port_number = 5; break;
5076                 case 2: port_number = 3; break;
5077                 default:
5078                         return boost::shared_ptr<AutomationControl>();
5079         }
5080 #endif
5081
5082         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5083 #else
5084         return boost::shared_ptr<AutomationControl>();
5085 #endif
5086 }
5087
5088 boost::shared_ptr<AutomationControl>
5089 Route::eq_q_controllable (uint32_t band) const
5090 {
5091         return boost::shared_ptr<AutomationControl>();
5092 }
5093
5094 boost::shared_ptr<AutomationControl>
5095 Route::eq_shape_controllable (uint32_t band) const
5096 {
5097         return boost::shared_ptr<AutomationControl>();
5098 }
5099
5100 boost::shared_ptr<AutomationControl>
5101 Route::eq_enable_controllable () const
5102 {
5103 #ifdef MIXBUS
5104         boost::shared_ptr<PluginInsert> eq = ch_eq();
5105
5106         if (!eq) {
5107                 return boost::shared_ptr<AutomationControl>();
5108         }
5109
5110         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5111 #else
5112         return boost::shared_ptr<AutomationControl>();
5113 #endif
5114 }
5115
5116 boost::shared_ptr<AutomationControl>
5117 Route::eq_hpf_controllable () const
5118 {
5119 #ifdef MIXBUS
5120         boost::shared_ptr<PluginInsert> eq = ch_eq();
5121
5122         if (is_master() || mixbus() || !eq) {
5123                 return boost::shared_ptr<AutomationControl>();
5124         }
5125 #ifdef MIXBUS32C
5126         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5127 #else
5128         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5129 #endif
5130
5131 #else
5132         return boost::shared_ptr<AutomationControl>();
5133 #endif
5134 }
5135
5136 string
5137 Route::eq_band_name (uint32_t band) const
5138 {
5139 #ifdef MIXBUS32C
5140         if (is_master() || mixbus()) {
5141 #endif
5142         if (Profile->get_mixbus()) {
5143                 switch (band) {
5144                         case 0: return _("lo");
5145                         case 1: return _("mid");
5146                         case 2: return _("hi");
5147                         default: return string();
5148                 }
5149         } else {
5150                 return string ();
5151         }
5152 #ifdef MIXBUS32C
5153         } else {
5154                 switch (band) {
5155                         case 0: return _("lo");
5156                         case 1: return _("lo mid");
5157                         case 2: return _("hi mid");
5158                         case 3: return _("hi");
5159                         default: return string();
5160                 }
5161         }
5162 #endif
5163 }
5164
5165 boost::shared_ptr<AutomationControl>
5166 Route::comp_enable_controllable () const
5167 {
5168 #ifdef MIXBUS
5169         boost::shared_ptr<PluginInsert> comp = ch_comp();
5170
5171         if (!comp) {
5172                 return boost::shared_ptr<AutomationControl>();
5173         }
5174
5175         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5176 #else
5177         return boost::shared_ptr<AutomationControl>();
5178 #endif
5179 }
5180 boost::shared_ptr<AutomationControl>
5181 Route::comp_threshold_controllable () const
5182 {
5183 #ifdef MIXBUS
5184         boost::shared_ptr<PluginInsert> comp = ch_comp();
5185
5186         if (!comp) {
5187                 return boost::shared_ptr<AutomationControl>();
5188         }
5189
5190         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5191
5192 #else
5193         return boost::shared_ptr<AutomationControl>();
5194 #endif
5195 }
5196 boost::shared_ptr<AutomationControl>
5197 Route::comp_speed_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, 3)));
5207 #else
5208         return boost::shared_ptr<AutomationControl>();
5209 #endif
5210 }
5211 boost::shared_ptr<AutomationControl>
5212 Route::comp_mode_controllable () const
5213 {
5214 #ifdef MIXBUS
5215         boost::shared_ptr<PluginInsert> comp = ch_comp();
5216
5217         if (!comp) {
5218                 return boost::shared_ptr<AutomationControl>();
5219         }
5220
5221         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5222 #else
5223         return boost::shared_ptr<AutomationControl>();
5224 #endif
5225 }
5226 boost::shared_ptr<AutomationControl>
5227 Route::comp_makeup_controllable () const
5228 {
5229 #ifdef MIXBUS
5230         boost::shared_ptr<PluginInsert> comp = ch_comp();
5231
5232         if (!comp) {
5233                 return boost::shared_ptr<AutomationControl>();
5234         }
5235
5236         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5237 #else
5238         return boost::shared_ptr<AutomationControl>();
5239 #endif
5240 }
5241 boost::shared_ptr<ReadOnlyControl>
5242 Route::comp_redux_controllable () const
5243 {
5244 #ifdef MIXBUS
5245         boost::shared_ptr<PluginInsert> comp = ch_comp();
5246
5247         if (!comp) {
5248                 return boost::shared_ptr<ReadOnlyControl>();
5249         }
5250         if (is_master()) {
5251                 return comp->control_output (2);
5252         } else {
5253                 return comp->control_output (6);
5254         }
5255
5256 #else
5257         return boost::shared_ptr<ReadOnlyControl>();
5258 #endif
5259 }
5260
5261 string
5262 Route::comp_mode_name (uint32_t mode) const
5263 {
5264 #ifdef MIXBUS
5265         switch (mode) {
5266         case 0:
5267                 return _("Leveler");
5268         case 1:
5269                 return _("Compressor");
5270         case 2:
5271                 return _("Limiter");
5272         case 3:
5273                 return mixbus() ? _("Sidechain") : _("Limiter");
5274         }
5275
5276         return _("???");
5277 #else
5278         return _("???");
5279 #endif
5280 }
5281
5282 string
5283 Route::comp_speed_name (uint32_t mode) const
5284 {
5285 #ifdef MIXBUS
5286         switch (mode) {
5287         case 0:
5288                 return _("Attk");
5289         case 1:
5290                 return _("Ratio");
5291         case 2:
5292         case 3:
5293                 return _("Rels");
5294         }
5295         return _("???");
5296 #else
5297         return _("???");
5298 #endif
5299 }
5300
5301 boost::shared_ptr<AutomationControl>
5302 Route::send_level_controllable (uint32_t n) const
5303 {
5304 #ifdef  MIXBUS
5305 # undef MIXBUS_PORTS_H
5306 # include "../../gtk2_ardour/mixbus_ports.h"
5307         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5308         if (plug) {
5309                 uint32_t port_id = 0;
5310                 switch (n) {
5311                         case  0: port_id = port_channel_post_aux1_level; break;
5312                         case  1: port_id = port_channel_post_aux2_level; break;
5313                         case  2: port_id = port_channel_post_aux3_level; break;
5314                         case  3: port_id = port_channel_post_aux4_level; break;
5315                         case  4: port_id = port_channel_post_aux5_level; break;
5316                         case  5: port_id = port_channel_post_aux6_level; break;
5317                         case  6: port_id = port_channel_post_aux7_level; break;
5318                         case  7: port_id = port_channel_post_aux8_level; break;
5319 # ifdef MIXBUS32C
5320                         case  8: port_id = port_channel_post_aux9_level; break;
5321                         case  9: port_id = port_channel_post_aux10_level; break;
5322                         case 10: port_id = port_channel_post_aux11_level; break;
5323                         case 11: port_id = port_channel_post_aux12_level; break;
5324 # endif
5325                         default:
5326                                 break;
5327                 }
5328
5329                 if (port_id > 0) {
5330                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5331                 }
5332 # ifdef MIXBUS32C
5333                 assert (n > 11);
5334                 n -= 12;
5335 # else
5336                 assert (n > 7);
5337                 n -= 8;
5338 # endif
5339         }
5340 #endif
5341         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5342         if (!s) {
5343                 return boost::shared_ptr<AutomationControl>();
5344         }
5345         return s->gain_control ();
5346 }
5347
5348 boost::shared_ptr<AutomationControl>
5349 Route::send_enable_controllable (uint32_t n) const
5350 {
5351 #ifdef  MIXBUS
5352 # undef MIXBUS_PORTS_H
5353 # include "../../gtk2_ardour/mixbus_ports.h"
5354         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5355         if (plug) {
5356                 uint32_t port_id = 0;
5357                 switch (n) {
5358                         case  0: port_id = port_channel_post_aux1_asgn; break;
5359                         case  1: port_id = port_channel_post_aux2_asgn; break;
5360                         case  2: port_id = port_channel_post_aux3_asgn; break;
5361                         case  3: port_id = port_channel_post_aux4_asgn; break;
5362                         case  4: port_id = port_channel_post_aux5_asgn; break;
5363                         case  5: port_id = port_channel_post_aux6_asgn; break;
5364                         case  6: port_id = port_channel_post_aux7_asgn; break;
5365                         case  7: port_id = port_channel_post_aux8_asgn; break;
5366 # ifdef MIXBUS32C
5367                         case  8: port_id = port_channel_post_aux9_asgn; break;
5368                         case  9: port_id = port_channel_post_aux10_asgn; break;
5369                         case 10: port_id = port_channel_post_aux11_asgn; break;
5370                         case 11: port_id = port_channel_post_aux12_asgn; break;
5371 # endif
5372                         default:
5373                                 break;
5374                 }
5375
5376                 if (port_id > 0) {
5377                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5378                 }
5379 # ifdef MIXBUS32C
5380                 assert (n > 11);
5381                 n -= 12;
5382 # else
5383                 assert (n > 7);
5384                 n -= 8;
5385 # endif
5386         }
5387 #endif
5388         /* although Ardour sends have enable/disable as part of the Processor
5389          * API, it is not exposed as a controllable.
5390          *
5391          * XXX: we should fix this (make it click-free, automatable enable-control)
5392          */
5393         return boost::shared_ptr<AutomationControl>();
5394 }
5395
5396 string
5397 Route::send_name (uint32_t n) const
5398 {
5399 #ifdef MIXBUS
5400 # ifdef MIXBUS32C
5401         if (n < 12) {
5402                 return _session.get_mixbus (n)->name();
5403         }
5404         n -= 12;
5405 #else
5406         if (n < 8) {
5407                 return _session.get_mixbus (n)->name();
5408         }
5409         n -= 8;
5410 # endif
5411 #endif
5412         boost::shared_ptr<Processor> p = nth_send (n);
5413         if (p) {
5414                 return p->name();
5415         } else {
5416                 return string();
5417         }
5418 }
5419
5420 boost::shared_ptr<AutomationControl>
5421 Route::master_send_enable_controllable () const
5422 {
5423 #ifdef  MIXBUS
5424         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5425         if (!plug) {
5426                 return boost::shared_ptr<AutomationControl>();
5427         }
5428 # undef MIXBUS_PORTS_H
5429 # include "../../gtk2_ardour/mixbus_ports.h"
5430         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5431 #else
5432         return boost::shared_ptr<AutomationControl>();
5433 #endif
5434 }
5435
5436 bool
5437 Route::slaved () const
5438 {
5439         if (!_gain_control) {
5440                 return false;
5441         }
5442         /* just test one particular control, not all of them */
5443         return _gain_control->slaved ();
5444 }
5445
5446 bool
5447 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5448 {
5449         if (!vca || !_gain_control) {
5450                 return false;
5451         }
5452
5453         /* just test one particular control, not all of them */
5454
5455         return _gain_control->slaved_to (vca->gain_control());
5456 }
5457
5458 bool
5459 Route::muted_by_others_soloing () const
5460 {
5461         if (!can_be_muted_by_others ()) {
5462                 return false;
5463         }
5464
5465         return  _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5466 }
5467
5468 void
5469 Route::clear_all_solo_state ()
5470 {
5471         _solo_control->clear_all_solo_state ();
5472 }