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 <fstream>
  26 #include <cassert>
  27 #include <algorithm>
  28
  29 #include "pbd/xml++.h"
  30 #include "pbd/enumwriter.h"
  31 #include "pbd/memento_command.h"
  32 #include "pbd/stacktrace.h"
  33 #include "pbd/convert.h"
  34 #include "pbd/boost_debug.h"
  35
  36 #include "evoral/Curve.hpp"
  37
  38 #include "ardour/amp.h"
  39 #include "ardour/audio_port.h"
  40 #include "ardour/audioengine.h"
  41 #include "ardour/buffer.h"
  42 #include "ardour/buffer_set.h"
  43 #include "ardour/configuration.h"
  44 #include "ardour/cycle_timer.h"
  45 #include "ardour/debug.h"
  46 #include "ardour/delivery.h"
  47 #include "ardour/dB.h"
  48 #include "ardour/internal_send.h"
  49 #include "ardour/internal_return.h"
  50 #include "ardour/ladspa_plugin.h"
  51 #include "ardour/meter.h"
  52 #include "ardour/mix.h"
  53 #include "ardour/monitor_processor.h"
  54 #include "ardour/pannable.h"
  55 #include "ardour/panner.h"
  56 #include "ardour/panner_shell.h"
  57 #include "ardour/plugin_insert.h"
  58 #include "ardour/port.h"
  59 #include "ardour/port_insert.h"
  60 #include "ardour/processor.h"
  61 #include "ardour/profile.h"
  62 #include "ardour/route.h"
  63 #include "ardour/route_group.h"
  64 #include "ardour/send.h"
  65 #include "ardour/session.h"
  66 #include "ardour/timestamps.h"
  67 #include "ardour/utils.h"
  68 #include "ardour/graph.h"
  69 #include "ardour/unknown_processor.h"
  70 #include "ardour/capturing_processor.h"
  71
  72 #include "i18n.h"
  73
  74 using namespace std;
  75 using namespace ARDOUR;
  76 using namespace PBD;
  77
  78 uint32_t Route::order_key_cnt = 0;
  79 PBD::Signal1<void,string const&> Route::SyncOrderKeys;
  80 PBD::Signal0<void> Route::RemoteControlIDChange;
  81
  82 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
  83         : SessionObject (sess, name)
  84         , Automatable (sess)
  85         , GraphNode( sess.route_graph )
  86         , _active (true)
  87         , _initial_delay (0)
  88         , _roll_delay (0)
  89         , _flags (flg)
  90         , _pending_declick (true)
  91         , _meter_point (MeterPostFader)
  92         , _self_solo (false)
  93         , _soloed_by_others_upstream (0)
  94         , _soloed_by_others_downstream (0)
  95         , _solo_isolated (0)
  96         , _denormal_protection (false)
  97         , _recordable (true)
  98         , _silent (false)
  99         , _declickable (false)
 100         , _mute_master (new MuteMaster (sess, name))
 101         , _have_internal_generator (false)
 102         , _solo_safe (false)
 103         , _default_type (default_type)
 104         , _remote_control_id (0)
 105         , _in_configure_processors (false)
 106 {
 107         processor_max_streams.reset();
 108         order_keys[N_("signal")] = order_key_cnt++;
 109 }
 110
 111 int
 112 Route::init ()
 113 {
 114         /* add standard controls */
 115
 116         _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
 117         _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
 118
 119         _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
 120         _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
 121
 122         add_control (_solo_control);
 123         add_control (_mute_control);
 124
 125         /* panning */
 126
 127         Pannable* p = new Pannable (_session);
 128 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
 129         boost_debug_shared_ptr_mark_interesting (p, "Pannable");
 130 #endif
 131         _pannable.reset (p);
 132
 133         /* input and output objects */
 134
 135         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 136         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 137
 138         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
 139         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
 140
 141         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 142
 143         /* add amp processor  */
 144
 145         _amp.reset (new Amp (_session));
 146         add_processor (_amp, PostFader);
 147
 148         /* create standard processors: meter, main outs, monitor out;
 149            they will be added to _processors by setup_invisible_processors ()
 150         */
 151
 152         _meter.reset (new PeakMeter (_session));
 153         _meter->set_display_to_user (false);
 154         _meter->activate ();
 155
 156         _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
 157         _main_outs->activate ();
 158
 159         if (is_monitor()) {
 160                 /* where we listen to tracks */
 161                 _intreturn.reset (new InternalReturn (_session));
 162                 _intreturn->activate ();
 163
 164                 /* the thing that provides proper control over a control/monitor/listen bus
 165                    (such as per-channel cut, dim, solo, invert, etc).
 166                  */
 167                 _monitor_control.reset (new MonitorProcessor (_session));
 168                 _monitor_control->activate ();
 169         }
 170
 171         if (is_master() || is_monitor() || is_hidden()) {
 172                 _mute_master->set_solo_ignore (true);
 173         }
 174
 175         /* now that we have _meter, its safe to connect to this */
 176
 177         Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
 178
 179         {
 180                 /* run a configure so that the invisible processors get set up */
 181                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 182                 configure_processors (0);
 183         }
 184
 185         return 0;
 186 }
 187
 188 Route::~Route ()
 189 {
 190         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
 191
 192         /* do this early so that we don't get incoming signals as we are going through destruction
 193          */
 194
 195         drop_connections ();
 196
 197         /* don't use clear_processors here, as it depends on the session which may
 198            be half-destroyed by now
 199         */
 200
 201         Glib::RWLock::WriterLock lm (_processor_lock);
 202         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 203                 (*i)->drop_references ();
 204         }
 205
 206         _processors.clear ();
 207 }
 208
 209 void
 210 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
 211 {
 212         if (id != _remote_control_id) {
 213                 _remote_control_id = id;
 214                 RemoteControlIDChanged ();
 215                 if (notify_class_listeners) {
 216                         RemoteControlIDChange ();
 217                 }
 218         }
 219 }
 220
 221 uint32_t
 222 Route::remote_control_id() const
 223 {
 224         return _remote_control_id;
 225 }
 226
 227 int32_t
 228 Route::order_key (std::string const & name) const
 229 {
 230         OrderKeys::const_iterator i = order_keys.find (name);
 231         if (i == order_keys.end()) {
 232                 return -1;
 233         }
 234
 235         return i->second;
 236 }
 237
 238 void
 239 Route::set_order_key (std::string const & name, int32_t n)
 240 {
 241         bool changed = false;
 242
 243         /* This method looks more complicated than it should, but
 244            it's important that we don't emit order_key_changed unless
 245            it actually has, as expensive things happen on receipt of that
 246            signal.
 247         */
 248
 249         if (order_keys.find(name) == order_keys.end() || order_keys[name] != n) {
 250                 order_keys[name] = n;
 251                 changed = true;
 252         }
 253
 254         if (Config->get_sync_all_route_ordering()) {
 255                 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
 256                         if (x->second != n) {
 257                                 x->second = n;
 258                                 changed = true;
 259                         }
 260                 }
 261         }
 262
 263         if (changed) {
 264                 order_key_changed (); /* EMIT SIGNAL */
 265                 _session.set_dirty ();
 266         }
 267 }
 268
 269 /** Set all order keys to be the same as that for `base', if such a key
 270  *  exists in this route.
 271  *  @param base Base key.
 272  */
 273 void
 274 Route::sync_order_keys (std::string const & base)
 275 {
 276         if (order_keys.empty()) {
 277                 return;
 278         }
 279
 280         OrderKeys::iterator i;
 281         int32_t key;
 282
 283         if ((i = order_keys.find (base)) == order_keys.end()) {
 284                 /* key doesn't exist, use the first existing key (during session initialization) */
 285                 i = order_keys.begin();
 286                 key = i->second;
 287                 ++i;
 288         } else {
 289                 /* key exists - use it and reset all others (actually, itself included) */
 290                 key = i->second;
 291                 i = order_keys.begin();
 292         }
 293
 294         bool changed = false;
 295
 296         for (; i != order_keys.end(); ++i) {
 297                 if (i->second != key) {
 298                         i->second = key;
 299                         changed = true;
 300                 }
 301         }
 302
 303         if (changed) {
 304                 order_key_changed (); /* EMIT SIGNAL */
 305         }
 306 }
 307
 308 string
 309 Route::ensure_track_or_route_name(string name, Session &session)
 310 {
 311         string newname = name;
 312
 313         while (!session.io_name_is_legal (newname)) {
 314                 newname = bump_name_once (newname, '.');
 315         }
 316
 317         return newname;
 318 }
 319
 320
 321 void
 322 Route::inc_gain (gain_t fraction, void *src)
 323 {
 324         _amp->inc_gain (fraction, src);
 325 }
 326
 327 void
 328 Route::set_gain (gain_t val, void *src)
 329 {
 330         if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
 331
 332                 if (_route_group->is_relative()) {
 333
 334                         gain_t usable_gain = _amp->gain();
 335                         if (usable_gain < 0.000001f) {
 336                                 usable_gain = 0.000001f;
 337                         }
 338
 339                         gain_t delta = val;
 340                         if (delta < 0.000001f) {
 341                                 delta = 0.000001f;
 342                         }
 343
 344                         delta -= usable_gain;
 345
 346                         if (delta == 0.0f)
 347                                 return;
 348
 349                         gain_t factor = delta / usable_gain;
 350
 351                         if (factor > 0.0f) {
 352                                 factor = _route_group->get_max_factor(factor);
 353                                 if (factor == 0.0f) {
 354                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 355                                         return;
 356                                 }
 357                         } else {
 358                                 factor = _route_group->get_min_factor(factor);
 359                                 if (factor == 0.0f) {
 360                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 361                                         return;
 362                                 }
 363                         }
 364
 365                         _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
 366
 367                 } else {
 368
 369                         _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
 370                 }
 371
 372                 return;
 373         }
 374
 375         if (val == _amp->gain()) {
 376                 return;
 377         }
 378
 379         _amp->set_gain (val, src);
 380 }
 381
 382 /** Process this route for one (sub) cycle (process thread)
 383  *
 384  * @param bufs Scratch buffers to use for the signal path
 385  * @param start_frame Initial transport frame
 386  * @param end_frame Final transport frame
 387  * @param nframes Number of frames to output (to ports)
 388  *
 389  * Note that (end_frame - start_frame) may not be equal to nframes when the
 390  * transport speed isn't 1.0 (eg varispeed).
 391  */
 392 void
 393 Route::process_output_buffers (BufferSet& bufs,
 394                                framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
 395                                bool /*with_processors*/, int declick,
 396                                bool gain_automation_ok)
 397 {
 398         bool monitor = should_monitor ();
 399
 400         bufs.is_silent (false);
 401
 402         if (!declick) {
 403                 declick = _pending_declick;
 404         }
 405
 406         /* figure out if we're going to use gain automation */
 407         if (gain_automation_ok) {
 408                 _amp->setup_gain_automation (start_frame, end_frame, nframes);
 409         } else {
 410                 _amp->apply_gain_automation (false);
 411         }
 412
 413         /* tell main outs what to do about monitoring */
 414         _main_outs->no_outs_cuz_we_no_monitor (!monitor);
 415
 416
 417         /* -------------------------------------------------------------------------------------------
 418            GLOBAL DECLICK (for transport changes etc.)
 419            ----------------------------------------------------------------------------------------- */
 420
 421         if (declick > 0) {
 422                 Amp::declick (bufs, nframes, 1);
 423         } else if (declick < 0) {
 424                 Amp::declick (bufs, nframes, -1);
 425         }
 426
 427         _pending_declick = 0;
 428
 429         /* -------------------------------------------------------------------------------------------
 430            DENORMAL CONTROL/PHASE INVERT
 431            ----------------------------------------------------------------------------------------- */
 432
 433         if (_phase_invert.any ()) {
 434
 435                 int chn = 0;
 436
 437                 if (_denormal_protection || Config->get_denormal_protection()) {
 438
 439                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 440                                 Sample* const sp = i->data();
 441
 442                                 if (_phase_invert[chn]) {
 443                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 444                                                 sp[nx]  = -sp[nx];
 445                                                 sp[nx] += 1.0e-27f;
 446                                         }
 447                                 } else {
 448                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 449                                                 sp[nx] += 1.0e-27f;
 450                                         }
 451                                 }
 452                         }
 453
 454                 } else {
 455
 456                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 457                                 Sample* const sp = i->data();
 458
 459                                 if (_phase_invert[chn]) {
 460                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 461                                                 sp[nx] = -sp[nx];
 462                                         }
 463                                 }
 464                         }
 465                 }
 466
 467         } else {
 468
 469                 if (_denormal_protection || Config->get_denormal_protection()) {
 470
 471                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 472                                 Sample* const sp = i->data();
 473                                 for (pframes_t nx = 0; nx < nframes; ++nx) {
 474                                         sp[nx] += 1.0e-27f;
 475                                 }
 476                         }
 477
 478                 }
 479         }
 480
 481         /* -------------------------------------------------------------------------------------------
 482            and go ....
 483            ----------------------------------------------------------------------------------------- */
 484
 485         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 486
 487                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
 488                         break;
 489                 }
 490
 491 #ifndef NDEBUG
 492                 /* if it has any inputs, make sure they match */
 493                 if ((*i)->input_streams() != ChanCount::ZERO) {
 494                         if (bufs.count() != (*i)->input_streams()) {
 495                                 cerr << _name << " bufs = " << bufs.count()
 496                                      << " input for " << (*i)->name() << " = " << (*i)->input_streams()
 497                                      << endl;
 498                                 abort ();
 499                         }
 500                 }
 501 #endif
 502                 /* should we NOT run plugins here if the route is inactive?
 503                    do we catch route != active somewhere higher?
 504                 */
 505
 506                 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
 507                 bufs.set_count ((*i)->output_streams());
 508         }
 509 }
 510
 511 ChanCount
 512 Route::n_process_buffers ()
 513 {
 514         return max (_input->n_ports(), processor_max_streams);
 515 }
 516
 517 void
 518 Route::passthru (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 519 {
 520         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 521
 522         _silent = false;
 523
 524         assert (bufs.available() >= input_streams());
 525
 526         if (_input->n_ports() == ChanCount::ZERO) {
 527                 silence_unlocked (nframes);
 528         }
 529
 530         bufs.set_count (input_streams());
 531
 532         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
 533
 534                 /* control/monitor bus ignores input ports when something is
 535                    feeding the listen "stream". data will "arrive" into the
 536                    route from the intreturn processor element.
 537                 */
 538                 bufs.silence (nframes, 0);
 539
 540         } else {
 541
 542                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 543
 544                         BufferSet::iterator o = bufs.begin(*t);
 545                         PortSet& ports (_input->ports());
 546
 547                         for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
 548                                 o->read_from (i->get_buffer(nframes), nframes);
 549                         }
 550                 }
 551         }
 552
 553         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 554         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, true);
 555 }
 556
 557 void
 558 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 559 {
 560         BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
 561         bufs.set_count (_input->n_ports());
 562         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 563         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, false);
 564 }
 565
 566 void
 567 Route::set_listen (bool yn, void* src)
 568 {
 569         if (_solo_safe) {
 570                 return;
 571         }
 572
 573         if (_monitor_send) {
 574                 if (yn != _monitor_send->active()) {
 575                         if (yn) {
 576                                 _monitor_send->activate ();
 577                                 _mute_master->set_soloed (true);
 578                         } else {
 579                                 _monitor_send->deactivate ();
 580                                 _mute_master->set_soloed (false);
 581                         }
 582
 583                         listen_changed (src); /* EMIT SIGNAL */
 584                 }
 585         }
 586 }
 587
 588 bool
 589 Route::listening_via_monitor () const
 590 {
 591         if (_monitor_send) {
 592                 return _monitor_send->active ();
 593         } else {
 594                 return false;
 595         }
 596 }
 597
 598 void
 599 Route::set_solo_safe (bool yn, void *src)
 600 {
 601         if (_solo_safe != yn) {
 602                 _solo_safe = yn;
 603                 solo_safe_changed (src);
 604         }
 605 }
 606
 607 bool
 608 Route::solo_safe() const
 609 {
 610         return _solo_safe;
 611 }
 612
 613 void
 614 Route::set_solo (bool yn, void *src)
 615 {
 616         if (_solo_safe) {
 617                 return;
 618         }
 619
 620         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 621                 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
 622                 return;
 623         }
 624
 625         if (self_soloed() != yn) {
 626                 set_self_solo (yn);
 627                 set_mute_master_solo ();
 628                 solo_changed (true, src); /* EMIT SIGNAL */
 629                 _solo_control->Changed (); /* EMIT SIGNAL */
 630         }
 631 }
 632
 633 void
 634 Route::set_self_solo (bool yn)
 635 {
 636         _self_solo = yn;
 637 }
 638
 639 void
 640 Route::mod_solo_by_others_upstream (int32_t delta)
 641 {
 642         if (_solo_safe) {
 643                 return;
 644         }
 645
 646         uint32_t old_sbu = _soloed_by_others_upstream;
 647
 648         if (delta < 0) {
 649                 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
 650                         _soloed_by_others_upstream += delta;
 651                 } else {
 652                         _soloed_by_others_upstream = 0;
 653                 }
 654         } else {
 655                 _soloed_by_others_upstream += delta;
 656         }
 657
 658         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
 659                                                   name(), delta, _soloed_by_others_upstream, old_sbu,
 660                                                   _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
 661
 662         /* push the inverse solo change to everything that feeds us.
 663
 664            This is important for solo-within-group. When we solo 1 track out of N that
 665            feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
 666            on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
 667            tracks that feed it. This will silence them if they were audible because
 668            of a bus solo, but the newly soloed track will still be audible (because
 669            it is self-soloed).
 670
 671            but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
 672            not in reverse.
 673          */
 674
 675         if ((_self_solo || _soloed_by_others_downstream) &&
 676             ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
 677              (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
 678
 679                 if (delta > 0 || !Config->get_exclusive_solo()) {
 680                         DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
 681                         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
 682                                 boost::shared_ptr<Route> sr = i->r.lock();
 683                                 if (sr) {
 684                                         sr->mod_solo_by_others_downstream (-delta);
 685                                 }
 686                         }
 687                 }
 688         }
 689
 690         set_mute_master_solo ();
 691         solo_changed (false, this);
 692 }
 693
 694 void
 695 Route::mod_solo_by_others_downstream (int32_t delta)
 696 {
 697         if (_solo_safe) {
 698                 return;
 699         }
 700
 701         if (delta < 0) {
 702                 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
 703                         _soloed_by_others_downstream += delta;
 704                 } else {
 705                         _soloed_by_others_downstream = 0;
 706                 }
 707         } else {
 708                 _soloed_by_others_downstream += delta;
 709         }
 710
 711         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
 712
 713         set_mute_master_solo ();
 714         solo_changed (false, this);
 715 }
 716
 717 void
 718 Route::set_mute_master_solo ()
 719 {
 720         _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
 721 }
 722
 723 void
 724 Route::set_solo_isolated (bool yn, void *src)
 725 {
 726         if (is_master() || is_monitor() || is_hidden()) {
 727                 return;
 728         }
 729
 730         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 731                 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
 732                 return;
 733         }
 734
 735         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
 736
 737         boost::shared_ptr<RouteList> routes = _session.get_routes ();
 738         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 739
 740                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
 741                         continue;
 742                 }
 743
 744                 bool sends_only;
 745                 bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
 746
 747                 if (does_feed && !sends_only) {
 748                         (*i)->set_solo_isolated (yn, (*i)->route_group());
 749                 }
 750         }
 751
 752         /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
 753
 754         bool changed = false;
 755
 756         if (yn) {
 757                 if (_solo_isolated == 0) {
 758                         _mute_master->set_solo_ignore (true);
 759                         changed = true;
 760                 }
 761                 _solo_isolated++;
 762         } else {
 763                 if (_solo_isolated > 0) {
 764                         _solo_isolated--;
 765                         if (_solo_isolated == 0) {
 766                                 _mute_master->set_solo_ignore (false);
 767                                 changed = true;
 768                         }
 769                 }
 770         }
 771
 772         if (changed) {
 773                 solo_isolated_changed (src);
 774         }
 775 }
 776
 777 bool
 778 Route::solo_isolated () const
 779 {
 780         return _solo_isolated > 0;
 781 }
 782
 783 void
 784 Route::set_mute_points (MuteMaster::MutePoint mp)
 785 {
 786         _mute_master->set_mute_points (mp);
 787         mute_points_changed (); /* EMIT SIGNAL */
 788
 789         if (_mute_master->muted_by_self()) {
 790                 mute_changed (this); /* EMIT SIGNAL */
 791                 _mute_control->Changed (); /* EMIT SIGNAL */
 792         }
 793 }
 794
 795 void
 796 Route::set_mute (bool yn, void *src)
 797 {
 798         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
 799                 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
 800                 return;
 801         }
 802
 803         if (muted() != yn) {
 804                 _mute_master->set_muted_by_self (yn);
 805                 mute_changed (src); /* EMIT SIGNAL */
 806                 _mute_control->Changed (); /* EMIT SIGNAL */
 807         }
 808 }
 809
 810 bool
 811 Route::muted () const
 812 {
 813         return _mute_master->muted_by_self();
 814 }
 815
 816 #if 0
 817 static void
 818 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 819 {
 820         cerr << name << " {" << endl;
 821         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 822                         p != procs.end(); ++p) {
 823                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
 824         }
 825         cerr << "}" << endl;
 826 }
 827 #endif
 828
 829 int
 830 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
 831 {
 832         ProcessorList::iterator loc;
 833
 834         /* XXX this is not thread safe - we don't hold the lock across determining the iter
 835            to add before and actually doing the insertion. dammit.
 836         */
 837
 838         if (placement == PreFader) {
 839                 /* generic pre-fader: insert immediately before the amp */
 840                 loc = find (_processors.begin(), _processors.end(), _amp);
 841         } else {
 842                 /* generic post-fader: insert right before the main outs */
 843                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 844         }
 845
 846         return add_processor (processor, loc, err);
 847 }
 848
 849
 850 /** Add a processor to the route.
 851  *  @param iter an iterator in _processors; the new processor will be inserted immediately before this location.
 852  */
 853 int
 854 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
 855 {
 856         assert (processor != _meter);
 857         assert (processor != _main_outs);
 858
 859         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1 adding processor %2\n", name(), processor->name()));
 860
 861         ChanCount old_pms = processor_max_streams;
 862
 863         if (!_session.engine().connected() || !processor) {
 864                 return 1;
 865         }
 866
 867         {
 868                 Glib::RWLock::WriterLock lm (_processor_lock);
 869                 ProcessorState pstate (this);
 870
 871                 boost::shared_ptr<PluginInsert> pi;
 872                 boost::shared_ptr<PortInsert> porti;
 873
 874                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
 875
 876                 if (processor == _amp) {
 877                         // Ensure only one amp is in the list at any time
 878                         if (loc != _processors.end()) {
 879                                 if (iter == loc) { // Already in place, do nothing
 880                                         return 0;
 881                                 } else { // New position given, relocate
 882                                         _processors.erase (loc);
 883                                 }
 884                         }
 885
 886                 } else {
 887                         if (loc != _processors.end()) {
 888                                 cerr << "ERROR: Processor added to route twice!" << endl;
 889                                 return 1;
 890                         }
 891
 892                         loc = iter;
 893                 }
 894
 895                 _processors.insert (loc, processor);
 896
 897                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
 898                 // configure redirect ports properly, etc.
 899
 900                 {
 901                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 902
 903                         if (configure_processors_unlocked (err)) {
 904                                 pstate.restore ();
 905                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
 906                                 return -1;
 907                         }
 908                 }
 909
 910                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
 911
 912                         if (pi->natural_input_streams() == ChanCount::ZERO) {
 913                                 /* generator plugin */
 914                                 _have_internal_generator = true;
 915                         }
 916
 917                 }
 918
 919                 if (activation_allowed) {
 920                         processor->activate ();
 921                 }
 922
 923                 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
 924
 925                 _output->set_user_latency (0);
 926         }
 927
 928         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
 929         set_processor_positions ();
 930
 931         return 0;
 932 }
 933
 934 bool
 935 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
 936 {
 937         const XMLProperty *prop;
 938
 939         try {
 940                 boost::shared_ptr<Processor> processor;
 941
 942                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
 943                    so that we can add the processor in the right place (pre/post-fader)
 944                 */
 945
 946                 XMLNodeList const & children = node.children ();
 947                 XMLNodeList::const_iterator i = children.begin ();
 948
 949                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
 950                         ++i;
 951                 }
 952
 953                 Placement placement = PreFader;
 954
 955                 if (i != children.end()) {
 956                         if ((prop = (*i)->property (X_("placement"))) != 0) {
 957                                 placement = Placement (string_2_enum (prop->value(), placement));
 958                         }
 959                 }
 960
 961                 if (node.name() == "Insert") {
 962
 963                         if ((prop = node.property ("type")) != 0) {
 964
 965                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 966                                                 prop->value() == "lv2" ||
 967                                                 prop->value() == "vst" ||
 968                                                 prop->value() == "audiounit") {
 969
 970                                         processor.reset (new PluginInsert (_session));
 971
 972                                 } else {
 973
 974                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
 975                                 }
 976
 977                         }
 978
 979                 } else if (node.name() == "Send") {
 980
 981                         processor.reset (new Send (_session, _pannable, _mute_master));
 982
 983                 } else {
 984
 985                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
 986                         return false;
 987                 }
 988
 989                 if (processor->set_state (node, version)) {
 990                         return false;
 991                 }
 992
 993                 return (add_processor (processor, placement) == 0);
 994         }
 995
 996         catch (failed_constructor &err) {
 997                 warning << _("processor could not be created. Ignored.") << endmsg;
 998                 return false;
 999         }
