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                         _mute_master->set_muted_by_self (true);
2133                 }
2134         }
2135
2136         if ((prop = node.property (X_("meter-point"))) != 0) {
2137                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2138         }
2139
2140         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2141            don't mean the same thing.
2142         */
2143
2144         if ((prop = node.property (X_("order-keys"))) != 0) {
2145
2146                 int32_t n;
2147
2148                 string::size_type colon, equal;
2149                 string remaining = prop->value();
2150
2151                 while (remaining.length()) {
2152
2153                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2154                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2155                                         << endmsg;
2156                         } else {
2157                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2158                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2159                                                 << endmsg;
2160                                 } else {
2161                                         set_order_key (remaining.substr (0, equal), n);
2162                                 }
2163                         }
2164
2165                         colon = remaining.find_first_of (':');
2166
2167                         if (colon != string::npos) {
2168                                 remaining = remaining.substr (colon+1);
2169                         } else {
2170                                 break;
2171                         }
2172                 }
2173         }
2174
2175         /* IOs */
2176
2177         nlist = node.children ();
2178         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2179
2180                 child = *niter;
2181
2182                 if (child->name() == IO::state_node_name) {
2183
2184                         /* there is a note in IO::set_state_2X() about why we have to call
2185                            this directly.
2186                            */
2187
2188                         _input->set_state_2X (*child, version, true);
2189                         _output->set_state_2X (*child, version, false);
2190
2191                         if ((prop = child->property (X_("name"))) != 0) {
2192                                 Route::set_name (prop->value ());
2193                         }
2194
2195                         if ((prop = child->property (X_("id"))) != 0) {
2196                                 _id = prop->value ();
2197                         }
2198
2199                         if ((prop = child->property (X_("active"))) != 0) {
2200                                 bool yn = string_is_affirmative (prop->value());
2201                                 _active = !yn; // force switch
2202                                 set_active (yn, this);
2203                         }
2204
2205                         if ((prop = child->property (X_("gain"))) != 0) {
2206                                 gain_t val;
2207
2208                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2209                                         _amp->gain_control()->set_value (val);
2210                                 }
2211                         }
2212
2213                         /* Set up Panners in the IO */
2214                         XMLNodeList io_nlist = child->children ();
2215
2216                         XMLNodeConstIterator io_niter;
2217                         XMLNode *io_child;
2218
2219                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2220
2221                                 io_child = *io_niter;
2222
2223                                 if (io_child->name() == X_("Panner")) {
2224                                         _main_outs->panner_shell()->set_state(*io_child, version);
2225                                 } else if (io_child->name() == X_("Automation")) {
2226                                         /* IO's automation is for the fader */
2227                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2228                                 }
2229                         }
2230                 }
2231         }
2232
2233         XMLNodeList redirect_nodes;
2234
2235         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2236
2237                 child = *niter;
2238
2239                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2240                         redirect_nodes.push_back(child);
2241                 }
2242
2243         }
2244
2245         set_processor_state_2X (redirect_nodes, version);
2246
2247         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2248                 child = *niter;
2249
2250                 if (child->name() == X_("Comment")) {
2251
2252                         /* XXX this is a terrible API design in libxml++ */
2253
2254                         XMLNode *cmt = *(child->children().begin());
2255                         _comment = cmt->content();
2256
2257                 } else if (child->name() == X_("extra")) {
2258
2259                         _extra_xml = new XMLNode (*child);
2260
2261                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2262                         if (prop->value() == X_("solo")) {
2263                                 _solo_control->set_state (*child, version);
2264                         } else if (prop->value() == X_("mute")) {
2265                                 _mute_control->set_state (*child, version);
2266                         }
2267
2268                 } else if (child->name() == X_("RemoteControl")) {
2269                         if ((prop = child->property (X_("id"))) != 0) {
2270                                 int32_t x;
2271                                 sscanf (prop->value().c_str(), "%d", &x);
2272                                 set_remote_control_id (x);
2273                         }
2274
2275                 }
2276         }
2277
2278         return 0;
2279 }
2280
2281 XMLNode&
2282 Route::get_processor_state ()
2283 {
2284         XMLNode* root = new XMLNode (X_("redirects"));
2285         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2286                 root->add_child_nocopy ((*i)->state (true));
2287         }
2288
2289         return *root;
2290 }
2291
2292 void
2293 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2294 {
2295         /* We don't bother removing existing processors not in nList, as this
2296            method will only be called when creating a Route from scratch, not
2297            for undo purposes.  Just put processors in at the appropriate place
2298            in the list.
2299         */
2300
2301         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2302                 add_processor_from_xml_2X (**i, version);
2303         }
2304 }
2305
2306 void
2307 Route::set_processor_state (const XMLNode& node)
2308 {
2309         const XMLNodeList &nlist = node.children();
2310         XMLNodeConstIterator niter;
2311         ProcessorList new_order;
2312         bool must_configure = false;
2313
2314         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2315
2316                 XMLProperty* prop = (*niter)->property ("type");
2317
2318                 if (prop->value() == "amp") {
2319                         _amp->set_state (**niter, Stateful::current_state_version);
2320                         new_order.push_back (_amp);
2321                 } else if (prop->value() == "meter") {
2322                         _meter->set_state (**niter, Stateful::current_state_version);
2323                 } else if (prop->value() == "main-outs") {
2324                         _main_outs->set_state (**niter, Stateful::current_state_version);
2325                 } else if (prop->value() == "intreturn") {
2326                         if (!_intreturn) {
2327                                 _intreturn.reset (new InternalReturn (_session));
2328                                 must_configure = true;
2329                         }
2330                         _intreturn->set_state (**niter, Stateful::current_state_version);
2331                 } else if (is_monitor() && prop->value() == "monitor") {
2332                         if (!_monitor_control) {
2333                                 _monitor_control.reset (new MonitorProcessor (_session));
2334                                 must_configure = true;
2335                         }
2336                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2337                 } else if (prop->value() == "capture") {
2338                         _capturing_processor.reset (new CapturingProcessor (_session));
2339                 } else {
2340                         ProcessorList::iterator o;
2341
2342                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2343                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2344                                 if (id_prop && (*o)->id() == id_prop->value()) {
2345                                         (*o)->set_state (**niter, Stateful::current_state_version);
2346                                         new_order.push_back (*o);
2347                                         break;
2348                                 }
2349                         }
2350
2351                         // If the processor (*niter) is not on the route then create it
2352
2353                         if (o == _processors.end()) {
2354
2355                                 boost::shared_ptr<Processor> processor;
2356
2357                                 if (prop->value() == "intsend") {
2358
2359                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2360                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2361                                            prop->value() == "lv2" ||
2362                                            prop->value() == "vst" ||
2363                                            prop->value() == "audiounit") {
2364
2365                                         processor.reset (new PluginInsert(_session));
2366
2367                                 } else if (prop->value() == "port") {
2368
2369                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2370
2371                                 } else if (prop->value() == "send") {
2372
2373                                         processor.reset (new Send (_session, _pannable, _mute_master));
2374
2375                                 } else {
2376                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2377                                         continue;
2378                                 }
2379
2380                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2381                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2382                                         processor.reset (new UnknownProcessor (_session, **niter));
2383                                 }
2384
2385                                 /* we have to note the monitor send here, otherwise a new one will be created
2386                                    and the state of this one will be lost.
2387                                 */
2388                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2389                                 if (isend && isend->role() == Delivery::Listen) {
2390                                         _monitor_send = isend;
2391                                 }
2392
2393                                 /* it doesn't matter if invisible processors are added here, as they
2394                                    will be sorted out by setup_invisible_processors () shortly.
2395                                 */
2396
2397                                 new_order.push_back (processor);
2398                                 must_configure = true;
2399                         }
2400                 }
2401         }
2402
2403         {
2404                 Glib::RWLock::WriterLock lm (_processor_lock);
2405                 _processors = new_order;
2406                 if (must_configure) {
2407                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2408                         configure_processors_unlocked (0);
2409                 }
2410         }
2411
2412         processors_changed (RouteProcessorChange ());
2413         set_processor_positions ();
2414 }
2415
2416 void
2417 Route::curve_reallocate ()
2418 {
2419 //      _gain_automation_curve.finish_resize ();
2420 //      _pan_automation_curve.finish_resize ();
2421 }
2422
2423 void
2424 Route::silence (framecnt_t nframes)
2425 {
2426         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2427         if (!lm.locked()) {
2428                 return;
2429         }
2430
2431         silence_unlocked (nframes);
2432 }
2433
2434 void
2435 Route::silence_unlocked (framecnt_t nframes)
2436 {
2437         /* Must be called with the processor lock held */
2438
2439         if (!_silent) {
2440
2441                 _output->silence (nframes);
2442
2443                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2444                         boost::shared_ptr<PluginInsert> pi;
2445
2446                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2447                                 // skip plugins, they don't need anything when we're not active
2448                                 continue;
2449                         }
2450
2451                         (*i)->silence (nframes);
2452                 }
2453
2454                 if (nframes == _session.get_block_size()) {
2455                         // _silent = true;
2456                 }
2457         }
2458 }
2459
2460 void
2461 Route::add_internal_return ()
2462 {
2463         if (!_intreturn) {
2464                 _intreturn.reset (new InternalReturn (_session));
2465                 add_processor (_intreturn, PreFader);
2466         }
2467 }
2468
2469 void
2470 Route::add_send_to_internal_return (InternalSend* send)
2471 {
2472         Glib::RWLock::ReaderLock rm (_processor_lock);
2473
2474         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2475                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2476
2477                 if (d) {
2478                         return d->add_send (send);
2479                 }
2480         }
2481 }
2482
2483 void
2484 Route::remove_send_from_internal_return (InternalSend* send)
2485 {
2486         Glib::RWLock::ReaderLock rm (_processor_lock);
2487
2488         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2489                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2490
2491                 if (d) {
2492                         return d->remove_send (send);
2493                 }
2494         }
2495 }
2496
2497 /** Add a monitor send (if we don't already have one) but don't activate it */
2498 int
2499 Route::listen_via_monitor ()
2500 {
2501         /* master never sends to control outs */
2502         assert (!is_master ());
2503
2504         /* make sure we have one */
2505         if (!_monitor_send) {
2506                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2507                 _monitor_send->set_display_to_user (false);
2508         }
2509
2510         /* set it up */
2511         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2512         configure_processors (0);
2513
2514         return 0;
2515 }
2516
2517 /** Add an internal send to a route.
2518  *  @param route route to send to.
2519  *  @param placement placement for the send.
2520  */
2521 int
2522 Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
2523 {
2524         assert (route != _session.monitor_out ());
2525
2526         {
2527                 Glib::RWLock::ReaderLock rm (_processor_lock);
2528
2529                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2530
2531                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2532
2533                         if (d && d->target_route() == route) {
2534                                 /* already listening via the specified IO: do nothing */
2535                                 return 0;
2536                         }
2537                 }
2538         }
2539
2540         try {
2541                 boost::shared_ptr<InternalSend> listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2542                 add_processor (listener, placement);
2543
2544         } catch (failed_constructor& err) {
2545                 return -1;
2546         }
2547
2548         return 0;
2549 }
2550
2551 void
2552 Route::drop_listen (boost::shared_ptr<Route> route)
2553 {
2554         ProcessorStreams err;
2555         ProcessorList::iterator tmp;
2556
2557         Glib::RWLock::ReaderLock rl(_processor_lock);
2558         rl.acquire ();
2559
2560   again:
2561         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2562
2563                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2564
2565                 if (d && d->target_route() == route) {
2566                         rl.release ();
2567                         remove_processor (*x, &err);
2568                         rl.acquire ();
2569
2570                         /* list could have been demolished while we dropped the lock
2571                            so start over.
2572                         */
2573
2574                         goto again;
2575                 }
2576         }
2577
2578         rl.release ();
2579
2580         if (route == _session.monitor_out()) {
2581                 _monitor_send.reset ();
2582         }
2583 }
2584
2585 void
2586 Route::set_comment (string cmt, void *src)
2587 {
2588         _comment = cmt;
2589         comment_changed (src);
2590         _session.set_dirty ();
2591 }
2592
2593 bool
2594 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2595 {
2596         FeedRecord fr (other, via_sends_only);
2597
2598         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2599
2600         if (!result.second) {
2601
2602                 /* already a record for "other" - make sure sends-only information is correct */
2603                 if (!via_sends_only && result.first->sends_only) {
2604                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2605                         frp->sends_only = false;
2606                 }
2607         }
2608
2609         return result.second;
2610 }
2611
2612 void
2613 Route::clear_fed_by ()
2614 {
2615         _fed_by.clear ();
2616 }
2617
2618 bool
2619 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2620 {
2621         const FedBy& fed_by (other->fed_by());
2622
2623         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2624                 boost::shared_ptr<Route> sr = f->r.lock();
2625
2626                 if (sr && (sr.get() == this)) {
2627
2628                         if (via_sends_only) {
2629                                 *via_sends_only = f->sends_only;
2630                         }
2631
2632                         return true;
2633                 }
2634         }
2635
2636         return false;
2637 }
2638
2639 bool
2640 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2641 {
2642         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2643
2644         if (_output->connected_to (other->input())) {
2645                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2646                 if (only_send) {
2647                         *only_send = false;
2648                 }
2649
2650                 return true;
2651         }
2652
2653
2654         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2655
2656                 boost::shared_ptr<IOProcessor> iop;
2657
2658                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2659                         if (iop->feeds (other)) {
2660                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2661                                 if (only_send) {
2662                                         *only_send = true;
2663                                 }
2664                                 return true;
2665                         } else {
2666                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2667                         }
2668                 } else {
2669                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2670                 }
2671
2672         }
2673
2674         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2675         return false;
2676 }
2677
2678 /** Called from the (non-realtime) butler thread when the transport is stopped */
2679 void
2680 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2681 {
2682         framepos_t now = _session.transport_frame();
2683
2684         {
2685                 Glib::RWLock::ReaderLock lm (_processor_lock);
2686
2687                 if (!did_locate) {
2688                         automation_snapshot (now, true);
2689                 }
2690
2691                 Automatable::transport_stopped (now);
2692
2693                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2694
2695                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2696                                 (*i)->flush ();
2697                         }
2698
2699                         (*i)->transport_stopped (now);
2700                 }
2701         }
2702
2703         _roll_delay = _initial_delay;
2704 }
2705
2706 /** Called with the process lock held if change contains ConfigurationChanged */
2707 void
2708 Route::input_change_handler (IOChange change, void * /*src*/)
2709 {
2710         if ((change.type & IOChange::ConfigurationChanged)) {
2711                 configure_processors (0);
2712                 _phase_invert.resize (_input->n_ports().n_audio ());
2713                 io_changed (); /* EMIT SIGNAL */
2714         }
2715 }
2716
2717 /** Called with the process lock held if change contains ConfigurationChanged */
2718 void
2719 Route::output_change_handler (IOChange change, void * /*src*/)
2720 {
2721         if ((change.type & IOChange::ConfigurationChanged)) {
2722
2723                 /* XXX resize all listeners to match _main_outs? */
2724
2725                 /* Auto-connect newly-created outputs, unless we're auto-connecting to master
2726                    and we are master (as an auto-connect in this situation would cause a
2727                    feedback loop)
2728                 */
2729                 AutoConnectOption ac = Config->get_output_auto_connect ();
2730                 if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
2731
2732                         ChanCount start = change.before;
2733
2734                         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
2735                                 if (change.before.get(*i) < change.after.get(*i)) {
2736                                         /* the existing ChanCounts don't matter for this call as they are only
2737                                            to do with matching input and output indices, and we are only changing
2738                                            outputs here.
2739                                         */
2740                                         ChanCount dummy;
2741
2742                                         /* only auto-connect the newly-created outputs, not the ones that were
2743                                            already there
2744                                         */
2745                                         start.set (*i, start.get (*i) + 1);
2746
2747                                         _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
2748                                 }
2749                         }
2750                 }
2751
2752                 // configure_processors (0);
2753         }
2754 }
2755
2756 uint32_t
2757 Route::pans_required () const
2758 {
2759         if (n_outputs().n_audio() < 2) {
2760                 return 0;
2761         }
2762
2763         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2764 }
2765
2766 int
2767 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2768                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2769 {
2770         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2771         if (!lm.locked()) {
2772                 return 0;
2773         }
2774
2775         if (n_outputs().n_total() == 0) {
2776                 return 0;
2777         }
2778
2779         if (!_active || n_inputs() == ChanCount::ZERO)  {
2780                 silence_unlocked (nframes);
2781                 return 0;
2782         }
2783         if (session_state_changing) {
2784                 if (_session.transport_speed() != 0.0f) {
2785                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2786                            so we cannot use them. Be silent till this is over.
2787
2788                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2789                         */
2790                         silence_unlocked (nframes);
2791                         return 0;
2792                 }
2793                 /* we're really not rolling, so we're either delivery silence or actually
2794                    monitoring, both of which are safe to do while session_state_changing is true.
2795                 */
2796         }
2797
2798         _amp->apply_gain_automation (false);
2799         passthru (start_frame, end_frame, nframes, 0);
2800
2801         return 0;
2802 }
2803
2804 framecnt_t
2805 Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
2806 {
2807         if (_roll_delay > nframes) {
2808
2809                 _roll_delay -= nframes;
2810                 silence_unlocked (nframes);
2811                 /* transport frame is not legal for caller to use */
2812                 return 0;
2813
2814         } else if (_roll_delay > 0) {
2815
2816                 nframes -= _roll_delay;
2817                 silence_unlocked (_roll_delay);
2818                 /* we've written _roll_delay of samples into the
2819                    output ports, so make a note of that for
2820                    future reference.
2821                 */
2822                 _main_outs->increment_output_offset (_roll_delay);
2823                 transport_frame += _roll_delay;
2824
2825                 _roll_delay = 0;
2826         }
2827
2828         return nframes;
2829 }
2830
2831 int
2832 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2833              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2834 {
2835         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2836         if (!lm.locked()) {
2837                 return 0;
2838         }
2839
2840         automation_snapshot (_session.transport_frame(), false);
2841
2842         if (n_outputs().n_total() == 0) {
2843                 return 0;
2844         }
2845
2846         if (!_active || n_inputs().n_total() == 0) {
2847                 silence_unlocked (nframes);
2848                 return 0;
2849         }
2850
2851         framecnt_t unused = 0;
2852
2853         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2854                 return 0;
2855         }
2856
2857         _silent = false;
2858
2859         passthru (start_frame, end_frame, nframes, declick);
2860
2861         return 0;
2862 }
2863
2864 int
2865 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2866                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2867 {
2868         silence (nframes);
2869         return 0;
2870 }
2871
2872 void
2873 Route::toggle_monitor_input ()
2874 {
2875         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2876                 i->ensure_monitor_input( ! i->monitoring_input());
2877         }
2878 }
2879
2880 bool
2881 Route::has_external_redirects () const
2882 {
2883         // FIXME: what about sends? - they don't return a signal back to ardour?
2884
2885         boost::shared_ptr<const PortInsert> pi;
2886
2887         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2888
2889                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2890
2891                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2892
2893                                 string port_name = port->name();
2894                                 string client_name = port_name.substr (0, port_name.find(':'));
2895
2896                                 /* only say "yes" if the redirect is actually in use */
2897
2898                                 if (client_name != "ardour" && pi->active()) {
2899                                         return true;
2900                                 }
2901                         }
2902                 }
2903         }
2904
2905         return false;
2906 }
2907
2908 void
2909 Route::flush_processors ()
2910 {
2911         /* XXX shouldn't really try to take this lock, since
2912            this is called from the RT audio thread.
2913         */
2914
2915         Glib::RWLock::ReaderLock lm (_processor_lock);
2916
2917         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2918                 (*i)->flush ();
2919         }
2920 }
2921
2922 void
2923 Route::set_meter_point (MeterPoint p, bool force)
2924 {
2925         /* CAN BE CALLED FROM PROCESS CONTEXT */
2926
2927         if (_meter_point == p && !force) {
2928                 return;
2929         }
2930
2931         _meter_point = p;
2932
2933         bool meter_was_visible_to_user = _meter->display_to_user ();
2934
2935         {
2936                 Glib::RWLock::WriterLock lm (_processor_lock);
2937
2938                 if (_meter_point != MeterCustom) {
2939
2940                         _meter->set_display_to_user (false);
2941
2942                         setup_invisible_processors ();
2943
2944                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2945
2946                         ChanCount m_in;
2947
2948                         if (loc == _processors.begin()) {
2949                                 m_in = _input->n_ports();
2950                         } else {
2951                                 ProcessorList::iterator before = loc;
2952                                 --before;
2953                                 m_in = (*before)->output_streams ();
2954                         }
2955
2956                         _meter->reflect_inputs (m_in);
2957
2958                         /* we do not need to reconfigure the processors, because the meter
2959                            (a) is always ready to handle processor_max_streams
2960                            (b) is always an N-in/N-out processor, and thus moving
2961                            it doesn't require any changes to the other processors.
2962                         */
2963
2964                 } else {
2965
2966                         // just make it visible and let the user move it
2967
2968                         _meter->set_display_to_user (true);
2969                 }
2970         }
2971
2972         meter_change (); /* EMIT SIGNAL */
2973
2974         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2975
2976         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2977 }
2978
2979 void
2980 Route::listen_position_changed ()
2981 {
2982         {
2983                 Glib::RWLock::WriterLock lm (_processor_lock);
2984                 ProcessorState pstate (this);
2985
2986                 {
2987                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2988
2989                         if (configure_processors_unlocked (0)) {
2990                                 pstate.restore ();
2991                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
2992                                 return;
2993                         }
2994                 }
2995         }
2996
2997         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2998         _session.set_dirty ();
2999 }
3000
3001 boost::shared_ptr<CapturingProcessor>
3002 Route::add_export_point()
3003 {
3004         if (!_capturing_processor) {
3005
3006                 _capturing_processor.reset (new CapturingProcessor (_session));
3007                 _capturing_processor->activate ();
3008
3009                 {
3010                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3011                         configure_processors (0);
3012                 }
3013
3014         }
3015
3016         return _capturing_processor;
3017 }
3018
3019 framecnt_t
3020 Route::update_total_latency ()
3021 {
3022         framecnt_t old = _output->effective_latency();
3023         framecnt_t own_latency = _output->user_latency();
3024
3025         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3026                 if ((*i)->active ()) {
3027                         own_latency += (*i)->signal_latency ();
3028                 }
3029         }
3030
3031         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
3032
3033         _output->set_port_latency (own_latency);
3034
3035         if (_output->user_latency() == 0) {
3036
3037                 /* this (virtual) function is used for pure Routes,
3038                    not derived classes like AudioTrack.  this means
3039                    that the data processed here comes from an input
3040                    port, not prerecorded material, and therefore we
3041                    have to take into account any input latency.
3042                 */
3043
3044                 own_latency += _input->signal_latency ();
3045         }
3046
3047         if (old != own_latency) {
3048                 _output->set_latency_delay (own_latency);
3049                 signal_latency_changed (); /* EMIT SIGNAL */
3050         }
3051
3052         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
3053
3054         return _output->effective_latency ();
3055 }
3056
3057 void
3058 Route::set_user_latency (framecnt_t nframes)
3059 {
3060         _output->set_user_latency (nframes);
3061         _session.update_latency_compensation (false, false);
3062 }
3063
3064 void
3065 Route::set_latency_delay (framecnt_t longest_session_latency)
3066 {
3067         framecnt_t old = _initial_delay;
3068
3069         if (_output->effective_latency() < longest_session_latency) {
3070                 _initial_delay = longest_session_latency - _output->effective_latency();
3071         } else {
3072                 _initial_delay = 0;
3073         }
3074
3075         if (_initial_delay != old) {
3076                 initial_delay_changed (); /* EMIT SIGNAL */
3077         }
3078
3079         if (_session.transport_stopped()) {
3080                 _roll_delay = _initial_delay;
3081         }
3082 }
3083
3084 void
3085 Route::automation_snapshot (framepos_t now, bool force)
3086 {
3087         _pannable->automation_snapshot (now, force);
3088         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3089                 (*i)->automation_snapshot (now, force);
3090         }
3091 }
3092
3093 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3094         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3095                              boost::shared_ptr<AutomationList>(), name)
3096         , _route (r)
3097 {
3098         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3099         set_list (gl);
3100 }
3101
3102 void
3103 Route::SoloControllable::set_value (double val)
3104 {
3105         bool bval = ((val >= 0.5f) ? true: false);
3106
3107         boost::shared_ptr<RouteList> rl (new RouteList);
3108
3109         boost::shared_ptr<Route> r = _route.lock ();
3110         if (!r) {
3111                 return;
3112         }
3113
3114         rl->push_back (r);
3115
3116         if (Config->get_solo_control_is_listen_control()) {
3117                 _session.set_listen (rl, bval);
3118         } else {
3119                 _session.set_solo (rl, bval);
3120         }
3121 }
3122
3123 double
3124 Route::SoloControllable::get_value () const
3125 {
3126         boost::shared_ptr<Route> r = _route.lock ();
3127         if (!r) {
3128                 return 0;
3129         }
3130
3131         if (Config->get_solo_control_is_listen_control()) {
3132                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3133         } else {
3134                 return r->self_soloed() ? 1.0f : 0.0f;
3135         }
3136 }
3137
3138 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3139         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3140                              boost::shared_ptr<AutomationList>(), name)
3141         , _route (r)
3142 {
3143         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3144         set_list (gl);
3145 }
3146
3147 void
3148 Route::MuteControllable::set_value (double val)
3149 {
3150         bool bval = ((val >= 0.5f) ? true: false);
3151
3152         boost::shared_ptr<RouteList> rl (new RouteList);
3153
3154         boost::shared_ptr<Route> r = _route.lock ();
3155         if (!r) {
3156                 return;
3157         }
3158
3159         rl->push_back (r);
3160         _session.set_mute (rl, bval);
3161 }
3162
3163 double
3164 Route::MuteControllable::get_value () const
3165 {
3166         boost::shared_ptr<Route> r = _route.lock ();
3167         if (!r) {
3168                 return 0;
3169         }
3170
3171         return r->muted() ? 1.0f : 0.0f;
3172 }
3173
3174 void
3175 Route::set_block_size (pframes_t nframes)
3176 {
3177         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3178                 (*i)->set_block_size (nframes);
3179         }
3180
3181         _session.ensure_buffers (n_process_buffers ());
3182 }
3183
3184 void
3185 Route::protect_automation ()
3186 {
3187         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3188                 (*i)->protect_automation();
3189 }
3190
3191 void
3192 Route::set_pending_declick (int declick)
3193 {
3194         if (_declickable) {
3195                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3196                 if (declick) {
3197                         _pending_declick = declick;
3198                 }
3199                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3200         } else {
3201                 _pending_declick = 0;
3202         }
3203
3204 }
3205
3206 /** Shift automation forwards from a particular place, thereby inserting time.
3207  *  Adds undo commands for any shifts that are performed.
3208  *
3209  * @param pos Position to start shifting from.
3210  * @param frames Amount to shift forwards by.
3211  */
3212
3213 void
3214 Route::shift (framepos_t pos, framecnt_t frames)
3215 {
3216         /* gain automation */
3217         {
3218                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3219
3220                 XMLNode &before = gc->alist()->get_state ();
3221                 gc->alist()->shift (pos, frames);
3222                 XMLNode &after = gc->alist()->get_state ();
3223                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3224         }
3225
3226         /* pan automation */
3227         {
3228                 ControlSet::Controls& c (_pannable->controls());
3229
3230                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3231                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3232                         if (pc) {
3233                                 boost::shared_ptr<AutomationList> al = pc->alist();
3234                                 XMLNode& before = al->get_state ();
3235                                 al->shift (pos, frames);
3236                                 XMLNode& after = al->get_state ();
3237                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3238                         }
3239                 }
3240         }
3241
3242         /* redirect automation */
3243         {
3244                 Glib::RWLock::ReaderLock lm (_processor_lock);
3245                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3246
3247                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3248
3249                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3250                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3251                                 if (ac) {
3252                                         boost::shared_ptr<AutomationList> al = ac->alist();
3253                                         XMLNode &before = al->get_state ();
3254                                         al->shift (pos, frames);
3255                                         XMLNode &after = al->get_state ();
3256                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3257                                 }
3258                         }
3259                 }
3260         }
3261 }
3262
3263
3264 int
3265 Route::save_as_template (const string& path, const string& name)
3266 {
3267         XMLNode& node (state (false));
3268         XMLTree tree;
3269
3270         IO::set_name_in_state (*node.children().front(), name);
3271
3272         tree.set_root (&node);
3273         return tree.write (path.c_str());
3274 }
3275
3276
3277 bool
3278 Route::set_name (const string& str)
3279 {
3280         bool ret;
3281         string ioproc_name;
3282         string name;
3283
3284         name = Route::ensure_track_or_route_name (str, _session);
3285         SessionObject::set_name (name);
3286
3287         ret = (_input->set_name(name) && _output->set_name(name));
3288
3289         if (ret) {
3290
3291                 Glib::RWLock::ReaderLock lm (_processor_lock);
3292
3293                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3294
3295                         /* rename all I/O processors that have inputs or outputs */
3296
3297                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3298
3299                         if (iop && (iop->output() || iop->input())) {
3300                                 if (!iop->set_name (name)) {
3301                                         ret = false;
3302                                 }
3303                         }
3304                 }
3305
3306         }
3307
3308         return ret;
3309 }
3310
3311 boost::shared_ptr<Send>
3312 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3313 {
3314         Glib::RWLock::ReaderLock lm (_processor_lock);
3315
3316         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3317                 boost::shared_ptr<InternalSend> send;
3318
3319                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3320                         if (send->target_route() == target) {
3321                                 return send;
3322                         }
3323                 }
3324         }
3325
3326         return boost::shared_ptr<Send>();
3327 }
3328
3329 /** @param c Audio channel index.
3330  *  @param yn true to invert phase, otherwise false.
3331  */
3332 void
3333 Route::set_phase_invert (uint32_t c, bool yn)
3334 {
3335         if (_phase_invert[c] != yn) {
3336                 _phase_invert[c] = yn;
3337                 phase_invert_changed (); /* EMIT SIGNAL */
3338                 _session.set_dirty ();
3339         }
3340 }
3341
3342 void
3343 Route::set_phase_invert (boost::dynamic_bitset<> p)
3344 {
3345         if (_phase_invert != p) {
3346                 _phase_invert = p;
3347                 phase_invert_changed (); /* EMIT SIGNAL */
3348                 _session.set_dirty ();
3349         }
3350 }
3351
3352 bool
3353 Route::phase_invert (uint32_t c) const
3354 {
3355         return _phase_invert[c];
3356 }
3357
3358 boost::dynamic_bitset<>
3359 Route::phase_invert () const
3360 {
3361         return _phase_invert;
3362 }
3363
3364 void
3365 Route::set_denormal_protection (bool yn)
3366 {
3367         if (_denormal_protection != yn) {
3368                 _denormal_protection = yn;
3369                 denormal_protection_changed (); /* EMIT SIGNAL */
3370         }
3371 }
3372
3373 bool
3374 Route::denormal_protection () const
3375 {
3376         return _denormal_protection;
3377 }
3378
3379 void
3380 Route::set_active (bool yn, void* src)
3381 {
3382         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3383                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3384                 return;
3385         }
3386
3387         if (_active != yn) {
3388                 _active = yn;
3389                 _input->set_active (yn);
3390                 _output->set_active (yn);
3391                 active_changed (); // EMIT SIGNAL
3392         }
3393 }
3394
3395 void
3396 Route::meter ()
3397 {
3398         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3399
3400         assert (_meter);
3401
3402         _meter->meter ();
3403
3404         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3405
3406                 boost::shared_ptr<Send> s;
3407                 boost::shared_ptr<Return> r;
3408
3409                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3410                         s->meter()->meter();
3411                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3412                         r->meter()->meter ();
3413                 }
3414         }
3415 }
3416
3417 boost::shared_ptr<Pannable>
3418 Route::pannable() const
3419 {
3420         return _pannable;
3421 }
3422
3423 boost::shared_ptr<Panner>
3424 Route::panner() const
3425 {
3426         /* may be null ! */
3427         return _main_outs->panner_shell()->panner();
3428 }
3429
3430 boost::shared_ptr<PannerShell>
3431 Route::panner_shell() const
3432 {
3433         return _main_outs->panner_shell();
3434 }
3435
3436 boost::shared_ptr<AutomationControl>
3437 Route::gain_control() const
3438 {
3439         return _amp->gain_control();
3440 }
3441
3442 boost::shared_ptr<AutomationControl>
3443 Route::get_control (const Evoral::Parameter& param)
3444 {
3445         /* either we own the control or .... */
3446
3447         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3448
3449         if (!c) {
3450
3451                 /* maybe one of our processors does or ... */
3452
3453                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3454                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3455                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3456                                 break;
3457                         }
3458                 }
3459         }
3460
3461         if (!c) {
3462
3463                 /* nobody does so we'll make a new one */
3464
3465                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3466                 add_control(c);
3467         }
3468
3469         return c;
3470 }
3471
3472 boost::shared_ptr<Processor>
3473 Route::nth_plugin (uint32_t n)
3474 {
3475         Glib::RWLock::ReaderLock lm (_processor_lock);
3476         ProcessorList::iterator i;
3477
3478         for (i = _processors.begin(); i != _processors.end(); ++i) {
3479                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3480                         if (n-- == 0) {
3481                                 return *i;
3482                         }
3483                 }
3484         }
3485
3486         return boost::shared_ptr<Processor> ();
3487 }
3488
3489 boost::shared_ptr<Processor>
3490 Route::nth_send (uint32_t n)
3491 {
3492         Glib::RWLock::ReaderLock lm (_processor_lock);
3493         ProcessorList::iterator i;
3494
3495         for (i = _processors.begin(); i != _processors.end(); ++i) {
3496                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3497                         if (n-- == 0) {
3498                                 return *i;
3499                         }
3500                 }
3501         }
3502
3503         return boost::shared_ptr<Processor> ();
3504 }
3505
3506 bool
3507 Route::has_io_processor_named (const string& name)
3508 {
3509         Glib::RWLock::ReaderLock lm (_processor_lock);
3510         ProcessorList::iterator i;
3511
3512         for (i = _processors.begin(); i != _processors.end(); ++i) {
3513                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3514                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3515                         if ((*i)->name() == name) {
3516                                 return true;
3517                         }
3518                 }
3519         }
3520
3521         return false;
3522 }
3523
3524 MuteMaster::MutePoint
3525 Route::mute_points () const
3526 {
3527         return _mute_master->mute_points ();
3528 }
3529
3530 void
3531 Route::set_processor_positions ()
3532 {
3533         Glib::RWLock::ReaderLock lm (_processor_lock);
3534
3535         bool had_amp = false;
3536         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3537                 (*i)->set_pre_fader (!had_amp);
3538                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3539                         had_amp = true;
3540                 }
3541         }
3542 }
3543
3544 /** Called when there is a proposed change to the input port count */
3545 bool
3546 Route::input_port_count_changing (ChanCount to)
3547 {
3548         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3549         if (c.empty()) {
3550                 /* The processors cannot be configured with the new input arrangement, so
3551                    block the change.
3552                 */
3553                 return true;
3554         }
3555
3556         /* The change is ok */
3557         return false;
3558 }
3559
3560 list<string>
3561 Route::unknown_processors () const
3562 {
3563         list<string> p;
3564
3565         Glib::RWLock::ReaderLock lm (_processor_lock);
3566         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3567                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3568                         p.push_back ((*i)->name ());
3569                 }
3570         }
3571
3572         return p;
3573 }
3574
3575 void
3576 Route::set_latency_ranges (bool playback) const
3577 {
3578         framecnt_t own_latency = 0;
3579
3580         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD OR
3581            LATENCY CALLBACK
3582         */
3583
3584         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3585                 if ((*i)->active ()) {
3586                         own_latency += (*i)->signal_latency ();
3587                 }
3588         }
3589
3590         if (playback) {
3591                 update_port_latencies (_input->ports (), _output->ports (), true, own_latency);
3592         } else {
3593                 update_port_latencies (_output->ports (), _input->ports (), false, own_latency);
3594         }
3595 }
3596
3597 void
3598 Route::update_port_latencies (const PortSet& operands, const PortSet& feeders, bool playback, framecnt_t our_latency) const
3599 {
3600 #ifdef HAVE_JACK_NEW_LATENCY
3601
3602         /* we assume that all our input ports feed all our output ports. its not
3603            universally true, but the alternative is way too corner-case to worry about.
3604         */
3605
3606         jack_latency_range_t all_connections;
3607
3608         all_connections.min = ~((jack_nframes_t) 0);
3609         all_connections.max = 0;
3610
3611         /* iterate over all feeder ports and determine their relevant latency, taking
3612            the maximum and minimum across all of them.
3613         */
3614
3615         for (PortSet::const_iterator p = feeders.begin(); p != feeders.end(); ++p) {
3616
3617                 jack_latency_range_t range;
3618
3619                 p->get_connected_latency_range (range, playback);
3620
3621                 all_connections.min = min (all_connections.min, range.min);
3622                 all_connections.max = max (all_connections.max, range.max);
3623         }
3624
3625         all_connections.min += our_latency;
3626         all_connections.max += our_latency;
3627
3628         for (PortSet::const_iterator p = operands.begin(); p != operands.end(); ++p) {
3629
3630                 p->set_latency_range (all_connections, playback);
3631
3632                 DEBUG_TRACE (DEBUG::Latency, string_compose ("Port %1 %5 latency range %2 .. %3 (including route latency of %4)\n",
3633                                                              p->name(),
3634                                                              all_connections.min,
3635                                                              all_connections.max,
3636                                                              our_latency,
3637                                                              (playback ? "PLAYBACK" : "CAPTURE")));
3638         }
3639 #endif
3640 }
3641
3642
3643 /** Put the invisible processors in the right place in _processors.
3644  *  Must be called with a writer lock on _processor_lock held.
3645  */
3646 void
3647 Route::setup_invisible_processors ()
3648 {
3649 #ifndef NDEBUG
3650         Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3651         assert (!lm.locked ());
3652 #endif
3653
3654         if (!_main_outs) {
3655                 /* too early to be doing this stuff */
3656                 return;
3657         }
3658
3659         /* we'll build this new list here and then use it */
3660
3661         ProcessorList new_processors;
3662
3663         /* find visible processors */
3664
3665         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3666                 if ((*i)->display_to_user ()) {
3667                         new_processors.push_back (*i);
3668                 }
3669         }
3670
3671         /* find the amp */
3672
3673         ProcessorList::iterator amp = new_processors.begin ();
3674         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3675                 ++amp;
3676         }
3677
3678         assert (amp != _processors.end ());
3679
3680         /* and the processor after the amp */
3681
3682         ProcessorList::iterator after_amp = amp;
3683         ++after_amp;
3684
3685         /* METER */
3686
3687         if (_meter) {
3688                 switch (_meter_point) {
3689                 case MeterInput:
3690                         assert (!_meter->display_to_user ());
3691                         new_processors.push_front (_meter);
3692                         break;
3693                 case MeterPreFader:
3694                         assert (!_meter->display_to_user ());
3695                         new_processors.insert (amp, _meter);
3696                         break;
3697                 case MeterPostFader:
3698                         /* do nothing here */
3699                         break;
3700                 case MeterOutput:
3701                         /* do nothing here */
3702                         break;
3703                 case MeterCustom:
3704                         /* the meter is visible, so we don't touch it here */
3705                         break;
3706                 }
3707         }
3708
3709         /* MAIN OUTS */
3710
3711         assert (_main_outs);
3712         assert (!_main_outs->display_to_user ());
3713         new_processors.push_back (_main_outs);
3714
3715         /* iterator for the main outs */
3716
3717         ProcessorList::iterator main = new_processors.end();
3718         --main;
3719
3720         /* OUTPUT METERING */
3721
3722         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3723                 assert (!_meter->display_to_user ());
3724
3725                 /* add the processor just before or just after the main outs */
3726
3727                 ProcessorList::iterator meter_point = main;
3728
3729                 if (_meter_point == MeterOutput) {
3730                         ++meter_point;
3731                 }
3732                 new_processors.insert (meter_point, _meter);
3733         }
3734
3735         /* MONITOR SEND */
3736
3737         if (_monitor_send && !is_monitor ()) {
3738                 assert (!_monitor_send->display_to_user ());
3739                 if (Config->get_solo_control_is_listen_control()) {
3740                         switch (Config->get_listen_position ()) {
3741                         case PreFaderListen:
3742                                 switch (Config->get_pfl_position ()) {
3743                                 case PFLFromBeforeProcessors:
3744                                         new_processors.push_front (_monitor_send);
3745                                         break;
3746                                 case PFLFromAfterProcessors:
3747                                         new_processors.insert (amp, _monitor_send);
3748                                         break;
3749                                 }
3750                                 break;
3751                         case AfterFaderListen:
3752                                 switch (Config->get_afl_position ()) {
3753                                 case AFLFromBeforeProcessors:
3754                                         new_processors.insert (after_amp, _monitor_send);
3755                                         break;
3756                                 case AFLFromAfterProcessors:
3757                                         new_processors.insert (new_processors.end(), _monitor_send);
3758                                         break;
3759                                 }
3760                                 break;
3761                         }
3762                 }  else {
3763                         new_processors.insert (new_processors.end(), _monitor_send);
3764                 }
3765         }
3766
3767         /* MONITOR CONTROL */
3768
3769         if (_monitor_control && is_monitor ()) {
3770                 assert (!_monitor_control->display_to_user ());
3771                 new_processors.push_front (_monitor_control);
3772         }
3773
3774         /* INTERNAL RETURN */
3775
3776         /* doing this here means that any monitor control will come just after
3777            the return.
3778         */
3779
3780         if (_intreturn) {
3781                 assert (!_intreturn->display_to_user ());
3782                 new_processors.push_front (_intreturn);
3783         }
3784
3785         /* EXPORT PROCESSOR */
3786
3787         if (_capturing_processor) {
3788                 assert (!_capturing_processor->display_to_user ());
3789                 new_processors.push_front (_capturing_processor);
3790         }
3791
3792         _processors = new_processors;
3793
3794         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3795         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3796                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3797         }
3798 }
3799
3800 bool
3801 Route::should_monitor () const
3802 {
3803         switch (Config->get_monitoring_model()) {
3804         case HardwareMonitoring:
3805         case ExternalMonitoring:
3806                 return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
3807                 break;
3808         default:
3809                 break;
3810         }
3811
3812         return true;
3813 }
3814