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