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