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