1000 }
1001
1002 int
1003 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1004 {
1005         /* NOTE: this is intended to be used ONLY when copying
1006            processors from another Route. Hence the subtle
1007            differences between this and ::add_processor()
1008         */
1009
1010         ProcessorList::iterator loc;
1011
1012         if (before) {
1013                 loc = find(_processors.begin(), _processors.end(), before);
1014         } else {
1015                 /* nothing specified - at end */
1016                 loc = _processors.end ();
1017         }
1018
1019         ChanCount old_pms = processor_max_streams;
1020
1021         if (!_session.engine().connected()) {
1022                 return 1;
1023         }
1024
1025         if (others.empty()) {
1026                 return 0;
1027         }
1028
1029         {
1030                 Glib::RWLock::WriterLock lm (_processor_lock);
1031                 ProcessorState pstate (this);
1032
1033                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1034
1035                         if (*i == _meter) {
1036                                 continue;
1037                         }
1038
1039                         boost::shared_ptr<PluginInsert> pi;
1040
1041                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1042                                 pi->set_count (1);
1043                         }
1044
1045                         ProcessorList::iterator inserted = _processors.insert (loc, *i);
1046
1047                         if ((*i)->active()) {
1048                                 (*i)->activate ();
1049                         }
1050
1051                         {
1052                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1053                                 if (configure_processors_unlocked (err)) {
1054                                         pstate.restore ();
1055                                         configure_processors_unlocked (0); // it worked before we tried to add it ...
1056                                         return -1;
1057                                 }
1058                         }
1059
1060                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
1061                 }
1062
1063                 _output->set_user_latency (0);
1064         }
1065
1066         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1067         set_processor_positions ();
1068
1069         return 0;
1070 }
1071
1072 void
1073 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1074 {
1075         if (p == PreFader) {
1076                 start = _processors.begin();
1077                 end = find(_processors.begin(), _processors.end(), _amp);
1078         } else {
1079                 start = find(_processors.begin(), _processors.end(), _amp);
1080                 ++start;
1081                 end = _processors.end();
1082         }
1083 }
1084
1085 /** Turn off all processors with a given placement
1086  * @param p Placement of processors to disable
1087  */
1088 void
1089 Route::disable_processors (Placement p)
1090 {
1091         Glib::RWLock::ReaderLock lm (_processor_lock);
1092
1093         ProcessorList::iterator start, end;
1094         placement_range(p, start, end);
1095
1096         for (ProcessorList::iterator i = start; i != end; ++i) {
1097                 (*i)->deactivate ();
1098         }
1099
1100         _session.set_dirty ();
1101 }
1102
1103 /** Turn off all redirects
1104  */
1105 void
1106 Route::disable_processors ()
1107 {
1108         Glib::RWLock::ReaderLock lm (_processor_lock);
1109
1110         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1111                 (*i)->deactivate ();
1112         }
1113
1114         _session.set_dirty ();
1115 }
1116
1117 /** Turn off all redirects with a given placement
1118  * @param p Placement of redirects to disable
1119  */
1120 void
1121 Route::disable_plugins (Placement p)
1122 {
1123         Glib::RWLock::ReaderLock lm (_processor_lock);
1124
1125         ProcessorList::iterator start, end;
1126         placement_range(p, start, end);
1127
1128         for (ProcessorList::iterator i = start; i != end; ++i) {
1129                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1130                         (*i)->deactivate ();
1131                 }
1132         }
1133
1134         _session.set_dirty ();
1135 }
1136
1137 /** Turn off all plugins
1138  */
1139 void
1140 Route::disable_plugins ()
1141 {
1142         Glib::RWLock::ReaderLock lm (_processor_lock);
1143
1144         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1145                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1146                         (*i)->deactivate ();
1147                 }
1148         }
1149
1150         _session.set_dirty ();
1151 }
1152
1153
1154 void
1155 Route::ab_plugins (bool forward)
1156 {
1157         Glib::RWLock::ReaderLock lm (_processor_lock);
1158
1159         if (forward) {
1160
1161                 /* forward = turn off all active redirects, and mark them so that the next time
1162                    we go the other way, we will revert them
1163                 */
1164
1165                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1166                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1167                                 continue;
1168                         }
1169
1170                         if ((*i)->active()) {
1171                                 (*i)->deactivate ();
1172                                 (*i)->set_next_ab_is_active (true);
1173                         } else {
1174                                 (*i)->set_next_ab_is_active (false);
1175                         }
1176                 }
1177
1178         } else {
1179
1180                 /* backward = if the redirect was marked to go active on the next ab, do so */
1181
1182                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1183
1184                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1185                                 continue;
1186                         }
1187
1188                         if ((*i)->get_next_ab_is_active()) {
1189                                 (*i)->activate ();
1190                         } else {
1191                                 (*i)->deactivate ();
1192                         }
1193                 }
1194         }
1195
1196         _session.set_dirty ();
1197 }
1198
1199
1200 /** Remove processors with a given placement.
1201  * @param p Placement of processors to remove.
1202  */
1203 void
1204 Route::clear_processors (Placement p)
1205 {
1206         const ChanCount old_pms = processor_max_streams;
1207
1208         if (!_session.engine().connected()) {
1209                 return;
1210         }
1211
1212         bool already_deleting = _session.deletion_in_progress();
1213         if (!already_deleting) {
1214                 _session.set_deletion_in_progress();
1215         }
1216
1217         {
1218                 Glib::RWLock::WriterLock lm (_processor_lock);
1219                 ProcessorList new_list;
1220                 ProcessorStreams err;
1221                 bool seen_amp = false;
1222
1223                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1224
1225                         if (*i == _amp) {
1226                                 seen_amp = true;
1227                         }
1228
1229                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1230
1231                                 /* you can't remove these */
1232
1233                                 new_list.push_back (*i);
1234
1235                         } else {
1236                                 if (seen_amp) {
1237
1238                                         switch (p) {
1239                                         case PreFader:
1240                                                 new_list.push_back (*i);
1241                                                 break;
1242                                         case PostFader:
1243                                                 (*i)->drop_references ();
1244                                                 break;
1245                                         }
1246
1247                                 } else {
1248
1249                                         switch (p) {
1250                                         case PreFader:
1251                                                 (*i)->drop_references ();
1252                                                 break;
1253                                         case PostFader:
1254                                                 new_list.push_back (*i);
1255                                                 break;
1256                                         }
1257                                 }
1258                         }
1259                 }
1260
1261                 _processors = new_list;
1262
1263                 {
1264                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1265                         configure_processors_unlocked (&err); // this can't fail
1266                 }
1267         }
1268
1269         processor_max_streams.reset();
1270         _have_internal_generator = false;
1271         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1272         set_processor_positions ();
1273
1274         if (!already_deleting) {
1275                 _session.clear_deletion_in_progress();
1276         }
1277 }
1278
1279 int
1280 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1281 {
1282         /* these can never be removed */
1283
1284         if (processor == _amp || processor == _meter || processor == _main_outs) {
1285                 return 0;
1286         }
1287
1288         ChanCount old_pms = processor_max_streams;
1289
1290         if (!_session.engine().connected()) {
1291                 return 1;
1292         }
1293
1294         processor_max_streams.reset();
1295
1296         {
1297                 Glib::RWLock::WriterLock lm (_processor_lock);
1298                 ProcessorState pstate (this);
1299
1300                 ProcessorList::iterator i;
1301                 bool removed = false;
1302
1303                 for (i = _processors.begin(); i != _processors.end(); ) {
1304                         if (*i == processor) {
1305
1306                                 /* move along, see failure case for configure_processors()
1307                                    where we may need to reconfigure the processor.
1308                                 */
1309
1310                                 /* stop redirects that send signals to JACK ports
1311                                    from causing noise as a result of no longer being
1312                                    run.
1313                                 */
1314
1315                                 boost::shared_ptr<IOProcessor> iop;
1316
1317                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1318                                         if (iop->input()) {
1319                                                 iop->input()->disconnect (this);
1320                                         }
1321                                         if (iop->output()) {
1322                                                 iop->output()->disconnect (this);
1323                                         }
1324                                 }
1325
1326                                 i = _processors.erase (i);
1327                                 removed = true;
1328                                 break;
1329
1330                         } else {
1331                                 ++i;
1332                         }
1333
1334                         _output->set_user_latency (0);
1335                 }
1336
1337                 if (!removed) {
1338                         /* what? */
1339                         return 1;
1340                 }
1341
1342                 {
1343                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1344
1345                         if (configure_processors_unlocked (err)) {
1346                                 pstate.restore ();
1347                                 /* we know this will work, because it worked before :) */
1348                                 configure_processors_unlocked (0);
1349                                 return -1;
1350                         }
1351                 }
1352
1353                 _have_internal_generator = false;
1354
1355                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1356                         boost::shared_ptr<PluginInsert> pi;
1357
1358                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1359                                 if (pi->is_generator()) {
1360                                         _have_internal_generator = true;
1361                                         break;
1362                                 }
1363                         }
1364                 }
1365         }
1366
1367         processor->drop_references ();
1368         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1369         set_processor_positions ();
1370
1371         return 0;
1372 }
1373
1374 int
1375 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1376 {
1377         ProcessorList deleted;
1378
1379         if (!_session.engine().connected()) {
1380                 return 1;
1381         }
1382
1383         processor_max_streams.reset();
1384
1385         {
1386                 Glib::RWLock::WriterLock lm (_processor_lock);
1387                 ProcessorState pstate (this);
1388
1389                 ProcessorList::iterator i;
1390                 boost::shared_ptr<Processor> processor;
1391
1392                 for (i = _processors.begin(); i != _processors.end(); ) {
1393
1394                         processor = *i;
1395
1396                         /* these can never be removed */
1397
1398                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1399                                 ++i;
1400                                 continue;
1401                         }
1402
1403                         /* see if its in the list of processors to delete */
1404
1405                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1406                                 ++i;
1407                                 continue;
1408                         }
1409
1410                         /* stop IOProcessors that send to JACK ports
1411                            from causing noise as a result of no longer being
1412                            run.
1413                         */
1414
1415                         boost::shared_ptr<IOProcessor> iop;
1416
1417                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1418                                 iop->disconnect ();
1419                         }
1420
1421                         deleted.push_back (processor);
1422                         i = _processors.erase (i);
1423                 }
1424
1425                 if (deleted.empty()) {
1426                         /* none of those in the requested list were found */
1427                         return 0;
1428                 }
1429
1430                 _output->set_user_latency (0);
1431
1432                 {
1433                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1434
1435                         if (configure_processors_unlocked (err)) {
1436                                 pstate.restore ();
1437                                 /* we know this will work, because it worked before :) */
1438                                 configure_processors_unlocked (0);
1439                                 return -1;
1440                         }
1441                 }
1442
1443                 _have_internal_generator = false;
1444
1445                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1446                         boost::shared_ptr<PluginInsert> pi;
1447
1448                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1449                                 if (pi->is_generator()) {
1450                                         _have_internal_generator = true;
1451                                         break;
1452                                 }
1453                         }
1454                 }
1455         }
1456
1457         /* now try to do what we need to so that those that were removed will be deleted */
1458
1459         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1460                 (*i)->drop_references ();
1461         }
1462
1463         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1464         set_processor_positions ();
1465
1466         return 0;
1467 }
1468
1469 /** Caller must hold process lock */
1470 int
1471 Route::configure_processors (ProcessorStreams* err)
1472 {
1473         assert (!AudioEngine::instance()->process_lock().trylock());
1474
1475         if (!_in_configure_processors) {
1476                 Glib::RWLock::WriterLock lm (_processor_lock);
1477                 return configure_processors_unlocked (err);
1478         }
1479
1480         return 0;
1481 }
1482
1483 ChanCount
1484 Route::input_streams () const
1485 {
1486         return _input->n_ports ();
1487 }
1488
1489 list<pair<ChanCount, ChanCount> >
1490 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1491 {
1492         Glib::RWLock::ReaderLock lm (_processor_lock);
1493
1494         return try_configure_processors_unlocked (in, err);
1495 }
1496
1497 list<pair<ChanCount, ChanCount> >
1498 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1499 {
1500         // Check each processor in order to see if we can configure as requested
1501         ChanCount out;
1502         list<pair<ChanCount, ChanCount> > configuration;
1503         uint32_t index = 0;
1504
1505         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1506         DEBUG_TRACE (DEBUG::Processors, "{\n");
1507
1508         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1509
1510                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1511                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1512                         break;
1513                 }
1514
1515                 if ((*p)->can_support_io_configuration(in, out)) {
1516                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1517                         configuration.push_back(make_pair(in, out));
1518                         in = out;
1519                 } else {
1520                         if (err) {
1521                                 err->index = index;
1522                                 err->count = in;
1523                         }
1524                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1525                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1526                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1527                         return list<pair<ChanCount, ChanCount> > ();
1528                 }
1529         }
1530
1531         DEBUG_TRACE (DEBUG::Processors, "}\n");
1532
1533         return configuration;
1534 }
1535
1536 /** Set the input/output configuration of each processor in the processors list.
1537  *  Caller must hold process lock.
1538  *  Return 0 on success, otherwise configuration is impossible.
1539  */
1540 int
1541 Route::configure_processors_unlocked (ProcessorStreams* err)
1542 {
1543         assert (!AudioEngine::instance()->process_lock().trylock());
1544
1545         if (_in_configure_processors) {
1546                 return 0;
1547         }
1548
1549         /* put invisible processors where they should be */
1550         setup_invisible_processors ();
1551
1552         _in_configure_processors = true;
1553
1554         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1555
1556         if (configuration.empty ()) {
1557                 _in_configure_processors = false;
1558                 return -1;
1559         }
1560
1561         ChanCount out;
1562
1563         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1564         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1565
1566                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1567                         break;
1568                 }
1569
1570                 (*p)->configure_io(c->first, c->second);
1571                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1572                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1573                 out = c->second;
1574         }
1575
1576         if (_meter) {
1577                 _meter->reset_max_channels (processor_max_streams);
1578         }
1579
1580         /* make sure we have sufficient scratch buffers to cope with the new processor
1581            configuration */
1582         _session.ensure_buffers (n_process_buffers ());
1583
1584         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1585
1586         _in_configure_processors = false;
1587         return 0;
1588 }
1589
1590 void
1591 Route::all_processors_flip ()
1592 {
1593         Glib::RWLock::ReaderLock lm (_processor_lock);
1594
1595         if (_processors.empty()) {
1596                 return;
1597         }
1598
1599         bool first_is_on = _processors.front()->active();
1600
1601         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1602                 if (first_is_on) {
1603                         (*i)->deactivate ();
1604                 } else {
1605                         (*i)->activate ();
1606                 }
1607         }
1608
1609         _session.set_dirty ();
1610 }
1611
1612 /** Set all processors with a given placement to a given active state.
1613  * @param p Placement of processors to change.
1614  * @param state New active state for those processors.
1615  */
1616 void
1617 Route::all_processors_active (Placement p, bool state)
1618 {
1619         Glib::RWLock::ReaderLock lm (_processor_lock);
1620
1621         if (_processors.empty()) {
1622                 return;
1623         }
1624         ProcessorList::iterator start, end;
1625         placement_range(p, start, end);
1626
1627         bool before_amp = true;
1628         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1629                 if ((*i) == _amp) {
1630                         before_amp = false;
1631                         continue;
1632                 }
1633                 if (p == PreFader && before_amp) {
1634                         if (state) {
1635                                 (*i)->activate ();
1636                         } else {
1637                                 (*i)->deactivate ();
1638                         }
1639                 }
1640         }
1641
1642         _session.set_dirty ();
1643 }
1644
1645 bool
1646 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1647 {
1648         bool pre_fader = true;
1649         Glib::RWLock::ReaderLock lm (_processor_lock);
1650
1651         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1652
1653                 /* semantic note: if p == amp, we want to return true, so test
1654                    for equality before checking if this is the amp
1655                 */
1656
1657                 if ((*i) == p) {
1658                         break;
1659                 }
1660
1661                 if ((*i) == _amp) {
1662                         pre_fader = false;
1663                         break;
1664                 }
1665         }
1666
1667         return pre_fader;
1668 }
1669
1670 int
1671 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1672 {
1673         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1674            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1675            processors in the current actual processor list that are hidden. Any visible processors
1676            in the current list but not in "new_order" will be assumed to be deleted.
1677         */
1678
1679         {
1680                 Glib::RWLock::WriterLock lm (_processor_lock);
1681                 ProcessorState pstate (this);
1682
1683                 ProcessorList::iterator oiter;
1684                 ProcessorList::const_iterator niter;
1685                 ProcessorList as_it_will_be;
1686
1687                 oiter = _processors.begin();
1688                 niter = new_order.begin();
1689
1690                 while (niter !=  new_order.end()) {
1691
1692                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1693                            then append it to the temp list.
1694
1695                            Otherwise, see if the next processor in the old list is in the new list. if not,
1696                            its been deleted. If its there, append it to the temp list.
1697                         */
1698
1699                         if (oiter == _processors.end()) {
1700
1701                                 /* no more elements in the old list, so just stick the rest of
1702                                    the new order onto the temp list.
1703                                 */
1704
1705                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1706                                 while (niter != new_order.end()) {
1707                                         ++niter;
1708                                 }
1709                                 break;
1710
1711                         } else {
1712
1713                                 if (!(*oiter)->display_to_user()) {
1714
1715                                         as_it_will_be.push_back (*oiter);
1716
1717                                 } else {
1718
1719                                         /* visible processor: check that its in the new order */
1720
1721                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1722                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1723                                         } else {
1724                                                 /* ignore this one, and add the next item from the new order instead */
1725                                                 as_it_will_be.push_back (*niter);
1726                                                 ++niter;
1727                                         }
1728                                 }
1729
1730                                 /* now remove from old order - its taken care of no matter what */
1731                                 oiter = _processors.erase (oiter);
1732                         }
1733
1734                 }
1735
1736                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1737
1738                 {
1739                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1740
1741                         if (configure_processors_unlocked (err)) {
1742                                 pstate.restore ();
1743                                 return -1;
1744                         }
1745                 }
1746         }
1747
1748         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1749         set_processor_positions ();
1750
1751         return 0;
1752 }
1753
1754 XMLNode&
1755 Route::get_state()
1756 {
1757         return state(true);
1758 }
1759
1760 XMLNode&
1761 Route::get_template()
1762 {
1763         return state(false);
1764 }
1765
1766 XMLNode&
1767 Route::state(bool full_state)
1768 {
1769         XMLNode *node = new XMLNode("Route");
1770         ProcessorList::iterator i;
1771         char buf[32];
1772
1773         id().print (buf, sizeof (buf));
1774         node->add_property("id", buf);
1775         node->add_property ("name", _name);
1776         node->add_property("default-type", _default_type.to_string());
1777
1778         if (_flags) {
1779                 node->add_property("flags", enum_2_string (_flags));
1780         }
1781
1782         node->add_property("active", _active?"yes":"no");
1783         string p;
1784         boost::to_string (_phase_invert, p);
1785         node->add_property("phase-invert", p);
1786         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1787         node->add_property("meter-point", enum_2_string (_meter_point));
1788
1789         if (_route_group) {
1790                 node->add_property("route-group", _route_group->name());
1791         }
1792
1793         string order_string;
1794         OrderKeys::iterator x = order_keys.begin();
1795
1796         while (x != order_keys.end()) {
1797                 order_string += string ((*x).first);
1798                 order_string += '=';
1799                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1800                 order_string += buf;
1801
1802                 ++x;
1803
1804                 if (x == order_keys.end()) {
1805                         break;
1806                 }
1807
1808                 order_string += ':';
1809         }
1810         node->add_property ("order-keys", order_string);
1811         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1812         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1813         node->add_property ("soloed-by-upstream", buf);
1814         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1815         node->add_property ("soloed-by-downstream", buf);
1816         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1817         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1818
1819         node->add_child_nocopy (_input->state (full_state));
1820         node->add_child_nocopy (_output->state (full_state));
1821         node->add_child_nocopy (_solo_control->get_state ());
1822         node->add_child_nocopy (_mute_control->get_state ());
1823         node->add_child_nocopy (_mute_master->get_state ());
1824
1825         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1826         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1827         remote_control_node->add_property (X_("id"), buf);
1828         node->add_child_nocopy (*remote_control_node);
1829
1830         if (_comment.length()) {
1831                 XMLNode *cmt = node->add_child ("Comment");
1832                 cmt->add_content (_comment);
1833         }
1834
1835         node->add_child_nocopy (_pannable->state (full_state));
1836
1837         for (i = _processors.begin(); i != _processors.end(); ++i) {
1838                 node->add_child_nocopy((*i)->state (full_state));
1839         }
1840
1841         if (_extra_xml){
1842                 node->add_child_copy (*_extra_xml);
1843         }
1844
1845         return *node;
1846 }
1847
1848 int
1849 Route::set_state (const XMLNode& node, int version)
1850 {
1851         return _set_state (node, version, true);
1852 }
1853
1854 int
1855 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1856 {
1857         if (version < 3000) {
1858                 return _set_state_2X (node, version);
1859         }
1860
1861         XMLNodeList nlist;
1862         XMLNodeConstIterator niter;
1863         XMLNode *child;
1864         const XMLProperty *prop;
1865
1866         if (node.name() != "Route"){
1867                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1868                 return -1;
1869         }
1870
1871         if ((prop = node.property (X_("name"))) != 0) {
1872                 Route::set_name (prop->value());
1873         }
1874
1875         if ((prop = node.property ("id")) != 0) {
1876                 _id = prop->value ();
1877         }
1878
1879         if ((prop = node.property (X_("flags"))) != 0) {
1880                 _flags = Flag (string_2_enum (prop->value(), _flags));
1881         } else {
1882                 _flags = Flag (0);
1883         }
1884
1885         if (is_master() || is_monitor() || is_hidden()) {
1886                 _mute_master->set_solo_ignore (true);
1887         }
1888
1889         /* add all processors (except amp, which is always present) */
1890
1891         nlist = node.children();
1892         XMLNode processor_state (X_("processor_state"));
1893
1894         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1895
1896                 child = *niter;
1897
1898                 if (child->name() == IO::state_node_name) {
1899                         if ((prop = child->property (X_("direction"))) == 0) {
1900                                 continue;
1901                         }
1902
1903                         if (prop->value() == "Input") {
1904                                 _input->set_state (*child, version);
1905                         } else if (prop->value() == "Output") {
1906                                 _output->set_state (*child, version);
1907                         }
1908                 }
1909
1910                 if (child->name() == X_("Processor")) {
1911                         processor_state.add_child_copy (*child);
1912                 }
1913
1914
1915                 if (child->name() == X_("Pannable")) {
1916                         _pannable->set_state (*child, version);
1917                 }
1918         }
1919
1920         set_processor_state (processor_state);
1921
1922         if ((prop = node.property ("self-solo")) != 0) {
1923                 set_self_solo (string_is_affirmative (prop->value()));
1924         }
1925
1926         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1927                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1928                 mod_solo_by_others_upstream (atoi (prop->value()));
1929         }
1930
1931         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1932                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1933                 mod_solo_by_others_downstream (atoi (prop->value()));
1934         }
1935
1936         if ((prop = node.property ("solo-isolated")) != 0) {
1937                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1938         }
1939
1940         if ((prop = node.property ("solo-safe")) != 0) {
1941                 set_solo_safe (string_is_affirmative (prop->value()), this);
1942         }
1943
1944         if ((prop = node.property (X_("phase-invert"))) != 0) {
1945                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1946         }
1947
1948         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1949                 set_denormal_protection (string_is_affirmative (prop->value()));
1950         }
1951
1952         if ((prop = node.property (X_("active"))) != 0) {
1953                 bool yn = string_is_affirmative (prop->value());
1954                 _active = !yn; // force switch
1955                 set_active (yn, this);
1956         }
1957
1958         if ((prop = node.property (X_("meter-point"))) != 0) {
1959                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1960                 set_meter_point (mp, true);
1961                 if (_meter) {
1962                         _meter->set_display_to_user (_meter_point == MeterCustom);
1963                 }
1964         }
1965
1966         if ((prop = node.property (X_("order-keys"))) != 0) {
1967
1968                 int32_t n;
1969
1970                 string::size_type colon, equal;
1971                 string remaining = prop->value();
1972
1973                 while (remaining.length()) {
1974
1975                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1976                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1977                                       << endmsg;
1978                         } else {
1979                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
1980                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1981                                               << endmsg;
1982                                 } else {
1983                                         set_order_key (remaining.substr (0, equal), n);
1984                                 }
1985                         }
1986
1987                         colon = remaining.find_first_of (':');
1988
1989                         if (colon != string::npos) {
1990                                 remaining = remaining.substr (colon+1);
1991                         } else {
1992                                 break;
1993                         }
1994                 }
1995         }
1996
1997         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1998                 child = *niter;
1999
2000                 if (child->name() == X_("Comment")) {
2001
2002                         /* XXX this is a terrible API design in libxml++ */
2003
2004                         XMLNode *cmt = *(child->children().begin());
2005                         _comment = cmt->content();
2006
2007                 } else if (child->name() == X_("Extra")) {
2008
2009                         _extra_xml = new XMLNode (*child);
2010
2011                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2012                         if (prop->value() == "solo") {
2013                                 _solo_control->set_state (*child, version);
2014                         }
2015
2016                 } else if (child->name() == X_("RemoteControl")) {
2017                         if ((prop = child->property (X_("id"))) != 0) {
2018                                 int32_t x;
2019                                 sscanf (prop->value().c_str(), "%d", &x);
2020                                 set_remote_control_id (x);
2021                         }
2022
2023                 } else if (child->name() == X_("MuteMaster")) {
2024                         _mute_master->set_state (*child, version);
2025                 }
2026         }
2027
2028         return 0;
2029 }
2030
2031 int
2032 Route::_set_state_2X (const XMLNode& node, int version)
2033 {
2034         XMLNodeList nlist;
2035         XMLNodeConstIterator niter;
2036         XMLNode *child;
2037         const XMLProperty *prop;
2038
2039         /* 2X things which still remain to be handled:
2040          * default-type
2041          * automation
2042          * controlouts
2043          */
2044
2045         if (node.name() != "Route") {
2046                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2047                 return -1;
2048         }
2049
2050         if ((prop = node.property (X_("flags"))) != 0) {
2051                 _flags = Flag (string_2_enum (prop->value(), _flags));
2052         } else {
2053                 _flags = Flag (0);
2054         }
2055
2056         if ((prop = node.property (X_("phase-invert"))) != 0) {
2057                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2058                 if (string_is_affirmative (prop->value ())) {
2059                         p.set ();
2060                 }
2061                 set_phase_invert (p);
2062         }
2063
2064         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2065                 set_denormal_protection (string_is_affirmative (prop->value()));
2066         }
2067
2068         if ((prop = node.property (X_("soloed"))) != 0) {
2069                 bool yn = string_is_affirmative (prop->value());
2070
2071                 /* XXX force reset of solo status */
2072
2073                 set_solo (yn, this);
2074         }
2075
2076         if ((prop = node.property (X_("muted"))) != 0) {
2077
2078                 bool first = true;
2079                 bool muted = string_is_affirmative (prop->value());
2080
2081                 if (muted){
2082
2083                         string mute_point;
2084
2085                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2086
2087                                 if (string_is_affirmative (prop->value())){
2088                                         mute_point = mute_point + "PreFader";
2089                                         first = false;
2090                                 }
2091                         }
2092
2093                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2094
2095                                 if (string_is_affirmative (prop->value())){
2096
2097                                         if (!first) {
2098                                                 mute_point = mute_point + ",";
2099                                         }
2100
2101                                         mute_point = mute_point + "PostFader";
2102                                         first = false;
2103                                 }
2104                         }
2105
2106                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2107
2108                                 if (string_is_affirmative (prop->value())){
2109
2110                                         if (!first) {
2111                                                 mute_point = mute_point + ",";
2112                                         }
2113
2114                                         mute_point = mute_point + "Listen";
2115                                         first = false;
2116                                 }
2117                         }
2118
2119                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2120
2121                                 if (string_is_affirmative (prop->value())){
2122
2123                                         if (!first) {
2124                                                 mute_point = mute_point + ",";
2125                                         }
2126
2127                                         mute_point = mute_point + "Main";
2128                                 }
2129                         }
2130
2131                         _mute_master->set_mute_points (mute_point);
2132                 }
2133         }
2134
2135         if ((prop = node.property (X_("meter-point"))) != 0) {
2136                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2137         }
2138
2139         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2140            don't mean the same thing.
2141         */
2142
2143         if ((prop = node.property (X_("order-keys"))) != 0) {
2144
2145                 int32_t n;
2146
2147                 string::size_type colon, equal;
2148                 string remaining = prop->value();
2149
2150                 while (remaining.length()) {
2151
2152                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2153                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2154                                         << endmsg;
2155                         } else {
2156                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2157                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2158                                                 << endmsg;
2159                                 } else {
2160                                         set_order_key (remaining.substr (0, equal), n);
2161                                 }
2162                         }
2163
2164                         colon = remaining.find_first_of (':');
2165
2166                         if (colon != string::npos) {
2167                                 remaining = remaining.substr (colon+1);
2168                         } else {
2169                                 break;
2170                         }
2171                 }
2172         }
2173
2174         /* IOs */
2175
2176         nlist = node.children ();
2177         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2178
2179                 child = *niter;
2180
2181                 if (child->name() == IO::state_node_name) {
2182
2183                         /* there is a note in IO::set_state_2X() about why we have to call
2184                            this directly.
2185                            */
2186
2187                         _input->set_state_2X (*child, version, true);
2188                         _output->set_state_2X (*child, version, false);
2189
2190                         if ((prop = child->property (X_("name"))) != 0) {
2191                                 Route::set_name (prop->value ());
2192                         }
2193
2194                         if ((prop = child->property (X_("id"))) != 0) {
2195                                 _id = prop->value ();
2196                         }
2197
2198                         if ((prop = child->property (X_("active"))) != 0) {
2199                                 bool yn = string_is_affirmative (prop->value());
2200                                 _active = !yn; // force switch
2201                                 set_active (yn, this);
2202                         }
2203
2204                         if ((prop = child->property (X_("gain"))) != 0) {
2205                                 gain_t val;
2206
2207                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2208                                         _amp->gain_control()->set_value (val);
2209                                 }
2210                         }
2211
2212                         /* Set up Panners in the IO */
2213                         XMLNodeList io_nlist = child->children ();
2214
2215                         XMLNodeConstIterator io_niter;
2216                         XMLNode *io_child;
2217
2218                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2219
2220                                 io_child = *io_niter;
2221
2222                                 if (io_child->name() == X_("Panner")) {
2223                                         _main_outs->panner_shell()->set_state(*io_child, version);
2224                                 } else if (io_child->name() == X_("Automation")) {
2225                                         /* IO's automation is for the fader */
2226                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2227                                 }
2228                         }
2229                 }
2230         }
2231
2232         XMLNodeList redirect_nodes;
2233
2234         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2235
2236                 child = *niter;
2237
2238                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2239                         redirect_nodes.push_back(child);
2240                 }
2241
2242         }
2243
2244         set_processor_state_2X (redirect_nodes, version);
2245
2246         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2247                 child = *niter;
2248
2249                 if (child->name() == X_("Comment")) {
2250
2251                         /* XXX this is a terrible API design in libxml++ */
2252
2253                         XMLNode *cmt = *(child->children().begin());
2254                         _comment = cmt->content();
2255
2256                 } else if (child->name() == X_("extra")) {
2257
2258                         _extra_xml = new XMLNode (*child);
2259
2260                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2261                         if (prop->value() == X_("solo")) {
2262                                 _solo_control->set_state (*child, version);
2263                         } else if (prop->value() == X_("mute")) {
2264                                 _mute_control->set_state (*child, version);
2265                         }
2266
2267                 } else if (child->name() == X_("RemoteControl")) {
2268                         if ((prop = child->property (X_("id"))) != 0) {
2269                                 int32_t x;
2270                                 sscanf (prop->value().c_str(), "%d", &x);
2271                                 set_remote_control_id (x);
2272                         }
2273
2274                 }
2275         }
2276
2277         return 0;
2278 }
2279
2280 XMLNode&
2281 Route::get_processor_state ()
2282 {
2283         XMLNode* root = new XMLNode (X_("redirects"));
2284         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2285                 root->add_child_nocopy ((*i)->state (true));
2286         }
2287
2288         return *root;
2289 }
2290
2291 void
2292 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2293 {
2294         /* We don't bother removing existing processors not in nList, as this
2295            method will only be called when creating a Route from scratch, not
2296            for undo purposes.  Just put processors in at the appropriate place
2297            in the list.
2298         */
2299
2300         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2301                 add_processor_from_xml_2X (**i, version);
2302         }
2303 }
2304
2305 void
2306 Route::set_processor_state (const XMLNode& node)
2307 {
2308         const XMLNodeList &nlist = node.children();
2309         XMLNodeConstIterator niter;
2310         ProcessorList new_order;
2311         bool must_configure = false;
2312
2313         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2314
2315                 XMLProperty* prop = (*niter)->property ("type");
2316
2317                 if (prop->value() == "amp") {
2318                         _amp->set_state (**niter, Stateful::current_state_version);
2319                         new_order.push_back (_amp);
2320                 } else if (prop->value() == "meter") {
2321                         _meter->set_state (**niter, Stateful::current_state_version);
2322                 } else if (prop->value() == "main-outs") {
2323                         _main_outs->set_state (**niter, Stateful::current_state_version);
2324                 } else if (prop->value() == "intreturn") {
2325                         if (!_intreturn) {
2326                                 _intreturn.reset (new InternalReturn (_session));
2327                                 must_configure = true;
2328                         }
2329                         _intreturn->set_state (**niter, Stateful::current_state_version);
2330                 } else if (is_monitor() && prop->value() == "monitor") {
2331                         if (!_monitor_control) {
2332                                 _monitor_control.reset (new MonitorProcessor (_session));
2333                                 must_configure = true;
2334                         }
2335                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2336                 } else if (prop->value() == "capture") {
2337                         _capturing_processor.reset (new CapturingProcessor (_session));
2338                 } else {
2339                         ProcessorList::iterator o;
2340
2341                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2342                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2343                                 if (id_prop && (*o)->id() == id_prop->value()) {
2344                                         (*o)->set_state (**niter, Stateful::current_state_version);
2345                                         new_order.push_back (*o);
2346                                         break;
2347                                 }
2348                         }
2349
2350                         // If the processor (*niter) is not on the route then create it
2351
2352                         if (o == _processors.end()) {
2353
2354                                 boost::shared_ptr<Processor> processor;
2355
2356                                 if (prop->value() == "intsend") {
2357
2358                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2359                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2360                                            prop->value() == "lv2" ||
2361                                            prop->value() == "vst" ||
2362                                            prop->value() == "audiounit") {
2363
2364                                         processor.reset (new PluginInsert(_session));
2365
2366                                 } else if (prop->value() == "port") {
2367
2368                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2369
2370                                 } else if (prop->value() == "send") {
2371
2372                                         processor.reset (new Send (_session, _pannable, _mute_master));
2373
2374                                 } else {
2375                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2376                                         continue;
2377                                 }
2378
2379                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2380                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2381                                         processor.reset (new UnknownProcessor (_session, **niter));
2382                                 }
2383
2384                                 /* we have to note the monitor send here, otherwise a new one will be created
2385                                    and the state of this one will be lost.
2386                                 */
2387                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2388                                 if (isend && isend->role() == Delivery::Listen) {
2389                                         _monitor_send = isend;
2390                                 }
2391
2392                                 /* it doesn't matter if invisible processors are added here, as they
2393                                    will be sorted out by setup_invisible_processors () shortly.
2394                                 */
2395
2396                                 new_order.push_back (processor);
2397                                 must_configure = true;
2398                         }
2399                 }
2400         }
2401
2402         {
2403                 Glib::RWLock::WriterLock lm (_processor_lock);
2404                 _processors = new_order;
2405                 if (must_configure) {
2406                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2407                         configure_processors_unlocked (0);
2408                 }
2409         }
2410
2411         processors_changed (RouteProcessorChange ());
2412         set_processor_positions ();
2413 }
2414
2415 void
2416 Route::curve_reallocate ()
2417 {
2418 //      _gain_automation_curve.finish_resize ();
2419 //      _pan_automation_curve.finish_resize ();
2420 }
2421
2422 void
2423 Route::silence (framecnt_t nframes)
2424 {
2425         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2426         if (!lm.locked()) {
2427                 return;
2428         }
2429
2430         silence_unlocked (nframes);
2431 }
2432
2433 void
2434 Route::silence_unlocked (framecnt_t nframes)
2435 {
2436         /* Must be called with the processor lock held */
2437
2438         if (!_silent) {
2439
2440                 _output->silence (nframes);
2441
2442                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2443                         boost::shared_ptr<PluginInsert> pi;
2444
2445                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2446                                 // skip plugins, they don't need anything when we're not active
2447                                 continue;
2448                         }
2449
2450                         (*i)->silence (nframes);
2451                 }
2452
2453                 if (nframes == _session.get_block_size()) {
2454                         // _silent = true;
2455                 }
2456         }
2457 }
2458
2459 void
2460 Route::add_internal_return ()
2461 {
2462         if (!_intreturn) {
2463                 _intreturn.reset (new InternalReturn (_session));
2464                 add_processor (_intreturn, PreFader);
2465         }
2466 }
2467
2468 void
2469 Route::add_send_to_internal_return (InternalSend* send)
2470 {
2471         Glib::RWLock::ReaderLock rm (_processor_lock);
2472
2473         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2474                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2475
2476                 if (d) {
2477                         return d->add_send (send);
2478                 }
2479         }
2480 }
2481
2482 void
2483 Route::remove_send_from_internal_return (InternalSend* send)
2484 {
2485         Glib::RWLock::ReaderLock rm (_processor_lock);
2486
2487         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2488                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2489
2490                 if (d) {
2491                         return d->remove_send (send);
2492                 }
2493         }
2494 }
2495
2496 /** Add a monitor send (if we don't already have one) but don't activate it */
2497 int
2498 Route::listen_via_monitor ()
2499 {
2500         /* master never sends to control outs */
2501         assert (!is_master ());
2502
2503         /* make sure we have one */
2504         if (!_monitor_send) {
2505                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2506                 _monitor_send->set_display_to_user (false);
2507         }
2508
2509         /* set it up */
2510         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2511         configure_processors (0);
2512
2513         return 0;
2514 }
2515
2516 /** Add an internal send to a route.
2517  *  @param route route to send to.
2518  *  @param placement placement for the send.
2519  */
2520 int
2521 Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
2522 {
2523         assert (route != _session.monitor_out ());
2524
2525         {
2526                 Glib::RWLock::ReaderLock rm (_processor_lock);
2527
2528                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2529
2530                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2531
2532                         if (d && d->target_route() == route) {
2533                                 /* already listening via the specified IO: do nothing */
2534                                 return 0;
2535                         }
2536                 }
2537         }
2538
2539         try {
2540                 boost::shared_ptr<InternalSend> listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2541                 add_processor (listener, placement);
2542
2543         } catch (failed_constructor& err) {
2544                 return -1;
2545         }
2546
2547         return 0;
2548 }
2549
2550 void
2551 Route::drop_listen (boost::shared_ptr<Route> route)
2552 {
2553         ProcessorStreams err;
2554         ProcessorList::iterator tmp;
2555
2556         Glib::RWLock::ReaderLock rl(_processor_lock);
2557         rl.acquire ();
2558
2559   again:
2560         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2561
2562                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2563
2564                 if (d && d->target_route() == route) {
2565                         rl.release ();
2566                         remove_processor (*x, &err);
2567                         rl.acquire ();
2568
2569                         /* list could have been demolished while we dropped the lock
2570                            so start over.
2571                         */
2572
2573                         goto again;
2574                 }
2575         }
2576
2577         rl.release ();
2578
2579         if (route == _session.monitor_out()) {
2580                 _monitor_send.reset ();
2581         }
2582 }
2583
2584 void
2585 Route::set_comment (string cmt, void *src)
2586 {
2587         _comment = cmt;
2588         comment_changed (src);
2589         _session.set_dirty ();
2590 }
2591
2592 bool
2593 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2594 {
2595         FeedRecord fr (other, via_sends_only);
2596
2597         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2598
2599         if (!result.second) {
2600
2601                 /* already a record for "other" - make sure sends-only information is correct */
2602                 if (!via_sends_only && result.first->sends_only) {
2603                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2604                         frp->sends_only = false;
2605                 }
2606         }
2607
2608         return result.second;
2609 }
2610
2611 void
2612 Route::clear_fed_by ()
2613 {
2614         _fed_by.clear ();
2615 }
2616
2617 bool
2618 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2619 {
2620         const FedBy& fed_by (other->fed_by());
2621
2622         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2623                 boost::shared_ptr<Route> sr = f->r.lock();
2624
2625                 if (sr && (sr.get() == this)) {
2626
2627                         if (via_sends_only) {
2628                                 *via_sends_only = f->sends_only;
2629                         }
2630
2631                         return true;
2632                 }
2633         }
2634
2635         return false;
2636 }
2637
2638 bool
2639 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2640 {
2641         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2642
2643         if (_output->connected_to (other->input())) {
2644                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2645                 if (only_send) {
2646                         *only_send = false;
2647                 }
2648
2649                 return true;
2650         }
2651
2652
2653         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2654
2655                 boost::shared_ptr<IOProcessor> iop;
2656
2657                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2658                         if (iop->feeds (other)) {
2659                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2660                                 if (only_send) {
2661                                         *only_send = true;
2662                                 }
2663                                 return true;
2664                         } else {
2665                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2666                         }
2667                 } else {
2668                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2669                 }
2670
2671         }
2672
2673         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2674         return false;
2675 }
2676
2677 /** Called from the (non-realtime) butler thread when the transport is stopped */
2678 void
2679 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2680 {
2681         framepos_t now = _session.transport_frame();
2682
2683         {
2684                 Glib::RWLock::ReaderLock lm (_processor_lock);
2685
2686                 if (!did_locate) {
2687                         automation_snapshot (now, true);
2688                 }
2689
2690                 Automatable::transport_stopped (now);
2691
2692                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2693
2694                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2695                                 (*i)->flush ();
2696                         }
2697
2698                         (*i)->transport_stopped (now);
2699                 }
2700         }
2701
2702         _roll_delay = _initial_delay;
2703 }
2704
2705 /** Called with the process lock held if change contains ConfigurationChanged */
2706 void
2707 Route::input_change_handler (IOChange change, void * /*src*/)
2708 {
2709         if ((change.type & IOChange::ConfigurationChanged)) {
2710                 configure_processors (0);
2711                 _phase_invert.resize (_input->n_ports().n_audio ());
2712                 io_changed (); /* EMIT SIGNAL */
2713         }
2714 }
2715
2716 /** Called with the process lock held if change contains ConfigurationChanged */
2717 void
2718 Route::output_change_handler (IOChange change, void * /*src*/)
2719 {
2720         if ((change.type & IOChange::ConfigurationChanged)) {
2721
2722                 /* XXX resize all listeners to match _main_outs? */
2723
2724                 /* Auto-connect newly-created outputs, unless we're auto-connecting to master
2725                    and we are master (as an auto-connect in this situation would cause a
2726                    feedback loop)
2727                 */
2728                 AutoConnectOption ac = Config->get_output_auto_connect ();
2729                 if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
2730
2731                         ChanCount start = change.before;
2732
2733                         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
2734                                 if (change.before.get(*i) < change.after.get(*i)) {
2735                                         /* the existing ChanCounts don't matter for this call as they are only
2736                                            to do with matching input and output indices, and we are only changing
2737                                            outputs here.
2738                                         */
2739                                         ChanCount dummy;
2740
2741                                         /* only auto-connect the newly-created outputs, not the ones that were
2742                                            already there
2743                                         */
2744                                         start.set (*i, start.get (*i) + 1);
2745
2746                                         _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
2747                                 }
2748                         }
2749                 }
2750
2751                 // configure_processors (0);
2752         }
2753 }
2754
2755 uint32_t
2756 Route::pans_required () const
2757 {
2758         if (n_outputs().n_audio() < 2) {
2759                 return 0;
2760         }
2761
2762         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2763 }
2764
2765 int
2766 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2767                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2768 {
2769         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2770         if (!lm.locked()) {
2771                 return 0;
2772         }
2773
2774         if (n_outputs().n_total() == 0) {
2775                 return 0;
2776         }
2777
2778         if (!_active || n_inputs() == ChanCount::ZERO)  {
2779                 silence_unlocked (nframes);
2780                 return 0;
2781         }
2782         if (session_state_changing) {
2783                 if (_session.transport_speed() != 0.0f) {
2784                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2785                            so we cannot use them. Be silent till this is over.
2786
2787                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2788                         */
2789                         silence_unlocked (nframes);
2790                         return 0;
2791                 }
2792                 /* we're really not rolling, so we're either delivery silence or actually
2793                    monitoring, both of which are safe to do while session_state_changing is true.
2794                 */
2795         }
2796
2797         _amp->apply_gain_automation (false);
2798         passthru (start_frame, end_frame, nframes, 0);
2799
2800         return 0;
2801 }
2802
2803 framecnt_t
2804 Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
2805 {
2806         if (_roll_delay > nframes) {
2807
2808                 _roll_delay -= nframes;
2809                 silence_unlocked (nframes);
2810                 /* transport frame is not legal for caller to use */
2811                 return 0;
2812
2813         } else if (_roll_delay > 0) {
2814
2815                 nframes -= _roll_delay;
2816                 silence_unlocked (_roll_delay);
2817                 /* we've written _roll_delay of samples into the
2818                    output ports, so make a note of that for
2819                    future reference.
2820                 */
2821                 _main_outs->increment_output_offset (_roll_delay);
2822                 transport_frame += _roll_delay;
2823
2824                 _roll_delay = 0;
2825         }
2826
2827         return nframes;
2828 }
2829
2830 int
2831 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2832              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2833 {
2834         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2835         if (!lm.locked()) {
2836                 return 0;
2837         }
2838
2839         automation_snapshot (_session.transport_frame(), false);
2840
2841         if (n_outputs().n_total() == 0) {
2842                 return 0;
2843         }
2844
2845         if (!_active || n_inputs().n_total() == 0) {
2846                 silence_unlocked (nframes);
2847                 return 0;
2848         }
2849
2850         framecnt_t unused = 0;
2851
2852         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2853                 return 0;
2854         }
2855
2856         _silent = false;
2857
2858         passthru (start_frame, end_frame, nframes, declick);
2859
2860         return 0;
2861 }
2862
2863 int
2864 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2865                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2866 {
2867         silence (nframes);
2868         return 0;
2869 }
2870
2871 void
2872 Route::toggle_monitor_input ()
2873 {
2874         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2875                 i->ensure_monitor_input( ! i->monitoring_input());
2876         }
2877 }
2878
2879 bool
2880 Route::has_external_redirects () const
2881 {
2882         // FIXME: what about sends? - they don't return a signal back to ardour?
2883
2884         boost::shared_ptr<const PortInsert> pi;
2885
2886         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2887
2888                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2889
2890                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2891
2892                                 string port_name = port->name();
2893                                 string client_name = port_name.substr (0, port_name.find(':'));
2894
2895                                 /* only say "yes" if the redirect is actually in use */
2896
2897                                 if (client_name != "ardour" && pi->active()) {
2898                                         return true;
2899                                 }
2900                         }
2901                 }
2902         }
2903
2904         return false;
2905 }
2906
2907 void
2908 Route::flush_processors ()
2909 {
2910         /* XXX shouldn't really try to take this lock, since
2911            this is called from the RT audio thread.
2912         */
2913
2914         Glib::RWLock::ReaderLock lm (_processor_lock);
2915
2916         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2917                 (*i)->flush ();
2918         }
2919 }
2920
2921 void
2922 Route::set_meter_point (MeterPoint p, bool force)
2923 {
2924         /* CAN BE CALLED FROM PROCESS CONTEXT */
2925
2926         if (_meter_point == p && !force) {
2927                 return;
2928         }
2929
2930         _meter_point = p;
2931
2932         bool meter_was_visible_to_user = _meter->display_to_user ();
2933
2934         {
2935                 Glib::RWLock::WriterLock lm (_processor_lock);
2936
2937                 if (_meter_point != MeterCustom) {
2938
2939                         _meter->set_display_to_user (false);
2940
2941                         setup_invisible_processors ();
2942
2943                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2944
2945                         ChanCount m_in;
2946
2947                         if (loc == _processors.begin()) {
2948                                 m_in = _input->n_ports();
2949                         } else {
2950                                 ProcessorList::iterator before = loc;
2951                                 --before;
2952                                 m_in = (*before)->output_streams ();
2953                         }
2954
2955                         _meter->reflect_inputs (m_in);
2956
2957                         /* we do not need to reconfigure the processors, because the meter
2958                            (a) is always ready to handle processor_max_streams
2959                            (b) is always an N-in/N-out processor, and thus moving
2960                            it doesn't require any changes to the other processors.
2961                         */
2962
2963                 } else {
2964
2965                         // just make it visible and let the user move it
2966
2967                         _meter->set_display_to_user (true);
2968                 }
2969         }
2970
2971         meter_change (); /* EMIT SIGNAL */
2972
2973         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2974
2975         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2976 }
2977
2978 void
2979 Route::listen_position_changed ()
2980 {
2981         {
2982                 Glib::RWLock::WriterLock lm (_processor_lock);
2983                 ProcessorState pstate (this);
2984
2985                 {
2986                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2987
2988                         if (configure_processors_unlocked (0)) {
2989                                 pstate.restore ();
2990                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
2991                                 return;
2992                         }
2993                 }
2994         }
2995
2996         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2997         _session.set_dirty ();
2998 }
2999
3000 boost::shared_ptr<CapturingProcessor>
3001 Route::add_export_point()
3002 {
3003         if (!_capturing_processor) {
3004
3005                 _capturing_processor.reset (new CapturingProcessor (_session));
3006                 _capturing_processor->activate ();
3007
3008                 {
3009                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3010                         configure_processors (0);
3011                 }
3012
3013         }
3014
3015         return _capturing_processor;
3016 }
3017
3018 framecnt_t
3019 Route::update_total_latency ()
3020 {
3021         framecnt_t old = _output->effective_latency();
3022         framecnt_t own_latency = _output->user_latency();
3023
3024         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3025                 if ((*i)->active ()) {
3026                         own_latency += (*i)->signal_latency ();
3027                 }
3028         }
3029
3030         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
3031
3032         _output->set_port_latency (own_latency);
3033
3034         if (_output->user_latency() == 0) {
3035
3036                 /* this (virtual) function is used for pure Routes,
3037                    not derived classes like AudioTrack.  this means
3038                    that the data processed here comes from an input
3039                    port, not prerecorded material, and therefore we
3040                    have to take into account any input latency.
3041                 */
3042
3043                 own_latency += _input->signal_latency ();
3044         }
3045
3046         if (old != own_latency) {
3047                 _output->set_latency_delay (own_latency);
3048                 signal_latency_changed (); /* EMIT SIGNAL */
3049         }
3050
3051         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
3052
3053         return _output->effective_latency ();
3054 }
3055
3056 void
3057 Route::set_user_latency (framecnt_t nframes)
3058 {
3059         _output->set_user_latency (nframes);
3060         _session.update_latency_compensation (false, false);
3061 }
3062
3063 void
3064 Route::set_latency_delay (framecnt_t longest_session_latency)
3065 {
3066         framecnt_t old = _initial_delay;
3067
3068         if (_output->effective_latency() < longest_session_latency) {
3069                 _initial_delay = longest_session_latency - _output->effective_latency();
3070         } else {
3071                 _initial_delay = 0;
3072         }
3073
3074         if (_initial_delay != old) {
3075                 initial_delay_changed (); /* EMIT SIGNAL */
3076         }
3077
3078         if (_session.transport_stopped()) {
3079                 _roll_delay = _initial_delay;
3080         }
3081 }
3082
3083 void
3084 Route::automation_snapshot (framepos_t now, bool force)
3085 {
3086         _pannable->automation_snapshot (now, force);
3087         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3088                 (*i)->automation_snapshot (now, force);
3089         }
3090 }
3091
3092 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3093         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3094                              boost::shared_ptr<AutomationList>(), name)
3095         , _route (r)
3096 {
3097         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3098         set_list (gl);
3099 }
3100
3101 void
3102 Route::SoloControllable::set_value (double val)
3103 {
3104         bool bval = ((val >= 0.5f) ? true: false);
3105
3106         boost::shared_ptr<RouteList> rl (new RouteList);
3107
3108         boost::shared_ptr<Route> r = _route.lock ();
3109         if (!r) {
3110                 return;
3111         }
3112
3113         rl->push_back (r);
3114
3115         if (Config->get_solo_control_is_listen_control()) {
3116                 _session.set_listen (rl, bval);
3117         } else {
3118                 _session.set_solo (rl, bval);
3119         }
3120 }
3121
3122 double
3123 Route::SoloControllable::get_value () const
3124 {
3125         boost::shared_ptr<Route> r = _route.lock ();
3126         if (!r) {
3127                 return 0;
3128         }
3129
3130         if (Config->get_solo_control_is_listen_control()) {
3131                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3132         } else {
3133                 return r->self_soloed() ? 1.0f : 0.0f;
3134         }
3135 }
3136
3137 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3138         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3139                              boost::shared_ptr<AutomationList>(), name)
3140         , _route (r)
3141 {
3142         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3143         set_list (gl);
3144 }
3145
3146 void
3147 Route::MuteControllable::set_value (double val)
3148 {
3149         bool bval = ((val >= 0.5f) ? true: false);
3150
3151         boost::shared_ptr<RouteList> rl (new RouteList);
3152
3153         boost::shared_ptr<Route> r = _route.lock ();
3154         if (!r) {
3155                 return;
3156         }
3157
3158         rl->push_back (r);
3159         _session.set_mute (rl, bval);
3160 }
3161
3162 double
3163 Route::MuteControllable::get_value () const
3164 {
3165         boost::shared_ptr<Route> r = _route.lock ();
3166         if (!r) {
3167                 return 0;
3168         }
3169
3170         return r->muted() ? 1.0f : 0.0f;
3171 }
3172
3173 void
3174 Route::set_block_size (pframes_t nframes)
3175 {
3176         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3177                 (*i)->set_block_size (nframes);
3178         }
3179
3180         _session.ensure_buffers (n_process_buffers ());
3181 }
3182
3183 void
3184 Route::protect_automation ()
3185 {
3186         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3187                 (*i)->protect_automation();
3188 }
3189
3190 void
3191 Route::set_pending_declick (int declick)
3192 {
3193         if (_declickable) {
3194                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3195                 if (declick) {
3196                         _pending_declick = declick;
3197                 }
3198                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3199         } else {
3200                 _pending_declick = 0;
3201         }
3202
3203 }
3204
3205 /** Shift automation forwards from a particular place, thereby inserting time.
3206  *  Adds undo commands for any shifts that are performed.
3207  *
3208  * @param pos Position to start shifting from.
3209  * @param frames Amount to shift forwards by.
3210  */
3211
3212 void
3213 Route::shift (framepos_t pos, framecnt_t frames)
3214 {
3215         /* gain automation */
3216         {
3217                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3218
3219                 XMLNode &before = gc->alist()->get_state ();
3220                 gc->alist()->shift (pos, frames);
3221                 XMLNode &after = gc->alist()->get_state ();
3222                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3223         }
3224
3225         /* pan automation */
3226         {
3227                 ControlSet::Controls& c (_pannable->controls());
3228
3229                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3230                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3231                         if (pc) {
3232                                 boost::shared_ptr<AutomationList> al = pc->alist();
3233                                 XMLNode& before = al->get_state ();
3234                                 al->shift (pos, frames);
3235                                 XMLNode& after = al->get_state ();
3236                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3237                         }
3238                 }
3239         }
3240
3241         /* redirect automation */
3242         {
3243                 Glib::RWLock::ReaderLock lm (_processor_lock);
3244                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3245
3246                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3247
3248                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3249                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3250                                 if (ac) {
3251                                         boost::shared_ptr<AutomationList> al = ac->alist();
3252                                         XMLNode &before = al->get_state ();
3253                                         al->shift (pos, frames);
3254                                         XMLNode &after = al->get_state ();
3255                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3256                                 }
3257                         }
3258                 }
3259         }
3260 }
3261
3262
3263 int
3264 Route::save_as_template (const string& path, const string& name)
3265 {
3266         XMLNode& node (state (false));
3267         XMLTree tree;
3268
3269         IO::set_name_in_state (*node.children().front(), name);
3270
3271         tree.set_root (&node);
3272         return tree.write (path.c_str());
3273 }
3274
3275
3276 bool
3277 Route::set_name (const string& str)
3278 {
3279         bool ret;
3280         string ioproc_name;
3281         string name;
3282
3283         name = Route::ensure_track_or_route_name (str, _session);
3284         SessionObject::set_name (name);
3285
3286         ret = (_input->set_name(name) && _output->set_name(name));
3287
3288         if (ret) {
3289
3290                 Glib::RWLock::ReaderLock lm (_processor_lock);
3291
3292                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3293
3294                         /* rename all I/O processors that have inputs or outputs */
3295
3296                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3297
3298                         if (iop && (iop->output() || iop->input())) {
3299                                 if (!iop->set_name (name)) {
3300                                         ret = false;
3301                                 }
3302                         }
3303                 }
3304
3305         }
3306
3307         return ret;
3308 }
3309
3310 boost::shared_ptr<Send>
3311 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3312 {
3313         Glib::RWLock::ReaderLock lm (_processor_lock);
3314
3315         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3316                 boost::shared_ptr<InternalSend> send;
3317
3318                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3319                         if (send->target_route() == target) {
3320                                 return send;
3321                         }
3322                 }
3323         }
3324
3325         return boost::shared_ptr<Send>();
3326 }
3327
3328 /** @param c Audio channel index.
3329  *  @param yn true to invert phase, otherwise false.
3330  */
3331 void
3332 Route::set_phase_invert (uint32_t c, bool yn)
3333 {
3334         if (_phase_invert[c] != yn) {
3335                 _phase_invert[c] = yn;
3336                 phase_invert_changed (); /* EMIT SIGNAL */
3337                 _session.set_dirty ();
3338         }
3339 }
3340
3341 void
3342 Route::set_phase_invert (boost::dynamic_bitset<> p)
3343 {
3344         if (_phase_invert != p) {
3345                 _phase_invert = p;
3346                 phase_invert_changed (); /* EMIT SIGNAL */
3347                 _session.set_dirty ();
3348         }
3349 }
3350
3351 bool
3352 Route::phase_invert (uint32_t c) const
3353 {
3354         return _phase_invert[c];
3355 }
3356
3357 boost::dynamic_bitset<>
3358 Route::phase_invert () const
3359 {
3360         return _phase_invert;
3361 }
3362
3363 void
3364 Route::set_denormal_protection (bool yn)
3365 {
3366         if (_denormal_protection != yn) {
3367                 _denormal_protection = yn;
3368                 denormal_protection_changed (); /* EMIT SIGNAL */
3369         }
3370 }
3371
3372 bool
3373 Route::denormal_protection () const
3374 {
3375         return _denormal_protection;
3376 }
3377
3378 void
3379 Route::set_active (bool yn, void* src)
3380 {
3381         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3382                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3383                 return;
3384         }
3385
3386         if (_active != yn) {
3387                 _active = yn;
3388                 _input->set_active (yn);
3389                 _output->set_active (yn);
3390                 active_changed (); // EMIT SIGNAL
3391         }
3392 }
3393
3394 void
3395 Route::meter ()
3396 {
3397         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3398
3399         assert (_meter);
3400
3401         _meter->meter ();
3402
3403         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3404
3405                 boost::shared_ptr<Send> s;
3406                 boost::shared_ptr<Return> r;
3407
3408                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3409                         s->meter()->meter();
3410                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3411                         r->meter()->meter ();
3412                 }
3413         }
3414 }
3415
3416 boost::shared_ptr<Pannable>
3417 Route::pannable() const
3418 {
3419         return _pannable;
3420 }
3421
3422 boost::shared_ptr<Panner>
3423 Route::panner() const
3424 {
3425         /* may be null ! */
3426         return _main_outs->panner_shell()->panner();
3427 }
3428
3429 boost::shared_ptr<PannerShell>
3430 Route::panner_shell() const
3431 {
3432         return _main_outs->panner_shell();
3433 }
3434
3435 boost::shared_ptr<AutomationControl>
3436 Route::gain_control() const
3437 {
3438         return _amp->gain_control();
3439 }
3440
3441 boost::shared_ptr<AutomationControl>
3442 Route::get_control (const Evoral::Parameter& param)
3443 {
3444         /* either we own the control or .... */
3445
3446         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3447
3448         if (!c) {
3449
3450                 /* maybe one of our processors does or ... */
3451
3452                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3453                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3454                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3455                                 break;
3456                         }
3457                 }
3458         }
3459
3460         if (!c) {
3461
3462                 /* nobody does so we'll make a new one */
3463
3464                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3465                 add_control(c);
3466         }
3467
3468         return c;
3469 }
3470
3471 boost::shared_ptr<Processor>
3472 Route::nth_plugin (uint32_t n)
3473 {
3474         Glib::RWLock::ReaderLock lm (_processor_lock);
3475         ProcessorList::iterator i;
3476
3477         for (i = _processors.begin(); i != _processors.end(); ++i) {
3478                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3479                         if (n-- == 0) {
3480                                 return *i;
3481                         }
3482                 }
3483         }
3484
3485         return boost::shared_ptr<Processor> ();
3486 }
3487
3488 boost::shared_ptr<Processor>
3489 Route::nth_send (uint32_t n)
3490 {
3491         Glib::RWLock::ReaderLock lm (_processor_lock);
3492         ProcessorList::iterator i;
3493
3494         for (i = _processors.begin(); i != _processors.end(); ++i) {
3495                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3496                         if (n-- == 0) {
3497                                 return *i;
3498                         }
3499                 }
3500         }
3501
3502         return boost::shared_ptr<Processor> ();
3503 }
3504
3505 bool
3506 Route::has_io_processor_named (const string& name)
3507 {
3508         Glib::RWLock::ReaderLock lm (_processor_lock);
3509         ProcessorList::iterator i;
3510
3511         for (i = _processors.begin(); i != _processors.end(); ++i) {
3512                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3513                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3514                         if ((*i)->name() == name) {
3515                                 return true;
3516                         }
3517                 }
3518         }
3519
3520         return false;
3521 }
3522
3523 MuteMaster::MutePoint
3524 Route::mute_points () const
3525 {
3526         return _mute_master->mute_points ();
3527 }
3528
3529 void
3530 Route::set_processor_positions ()
3531 {
3532         Glib::RWLock::ReaderLock lm (_processor_lock);
3533
3534         bool had_amp = false;
3535         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3536                 (*i)->set_pre_fader (!had_amp);
3537                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3538                         had_amp = true;
3539                 }
3540         }
3541 }
3542
3543 /** Called when there is a proposed change to the input port count */
3544 bool
3545 Route::input_port_count_changing (ChanCount to)
3546 {
3547         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3548         if (c.empty()) {
3549                 /* The processors cannot be configured with the new input arrangement, so
3550                    block the change.
3551                 */
3552                 return true;
3553         }
3554
3555         /* The change is ok */
3556         return false;
3557 }
3558
3559 list<string>
3560 Route::unknown_processors () const
3561 {
3562         list<string> p;
3563
3564         Glib::RWLock::ReaderLock lm (_processor_lock);
3565         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3566                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3567                         p.push_back ((*i)->name ());
3568                 }
3569         }
3570
3571         return p;
3572 }
3573
3574 void
3575 Route::set_latency_ranges (bool playback) const
3576 {
3577         framecnt_t own_latency = 0;
3578
3579         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD OR
3580            LATENCY CALLBACK
3581         */
3582
3583         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3584                 if ((*i)->active ()) {
3585                         own_latency += (*i)->signal_latency ();
3586                 }
3587         }
3588
3589         if (playback) {
3590                 update_port_latencies (_input->ports (), _output->ports (), true, own_latency);
3591         } else {
3592                 update_port_latencies (_output->ports (), _input->ports (), false, own_latency);
3593         }
3594 }
3595
3596 void
3597 Route::update_port_latencies (const PortSet& operands, const PortSet& feeders, bool playback, framecnt_t our_latency) const
3598 {
3599 #ifdef HAVE_JACK_NEW_LATENCY
3600
3601         /* we assume that all our input ports feed all our output ports. its not
3602            universally true, but the alternative is way too corner-case to worry about.
3603         */
3604
3605         jack_latency_range_t all_connections;
3606
3607         all_connections.min = ~((jack_nframes_t) 0);
3608         all_connections.max = 0;
3609
3610         /* iterate over all feeder ports and determine their relevant latency, taking
3611            the maximum and minimum across all of them.
3612         */
3613
3614         for (PortSet::const_iterator p = feeders.begin(); p != feeders.end(); ++p) {
3615
3616                 jack_latency_range_t range;
3617
3618                 p->get_connected_latency_range (range, playback);
3619
3620                 all_connections.min = min (all_connections.min, range.min);
3621                 all_connections.max = max (all_connections.max, range.max);
3622         }
3623
3624         all_connections.min += our_latency;
3625         all_connections.max += our_latency;
3626
3627         for (PortSet::const_iterator p = operands.begin(); p != operands.end(); ++p) {
3628
3629                 p->set_latency_range (all_connections, playback);
3630
3631                 DEBUG_TRACE (DEBUG::Latency, string_compose ("Port %1 %5 latency range %2 .. %3 (including route latency of %4)\n",
3632                                                              p->name(),
3633                                                              all_connections.min,
3634                                                              all_connections.max,
3635                                                              our_latency,
3636                                                              (playback ? "PLAYBACK" : "CAPTURE")));
3637         }
3638 #endif
3639 }
3640
3641
3642 /** Put the invisible processors in the right place in _processors.
3643  *  Must be called with a writer lock on _processor_lock held.
3644  */
3645 void
3646 Route::setup_invisible_processors ()
3647 {
3648 #ifndef NDEBUG
3649         Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3650         assert (!lm.locked ());
3651 #endif
3652
3653         if (!_main_outs) {
3654                 /* too early to be doing this stuff */
3655                 return;
3656         }
3657
3658         /* we'll build this new list here and then use it */
3659
3660         ProcessorList new_processors;
3661
3662         /* find visible processors */
3663
3664         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3665                 if ((*i)->display_to_user ()) {
3666                         new_processors.push_back (*i);
3667                 }
3668         }
3669
3670         /* find the amp */
3671
3672         ProcessorList::iterator amp = new_processors.begin ();
3673         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3674                 ++amp;
3675         }
3676
3677         assert (amp != _processors.end ());
3678
3679         /* and the processor after the amp */
3680
3681         ProcessorList::iterator after_amp = amp;
3682         ++after_amp;
3683
3684         /* METER */
3685
3686         if (_meter) {
3687                 switch (_meter_point) {
3688                 case MeterInput:
3689                         assert (!_meter->display_to_user ());
3690                         new_processors.push_front (_meter);
3691                         break;
3692                 case MeterPreFader:
3693                         assert (!_meter->display_to_user ());
3694                         new_processors.insert (amp, _meter);
3695                         break;
3696                 case MeterPostFader:
3697                         /* do nothing here */
3698                         break;
3699                 case MeterOutput:
3700                         /* do nothing here */
3701                         break;
3702                 case MeterCustom:
3703                         /* the meter is visible, so we don't touch it here */
3704                         break;
3705                 }
3706         }
3707
3708         /* MAIN OUTS */
3709
3710         assert (_main_outs);
3711         assert (!_main_outs->display_to_user ());
3712         new_processors.push_back (_main_outs);
3713
3714         /* iterator for the main outs */
3715
3716         ProcessorList::iterator main = new_processors.end();
3717         --main;
3718
3719         /* OUTPUT METERING */
3720
3721         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3722                 assert (!_meter->display_to_user ());
3723
3724                 /* add the processor just before or just after the main outs */
3725
3726                 ProcessorList::iterator meter_point = main;
3727
3728                 if (_meter_point == MeterOutput) {
3729                         ++meter_point;
3730                 }
3731                 new_processors.insert (meter_point, _meter);
3732         }
3733
3734         /* MONITOR SEND */
3735
3736         if (_monitor_send && !is_monitor ()) {
3737                 assert (!_monitor_send->display_to_user ());
3738                 if (Config->get_solo_control_is_listen_control()) {
3739                         switch (Config->get_listen_position ()) {
3740                         case PreFaderListen:
3741                                 switch (Config->get_pfl_position ()) {
3742                                 case PFLFromBeforeProcessors:
3743                                         new_processors.push_front (_monitor_send);
3744                                         break;
3745                                 case PFLFromAfterProcessors:
3746                                         new_processors.insert (amp, _monitor_send);
3747                                         break;
3748                                 }
3749                                 break;
3750                         case AfterFaderListen:
3751                                 switch (Config->get_afl_position ()) {
3752                                 case AFLFromBeforeProcessors:
3753                                         new_processors.insert (after_amp, _monitor_send);
3754                                         break;
3755                                 case AFLFromAfterProcessors:
3756                                         new_processors.insert (new_processors.end(), _monitor_send);
3757                                         break;
3758                                 }
3759                                 break;
3760                         }
3761                 }  else {
3762                         new_processors.insert (new_processors.end(), _monitor_send);
3763                 }
3764         }
3765
3766         /* MONITOR CONTROL */
3767
3768         if (_monitor_control && is_monitor ()) {
3769                 assert (!_monitor_control->display_to_user ());
3770                 new_processors.push_front (_monitor_control);
3771         }
3772
3773         /* INTERNAL RETURN */
3774
3775         /* doing this here means that any monitor control will come just after
3776            the return.
3777         */
3778
3779         if (_intreturn) {
3780                 assert (!_intreturn->display_to_user ());
3781                 new_processors.push_front (_intreturn);
3782         }
3783
3784         /* EXPORT PROCESSOR */
3785
3786         if (_capturing_processor) {
3787                 assert (!_capturing_processor->display_to_user ());
3788                 new_processors.push_front (_capturing_processor);
3789         }
3790
3791         _processors = new_processors;
3792
3793         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3794         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3795                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3796         }
3797 }
3798
3799 bool
3800 Route::should_monitor () const
3801 {
3802         switch (Config->get_monitoring_model()) {
3803         case HardwareMonitoring:
3804         case ExternalMonitoring:
3805                 return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
3806                 break;
3807         default:
3808                 break;
3809         }
3810
3811         return true;
3812 }
3813