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         _session.ensure_buffers (n_process_buffers ());
1588
1589         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1590
1591         _in_configure_processors = false;
1592         return 0;
1593 }
1594
1595 void
1596 Route::all_processors_flip ()
1597 {
1598         Glib::RWLock::ReaderLock lm (_processor_lock);
1599
1600         if (_processors.empty()) {
1601                 return;
1602         }
1603
1604         bool first_is_on = _processors.front()->active();
1605
1606         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1607                 if (first_is_on) {
1608                         (*i)->deactivate ();
1609                 } else {
1610                         (*i)->activate ();
1611                 }
1612         }
1613
1614         _session.set_dirty ();
1615 }
1616
1617 /** Set all processors with a given placement to a given active state.
1618  * @param p Placement of processors to change.
1619  * @param state New active state for those processors.
1620  */
1621 void
1622 Route::all_processors_active (Placement p, bool state)
1623 {
1624         Glib::RWLock::ReaderLock lm (_processor_lock);
1625
1626         if (_processors.empty()) {
1627                 return;
1628         }
1629         ProcessorList::iterator start, end;
1630         placement_range(p, start, end);
1631
1632         bool before_amp = true;
1633         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1634                 if ((*i) == _amp) {
1635                         before_amp = false;
1636                         continue;
1637                 }
1638                 if (p == PreFader && before_amp) {
1639                         if (state) {
1640                                 (*i)->activate ();
1641                         } else {
1642                                 (*i)->deactivate ();
1643                         }
1644                 }
1645         }
1646
1647         _session.set_dirty ();
1648 }
1649
1650 bool
1651 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1652 {
1653         bool pre_fader = true;
1654         Glib::RWLock::ReaderLock lm (_processor_lock);
1655
1656         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1657
1658                 /* semantic note: if p == amp, we want to return true, so test
1659                    for equality before checking if this is the amp
1660                 */
1661
1662                 if ((*i) == p) {
1663                         break;
1664                 }
1665
1666                 if ((*i) == _amp) {
1667                         pre_fader = false;
1668                         break;
1669                 }
1670         }
1671
1672         return pre_fader;
1673 }
1674
1675 int
1676 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1677 {
1678         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1679            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1680            processors in the current actual processor list that are hidden. Any visible processors
1681            in the current list but not in "new_order" will be assumed to be deleted.
1682         */
1683
1684         {
1685                 Glib::RWLock::WriterLock lm (_processor_lock);
1686                 ProcessorState pstate (this);
1687
1688                 ProcessorList::iterator oiter;
1689                 ProcessorList::const_iterator niter;
1690                 ProcessorList as_it_will_be;
1691
1692                 oiter = _processors.begin();
1693                 niter = new_order.begin();
1694
1695                 while (niter !=  new_order.end()) {
1696
1697                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1698                            then append it to the temp list.
1699
1700                            Otherwise, see if the next processor in the old list is in the new list. if not,
1701                            its been deleted. If its there, append it to the temp list.
1702                         */
1703
1704                         if (oiter == _processors.end()) {
1705
1706                                 /* no more elements in the old list, so just stick the rest of
1707                                    the new order onto the temp list.
1708                                 */
1709
1710                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1711                                 while (niter != new_order.end()) {
1712                                         ++niter;
1713                                 }
1714                                 break;
1715
1716                         } else {
1717
1718                                 if (!(*oiter)->display_to_user()) {
1719
1720                                         as_it_will_be.push_back (*oiter);
1721
1722                                 } else {
1723
1724                                         /* visible processor: check that its in the new order */
1725
1726                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1727                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1728                                         } else {
1729                                                 /* ignore this one, and add the next item from the new order instead */
1730                                                 as_it_will_be.push_back (*niter);
1731                                                 ++niter;
1732                                         }
1733                                 }
1734
1735                                 /* now remove from old order - its taken care of no matter what */
1736                                 oiter = _processors.erase (oiter);
1737                         }
1738
1739                 }
1740
1741                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1742
1743                 {
1744                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1745
1746                         if (configure_processors_unlocked (err)) {
1747                                 pstate.restore ();
1748                                 return -1;
1749                         }
1750                 }
1751         }
1752
1753         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1754         set_processor_positions ();
1755
1756         return 0;
1757 }
1758
1759 XMLNode&
1760 Route::get_state()
1761 {
1762         return state(true);
1763 }
1764
1765 XMLNode&
1766 Route::get_template()
1767 {
1768         return state(false);
1769 }
1770
1771 XMLNode&
1772 Route::state(bool full_state)
1773 {
1774         XMLNode *node = new XMLNode("Route");
1775         ProcessorList::iterator i;
1776         char buf[32];
1777
1778         id().print (buf, sizeof (buf));
1779         node->add_property("id", buf);
1780         node->add_property ("name", _name);
1781         node->add_property("default-type", _default_type.to_string());
1782
1783         if (_flags) {
1784                 node->add_property("flags", enum_2_string (_flags));
1785         }
1786
1787         node->add_property("active", _active?"yes":"no");
1788         string p;
1789         boost::to_string (_phase_invert, p);
1790         node->add_property("phase-invert", p);
1791         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1792         node->add_property("meter-point", enum_2_string (_meter_point));
1793
1794         if (_route_group) {
1795                 node->add_property("route-group", _route_group->name());
1796         }
1797
1798         string order_string;
1799         OrderKeys::iterator x = order_keys.begin();
1800
1801         while (x != order_keys.end()) {
1802                 order_string += string ((*x).first);
1803                 order_string += '=';
1804                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1805                 order_string += buf;
1806
1807                 ++x;
1808
1809                 if (x == order_keys.end()) {
1810                         break;
1811                 }
1812
1813                 order_string += ':';
1814         }
1815         node->add_property ("order-keys", order_string);
1816         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1817         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1818         node->add_property ("soloed-by-upstream", buf);
1819         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1820         node->add_property ("soloed-by-downstream", buf);
1821         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1822         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1823
1824         node->add_child_nocopy (_input->state (full_state));
1825         node->add_child_nocopy (_output->state (full_state));
1826         node->add_child_nocopy (_solo_control->get_state ());
1827         node->add_child_nocopy (_mute_control->get_state ());
1828         node->add_child_nocopy (_mute_master->get_state ());
1829
1830         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1831         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1832         remote_control_node->add_property (X_("id"), buf);
1833         node->add_child_nocopy (*remote_control_node);
1834
1835         if (_comment.length()) {
1836                 XMLNode *cmt = node->add_child ("Comment");
1837                 cmt->add_content (_comment);
1838         }
1839
1840         if (_pannable) {
1841                 node->add_child_nocopy (_pannable->state (full_state));
1842         }
1843
1844         for (i = _processors.begin(); i != _processors.end(); ++i) {
1845                 node->add_child_nocopy((*i)->state (full_state));
1846         }
1847
1848         if (_extra_xml){
1849                 node->add_child_copy (*_extra_xml);
1850         }
1851
1852         return *node;
1853 }
1854
1855 int
1856 Route::set_state (const XMLNode& node, int version)
1857 {
1858         return _set_state (node, version, true);
1859 }
1860
1861 int
1862 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1863 {
1864         if (version < 3000) {
1865                 return _set_state_2X (node, version);
1866         }
1867
1868         XMLNodeList nlist;
1869         XMLNodeConstIterator niter;
1870         XMLNode *child;
1871         const XMLProperty *prop;
1872
1873         if (node.name() != "Route"){
1874                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1875                 return -1;
1876         }
1877
1878         if ((prop = node.property (X_("name"))) != 0) {
1879                 Route::set_name (prop->value());
1880         }
1881
1882         if ((prop = node.property ("id")) != 0) {
1883                 _id = prop->value ();
1884         }
1885
1886         if ((prop = node.property (X_("flags"))) != 0) {
1887                 _flags = Flag (string_2_enum (prop->value(), _flags));
1888         } else {
1889                 _flags = Flag (0);
1890         }
1891
1892         if (is_master() || is_monitor() || is_hidden()) {
1893                 _mute_master->set_solo_ignore (true);
1894         }
1895
1896         if (is_monitor()) {
1897                 /* monitor bus does not get a panner, but if (re)created
1898                    via XML, it will already have one by the time we
1899                    call ::set_state(). so ... remove it.
1900                 */
1901                 unpan ();
1902         }
1903
1904         /* add all processors (except amp, which is always present) */
1905
1906         nlist = node.children();
1907         XMLNode processor_state (X_("processor_state"));
1908
1909         Stateful::save_extra_xml (node);
1910
1911         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1912
1913                 child = *niter;
1914
1915                 if (child->name() == IO::state_node_name) {
1916                         if ((prop = child->property (X_("direction"))) == 0) {
1917                                 continue;
1918                         }
1919
1920                         if (prop->value() == "Input") {
1921                                 _input->set_state (*child, version);
1922                         } else if (prop->value() == "Output") {
1923                                 _output->set_state (*child, version);
1924                         }
1925                 }
1926
1927                 if (child->name() == X_("Processor")) {
1928                         processor_state.add_child_copy (*child);
1929                 }
1930
1931
1932                 if (child->name() == X_("Pannable")) {
1933                         if (_pannable) {
1934                                 _pannable->set_state (*child, version);
1935                         } else {
1936                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
1937                         }
1938                 }
1939         }
1940
1941         set_processor_state (processor_state);
1942
1943         if ((prop = node.property ("self-solo")) != 0) {
1944                 set_self_solo (string_is_affirmative (prop->value()));
1945         }
1946
1947         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1948                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1949                 mod_solo_by_others_upstream (atoi (prop->value()));
1950         }
1951
1952         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1953                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1954                 mod_solo_by_others_downstream (atoi (prop->value()));
1955         }
1956
1957         if ((prop = node.property ("solo-isolated")) != 0) {
1958                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1959         }
1960
1961         if ((prop = node.property ("solo-safe")) != 0) {
1962                 set_solo_safe (string_is_affirmative (prop->value()), this);
1963         }
1964
1965         if ((prop = node.property (X_("phase-invert"))) != 0) {
1966                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1967         }
1968
1969         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1970                 set_denormal_protection (string_is_affirmative (prop->value()));
1971         }
1972
1973         if ((prop = node.property (X_("active"))) != 0) {
1974                 bool yn = string_is_affirmative (prop->value());
1975                 _active = !yn; // force switch
1976                 set_active (yn, this);
1977         }
1978
1979         if ((prop = node.property (X_("meter-point"))) != 0) {
1980                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1981                 set_meter_point (mp, true);
1982                 if (_meter) {
1983                         _meter->set_display_to_user (_meter_point == MeterCustom);
1984                 }
1985         }
1986
1987         if ((prop = node.property (X_("order-keys"))) != 0) {
1988
1989                 int32_t n;
1990
1991                 string::size_type colon, equal;
1992                 string remaining = prop->value();
1993
1994                 while (remaining.length()) {
1995
1996                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1997                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1998                                       << endmsg;
1999                         } else {
2000                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2001                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2002                                               << endmsg;
2003                                 } else {
2004                                         set_order_key (remaining.substr (0, equal), n);
2005                                 }
2006                         }
2007
2008                         colon = remaining.find_first_of (':');
2009
2010                         if (colon != string::npos) {
2011                                 remaining = remaining.substr (colon+1);
2012                         } else {
2013                                 break;
2014                         }
2015                 }
2016         }
2017
2018         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2019                 child = *niter;
2020
2021                 if (child->name() == X_("Comment")) {
2022
2023                         /* XXX this is a terrible API design in libxml++ */
2024
2025                         XMLNode *cmt = *(child->children().begin());
2026                         _comment = cmt->content();
2027
2028                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2029                         if (prop->value() == "solo") {
2030                                 _solo_control->set_state (*child, version);
2031                         }
2032
2033                 } else if (child->name() == X_("RemoteControl")) {
2034                         if ((prop = child->property (X_("id"))) != 0) {
2035                                 int32_t x;
2036                                 sscanf (prop->value().c_str(), "%d", &x);
2037                                 set_remote_control_id (x);
2038                         }
2039
2040                 } else if (child->name() == X_("MuteMaster")) {
2041                         _mute_master->set_state (*child, version);
2042                 }
2043         }
2044
2045         return 0;
2046 }
2047
2048 int
2049 Route::_set_state_2X (const XMLNode& node, int version)
2050 {
2051         XMLNodeList nlist;
2052         XMLNodeConstIterator niter;
2053         XMLNode *child;
2054         const XMLProperty *prop;
2055
2056         /* 2X things which still remain to be handled:
2057          * default-type
2058          * automation
2059          * controlouts
2060          */
2061
2062         if (node.name() != "Route") {
2063                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2064                 return -1;
2065         }
2066
2067         if ((prop = node.property (X_("flags"))) != 0) {
2068                 _flags = Flag (string_2_enum (prop->value(), _flags));
2069         } else {
2070                 _flags = Flag (0);
2071         }
2072
2073         if ((prop = node.property (X_("phase-invert"))) != 0) {
2074                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2075                 if (string_is_affirmative (prop->value ())) {
2076                         p.set ();
2077                 }
2078                 set_phase_invert (p);
2079         }
2080
2081         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2082                 set_denormal_protection (string_is_affirmative (prop->value()));
2083         }
2084
2085         if ((prop = node.property (X_("soloed"))) != 0) {
2086                 bool yn = string_is_affirmative (prop->value());
2087
2088                 /* XXX force reset of solo status */
2089
2090                 set_solo (yn, this);
2091         }
2092
2093         if ((prop = node.property (X_("muted"))) != 0) {
2094
2095                 bool first = true;
2096                 bool muted = string_is_affirmative (prop->value());
2097
2098                 if (muted) {
2099
2100                         string mute_point;
2101
2102                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2103
2104                                 if (string_is_affirmative (prop->value())){
2105                                         mute_point = mute_point + "PreFader";
2106                                         first = false;
2107                                 }
2108                         }
2109
2110                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2111
2112                                 if (string_is_affirmative (prop->value())){
2113
2114                                         if (!first) {
2115                                                 mute_point = mute_point + ",";
2116                                         }
2117
2118                                         mute_point = mute_point + "PostFader";
2119                                         first = false;
2120                                 }
2121                         }
2122
2123                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2124
2125                                 if (string_is_affirmative (prop->value())){
2126
2127                                         if (!first) {
2128                                                 mute_point = mute_point + ",";
2129                                         }
2130
2131                                         mute_point = mute_point + "Listen";
2132                                         first = false;
2133                                 }
2134                         }
2135
2136                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2137
2138                                 if (string_is_affirmative (prop->value())){
2139
2140                                         if (!first) {
2141                                                 mute_point = mute_point + ",";
2142                                         }
2143
2144                                         mute_point = mute_point + "Main";
2145                                 }
2146                         }
2147
2148                         _mute_master->set_mute_points (mute_point);
2149                         _mute_master->set_muted_by_self (true);
2150                 }
2151         }
2152
2153         if ((prop = node.property (X_("meter-point"))) != 0) {
2154                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2155         }
2156
2157         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2158            don't mean the same thing.
2159         */
2160
2161         if ((prop = node.property (X_("order-keys"))) != 0) {
2162
2163                 int32_t n;
2164
2165                 string::size_type colon, equal;
2166                 string remaining = prop->value();
2167
2168                 while (remaining.length()) {
2169
2170                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2171                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2172                                         << endmsg;
2173                         } else {
2174                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2175                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2176                                                 << endmsg;
2177                                 } else {
2178                                         set_order_key (remaining.substr (0, equal), n);
2179                                 }
2180                         }
2181
2182                         colon = remaining.find_first_of (':');
2183
2184                         if (colon != string::npos) {
2185                                 remaining = remaining.substr (colon+1);
2186                         } else {
2187                                 break;
2188                         }
2189                 }
2190         }
2191
2192         /* IOs */
2193
2194         nlist = node.children ();
2195         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2196
2197                 child = *niter;
2198
2199                 if (child->name() == IO::state_node_name) {
2200
2201                         /* there is a note in IO::set_state_2X() about why we have to call
2202                            this directly.
2203                            */
2204
2205                         _input->set_state_2X (*child, version, true);
2206                         _output->set_state_2X (*child, version, false);
2207
2208                         if ((prop = child->property (X_("name"))) != 0) {
2209                                 Route::set_name (prop->value ());
2210                         }
2211
2212                         if ((prop = child->property (X_("id"))) != 0) {
2213                                 _id = prop->value ();
2214                         }
2215
2216                         if ((prop = child->property (X_("active"))) != 0) {
2217                                 bool yn = string_is_affirmative (prop->value());
2218                                 _active = !yn; // force switch
2219                                 set_active (yn, this);
2220                         }
2221
2222                         if ((prop = child->property (X_("gain"))) != 0) {
2223                                 gain_t val;
2224
2225                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2226                                         _amp->gain_control()->set_value (val);
2227                                 }
2228                         }
2229
2230                         /* Set up Panners in the IO */
2231                         XMLNodeList io_nlist = child->children ();
2232
2233                         XMLNodeConstIterator io_niter;
2234                         XMLNode *io_child;
2235
2236                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2237
2238                                 io_child = *io_niter;
2239
2240                                 if (io_child->name() == X_("Panner")) {
2241                                         _main_outs->panner_shell()->set_state(*io_child, version);
2242                                 } else if (io_child->name() == X_("Automation")) {
2243                                         /* IO's automation is for the fader */
2244                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2245                                 }
2246                         }
2247                 }
2248         }
2249
2250         XMLNodeList redirect_nodes;
2251
2252         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2253
2254                 child = *niter;
2255
2256                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2257                         redirect_nodes.push_back(child);
2258                 }
2259
2260         }
2261
2262         set_processor_state_2X (redirect_nodes, version);
2263
2264         Stateful::save_extra_xml (node);
2265
2266         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2267                 child = *niter;
2268
2269                 if (child->name() == X_("Comment")) {
2270
2271                         /* XXX this is a terrible API design in libxml++ */
2272
2273                         XMLNode *cmt = *(child->children().begin());
2274                         _comment = cmt->content();
2275
2276                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2277                         if (prop->value() == X_("solo")) {
2278                                 _solo_control->set_state (*child, version);
2279                         } else if (prop->value() == X_("mute")) {
2280                                 _mute_control->set_state (*child, version);
2281                         }
2282
2283                 } else if (child->name() == X_("RemoteControl")) {
2284                         if ((prop = child->property (X_("id"))) != 0) {
2285                                 int32_t x;
2286                                 sscanf (prop->value().c_str(), "%d", &x);
2287                                 set_remote_control_id (x);
2288                         }
2289
2290                 }
2291         }
2292
2293         return 0;
2294 }
2295
2296 XMLNode&
2297 Route::get_processor_state ()
2298 {
2299         XMLNode* root = new XMLNode (X_("redirects"));
2300         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2301                 root->add_child_nocopy ((*i)->state (true));
2302         }
2303
2304         return *root;
2305 }
2306
2307 void
2308 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2309 {
2310         /* We don't bother removing existing processors not in nList, as this
2311            method will only be called when creating a Route from scratch, not
2312            for undo purposes.  Just put processors in at the appropriate place
2313            in the list.
2314         */
2315
2316         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2317                 add_processor_from_xml_2X (**i, version);
2318         }
2319 }
2320
2321 void
2322 Route::set_processor_state (const XMLNode& node)
2323 {
2324         const XMLNodeList &nlist = node.children();
2325         XMLNodeConstIterator niter;
2326         ProcessorList new_order;
2327         bool must_configure = false;
2328
2329         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2330
2331                 XMLProperty* prop = (*niter)->property ("type");
2332
2333                 if (prop->value() == "amp") {
2334                         _amp->set_state (**niter, Stateful::current_state_version);
2335                         new_order.push_back (_amp);
2336                 } else if (prop->value() == "meter") {
2337                         _meter->set_state (**niter, Stateful::current_state_version);
2338                 } else if (prop->value() == "main-outs") {
2339                         _main_outs->set_state (**niter, Stateful::current_state_version);
2340                 } else if (prop->value() == "intreturn") {
2341                         if (!_intreturn) {
2342                                 _intreturn.reset (new InternalReturn (_session));
2343                                 must_configure = true;
2344                         }
2345                         _intreturn->set_state (**niter, Stateful::current_state_version);
2346                 } else if (is_monitor() && prop->value() == "monitor") {
2347                         if (!_monitor_control) {
2348                                 _monitor_control.reset (new MonitorProcessor (_session));
2349                                 must_configure = true;
2350                         }
2351                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2352                 } else if (prop->value() == "capture") {
2353                         _capturing_processor.reset (new CapturingProcessor (_session));
2354                 } else {
2355                         ProcessorList::iterator o;
2356
2357                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2358                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2359                                 if (id_prop && (*o)->id() == id_prop->value()) {
2360                                         (*o)->set_state (**niter, Stateful::current_state_version);
2361                                         new_order.push_back (*o);
2362                                         break;
2363                                 }
2364                         }
2365
2366                         // If the processor (*niter) is not on the route then create it
2367
2368                         if (o == _processors.end()) {
2369
2370                                 boost::shared_ptr<Processor> processor;
2371
2372                                 if (prop->value() == "intsend") {
2373
2374                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2375
2376                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2377                                            prop->value() == "lv2" ||
2378                                            prop->value() == "vst" ||
2379                                            prop->value() == "audiounit") {
2380
2381                                         processor.reset (new PluginInsert(_session));
2382
2383                                 } else if (prop->value() == "port") {
2384
2385                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2386
2387                                 } else if (prop->value() == "send") {
2388
2389                                         processor.reset (new Send (_session, _pannable, _mute_master));
2390
2391                                 } else {
2392                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2393                                         continue;
2394                                 }
2395
2396                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2397                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2398                                         processor.reset (new UnknownProcessor (_session, **niter));
2399                                 }
2400
2401                                 /* we have to note the monitor send here, otherwise a new one will be created
2402                                    and the state of this one will be lost.
2403                                 */
2404                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2405                                 if (isend && isend->role() == Delivery::Listen) {
2406                                         _monitor_send = isend;
2407                                 }
2408
2409                                 /* it doesn't matter if invisible processors are added here, as they
2410                                    will be sorted out by setup_invisible_processors () shortly.
2411                                 */
2412
2413                                 new_order.push_back (processor);
2414                                 must_configure = true;
2415                         }
2416                 }
2417         }
2418
2419         {
2420                 Glib::RWLock::WriterLock lm (_processor_lock);
2421                 _processors = new_order;
2422
2423                 if (must_configure) {
2424                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2425                         configure_processors_unlocked (0);
2426                 }
2427
2428                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2429
2430                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2431
2432                         boost::shared_ptr<PluginInsert> pi;
2433
2434                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2435                                 if (pi->has_no_inputs ()) {
2436                                         _have_internal_generator = true;
2437                                         break;
2438                                 }
2439                         }
2440                 }
2441         }
2442
2443         processors_changed (RouteProcessorChange ());
2444         set_processor_positions ();
2445 }
2446
2447 void
2448 Route::curve_reallocate ()
2449 {
2450 //      _gain_automation_curve.finish_resize ();
2451 //      _pan_automation_curve.finish_resize ();
2452 }
2453
2454 void
2455 Route::silence (framecnt_t nframes)
2456 {
2457         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2458         if (!lm.locked()) {
2459                 return;
2460         }
2461
2462         silence_unlocked (nframes);
2463 }
2464
2465 void
2466 Route::silence_unlocked (framecnt_t nframes)
2467 {
2468         /* Must be called with the processor lock held */
2469
2470         if (!_silent) {
2471
2472                 _output->silence (nframes);
2473
2474                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2475                         boost::shared_ptr<PluginInsert> pi;
2476
2477                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2478                                 // skip plugins, they don't need anything when we're not active
2479                                 continue;
2480                         }
2481
2482                         (*i)->silence (nframes);
2483                 }
2484
2485                 if (nframes == _session.get_block_size()) {
2486                         // _silent = true;
2487                 }
2488         }
2489 }
2490
2491 void
2492 Route::add_internal_return ()
2493 {
2494         if (!_intreturn) {
2495                 _intreturn.reset (new InternalReturn (_session));
2496                 add_processor (_intreturn, PreFader);
2497         }
2498 }
2499
2500 void
2501 Route::add_send_to_internal_return (InternalSend* send)
2502 {
2503         Glib::RWLock::ReaderLock rm (_processor_lock);
2504
2505         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2506                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2507
2508                 if (d) {
2509                         return d->add_send (send);
2510                 }
2511         }
2512 }
2513
2514 void
2515 Route::remove_send_from_internal_return (InternalSend* send)
2516 {
2517         Glib::RWLock::ReaderLock rm (_processor_lock);
2518
2519         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2520                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2521
2522                 if (d) {
2523                         return d->remove_send (send);
2524                 }
2525         }
2526 }
2527
2528 /** Add a monitor send (if we don't already have one) but don't activate it */
2529 int
2530 Route::listen_via_monitor ()
2531 {
2532         /* master never sends to control outs */
2533         assert (!is_master ());
2534
2535         /* make sure we have one */
2536         if (!_monitor_send) {
2537                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2538                 _monitor_send->set_display_to_user (false);
2539         }
2540
2541         /* set it up */
2542         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2543         configure_processors (0);
2544
2545         return 0;
2546 }
2547
2548 /** Add an internal send to a route.
2549  *  @param route route to send to.
2550  *  @param placement placement for the send.
2551  */
2552 int
2553 Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
2554 {
2555         assert (route != _session.monitor_out ());
2556
2557         {
2558                 Glib::RWLock::ReaderLock rm (_processor_lock);
2559
2560                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2561
2562                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2563
2564                         if (d && d->target_route() == route) {
2565                                 /* already listening via the specified IO: do nothing */
2566                                 return 0;
2567                         }
2568                 }
2569         }
2570
2571         try {
2572                 boost::shared_ptr<InternalSend> listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2573                 add_processor (listener, placement);
2574
2575         } catch (failed_constructor& err) {
2576                 return -1;
2577         }
2578
2579         return 0;
2580 }
2581
2582 void
2583 Route::drop_listen (boost::shared_ptr<Route> route)
2584 {
2585         ProcessorStreams err;
2586         ProcessorList::iterator tmp;
2587
2588         Glib::RWLock::ReaderLock rl(_processor_lock);
2589         rl.acquire ();
2590
2591   again:
2592         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2593
2594                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2595
2596                 if (d && d->target_route() == route) {
2597                         rl.release ();
2598                         remove_processor (*x, &err);
2599                         rl.acquire ();
2600
2601                         /* list could have been demolished while we dropped the lock
2602                            so start over.
2603                         */
2604
2605                         goto again;
2606                 }
2607         }
2608
2609         rl.release ();
2610
2611         if (route == _session.monitor_out()) {
2612                 _monitor_send.reset ();
2613         }
2614 }
2615
2616 void
2617 Route::set_comment (string cmt, void *src)
2618 {
2619         _comment = cmt;
2620         comment_changed (src);
2621         _session.set_dirty ();
2622 }
2623
2624 bool
2625 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2626 {
2627         FeedRecord fr (other, via_sends_only);
2628
2629         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2630
2631         if (!result.second) {
2632
2633                 /* already a record for "other" - make sure sends-only information is correct */
2634                 if (!via_sends_only && result.first->sends_only) {
2635                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2636                         frp->sends_only = false;
2637                 }
2638         }
2639
2640         return result.second;
2641 }
2642
2643 void
2644 Route::clear_fed_by ()
2645 {
2646         _fed_by.clear ();
2647 }
2648
2649 bool
2650 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2651 {
2652         const FedBy& fed_by (other->fed_by());
2653
2654         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2655                 boost::shared_ptr<Route> sr = f->r.lock();
2656
2657                 if (sr && (sr.get() == this)) {
2658
2659                         if (via_sends_only) {
2660                                 *via_sends_only = f->sends_only;
2661                         }
2662
2663                         return true;
2664                 }
2665         }
2666
2667         return false;
2668 }
2669
2670 bool
2671 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2672 {
2673         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2674
2675         if (_output->connected_to (other->input())) {
2676                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2677                 if (only_send) {
2678                         *only_send = false;
2679                 }
2680
2681                 return true;
2682         }
2683
2684
2685         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2686
2687                 boost::shared_ptr<IOProcessor> iop;
2688
2689                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2690                         if (iop->feeds (other)) {
2691                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2692                                 if (only_send) {
2693                                         *only_send = true;
2694                                 }
2695                                 return true;
2696                         } else {
2697                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2698                         }
2699                 } else {
2700                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2701                 }
2702
2703         }
2704
2705         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2706         return false;
2707 }
2708
2709 /** Called from the (non-realtime) butler thread when the transport is stopped */
2710 void
2711 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2712 {
2713         framepos_t now = _session.transport_frame();
2714
2715         {
2716                 Glib::RWLock::ReaderLock lm (_processor_lock);
2717
2718                 if (!did_locate) {
2719                         automation_snapshot (now, true);
2720                 }
2721
2722                 Automatable::transport_stopped (now);
2723
2724                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2725
2726                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2727                                 (*i)->flush ();
2728                         }
2729
2730                         (*i)->transport_stopped (now);
2731                 }
2732         }
2733
2734         _roll_delay = _initial_delay;
2735 }
2736
2737 /** Called with the process lock held if change contains ConfigurationChanged */
2738 void
2739 Route::input_change_handler (IOChange change, void * /*src*/)
2740 {
2741         if ((change.type & IOChange::ConfigurationChanged)) {
2742                 configure_processors (0);
2743                 _phase_invert.resize (_input->n_ports().n_audio ());
2744                 io_changed (); /* EMIT SIGNAL */
2745         }
2746 }
2747
2748 uint32_t
2749 Route::pans_required () const
2750 {
2751         if (n_outputs().n_audio() < 2) {
2752                 return 0;
2753         }
2754
2755         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2756 }
2757
2758 int
2759 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2760                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2761 {
2762         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2763         if (!lm.locked()) {
2764                 return 0;
2765         }
2766
2767         if (n_outputs().n_total() == 0) {
2768                 return 0;
2769         }
2770
2771         if (!_active || n_inputs() == ChanCount::ZERO)  {
2772                 silence_unlocked (nframes);
2773                 return 0;
2774         }
2775         if (session_state_changing) {
2776                 if (_session.transport_speed() != 0.0f) {
2777                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2778                            so we cannot use them. Be silent till this is over.
2779
2780                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2781                         */
2782                         silence_unlocked (nframes);
2783                         return 0;
2784                 }
2785                 /* we're really not rolling, so we're either delivery silence or actually
2786                    monitoring, both of which are safe to do while session_state_changing is true.
2787                 */
2788         }
2789
2790         _amp->apply_gain_automation (false);
2791         passthru (start_frame, end_frame, nframes, 0);
2792
2793         return 0;
2794 }
2795
2796 framecnt_t
2797 Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
2798 {
2799         if (_roll_delay > nframes) {
2800
2801                 _roll_delay -= nframes;
2802                 silence_unlocked (nframes);
2803                 /* transport frame is not legal for caller to use */
2804                 return 0;
2805
2806         } else if (_roll_delay > 0) {
2807
2808                 nframes -= _roll_delay;
2809                 silence_unlocked (_roll_delay);
2810                 transport_frame += _roll_delay;
2811
2812                 /* shuffle all the port buffers for things that lead "out" of this Route
2813                    to reflect that we just wrote _roll_delay frames of silence.
2814                 */
2815
2816                 Glib::RWLock::ReaderLock lm (_processor_lock);
2817                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2818                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
2819                         if (iop) {
2820                                 iop->increment_port_buffer_offset (_roll_delay);
2821                         }
2822                 }
2823                 _output->increment_port_buffer_offset (_roll_delay);
2824
2825                 _roll_delay = 0;
2826
2827         }
2828
2829         return nframes;
2830 }
2831
2832 int
2833 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2834              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2835 {
2836         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2837         if (!lm.locked()) {
2838                 return 0;
2839         }
2840
2841         automation_snapshot (_session.transport_frame(), false);
2842
2843         if (n_outputs().n_total() == 0) {
2844                 return 0;
2845         }
2846
2847         if (!_active || n_inputs().n_total() == 0) {
2848                 silence_unlocked (nframes);
2849                 return 0;
2850         }
2851
2852         framecnt_t unused = 0;
2853
2854         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2855                 return 0;
2856         }
2857
2858         _silent = false;
2859
2860         passthru (start_frame, end_frame, nframes, declick);
2861
2862         return 0;
2863 }
2864
2865 int
2866 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2867                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2868 {
2869         silence (nframes);
2870         return 0;
2871 }
2872
2873 void
2874 Route::toggle_monitor_input ()
2875 {
2876         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2877                 i->ensure_monitor_input( ! i->monitoring_input());
2878         }
2879 }
2880
2881 bool
2882 Route::has_external_redirects () const
2883 {
2884         // FIXME: what about sends? - they don't return a signal back to ardour?
2885
2886         boost::shared_ptr<const PortInsert> pi;
2887
2888         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2889
2890                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2891
2892                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2893
2894                                 string port_name = port->name();
2895                                 string client_name = port_name.substr (0, port_name.find(':'));
2896
2897                                 /* only say "yes" if the redirect is actually in use */
2898
2899                                 if (client_name != "ardour" && pi->active()) {
2900                                         return true;
2901                                 }
2902                         }
2903                 }
2904         }
2905
2906         return false;
2907 }
2908
2909 void
2910 Route::flush_processors ()
2911 {
2912         /* XXX shouldn't really try to take this lock, since
2913            this is called from the RT audio thread.
2914         */
2915
2916         Glib::RWLock::ReaderLock lm (_processor_lock);
2917
2918         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2919                 (*i)->flush ();
2920         }
2921 }
2922
2923 void
2924 Route::set_meter_point (MeterPoint p, bool force)
2925 {
2926         /* CAN BE CALLED FROM PROCESS CONTEXT */
2927
2928         if (_meter_point == p && !force) {
2929                 return;
2930         }
2931
2932         _meter_point = p;
2933
2934         bool meter_was_visible_to_user = _meter->display_to_user ();
2935
2936         {
2937                 Glib::RWLock::WriterLock lm (_processor_lock);
2938
2939                 if (_meter_point != MeterCustom) {
2940
2941                         _meter->set_display_to_user (false);
2942
2943                         setup_invisible_processors ();
2944
2945                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2946
2947                         ChanCount m_in;
2948
2949                         if (loc == _processors.begin()) {
2950                                 m_in = _input->n_ports();
2951                         } else {
2952                                 ProcessorList::iterator before = loc;
2953                                 --before;
2954                                 m_in = (*before)->output_streams ();
2955                         }
2956
2957                         _meter->reflect_inputs (m_in);
2958
2959                         /* we do not need to reconfigure the processors, because the meter
2960                            (a) is always ready to handle processor_max_streams
2961                            (b) is always an N-in/N-out processor, and thus moving
2962                            it doesn't require any changes to the other processors.
2963                         */
2964
2965                 } else {
2966
2967                         // just make it visible and let the user move it
2968
2969                         _meter->set_display_to_user (true);
2970                 }
2971         }
2972
2973         meter_change (); /* EMIT SIGNAL */
2974
2975         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2976
2977         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2978 }
2979
2980 void
2981 Route::listen_position_changed ()
2982 {
2983         {
2984                 Glib::RWLock::WriterLock lm (_processor_lock);
2985                 ProcessorState pstate (this);
2986
2987                 {
2988                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2989
2990                         if (configure_processors_unlocked (0)) {
2991                                 pstate.restore ();
2992                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
2993                                 return;
2994                         }
2995                 }
2996         }
2997
2998         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2999         _session.set_dirty ();
3000 }
3001
3002 boost::shared_ptr<CapturingProcessor>
3003 Route::add_export_point()
3004 {
3005         if (!_capturing_processor) {
3006
3007                 _capturing_processor.reset (new CapturingProcessor (_session));
3008                 _capturing_processor->activate ();
3009
3010                 {
3011                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3012                         configure_processors (0);
3013                 }
3014
3015         }
3016
3017         return _capturing_processor;
3018 }
3019
3020 framecnt_t
3021 Route::update_signal_latency ()
3022 {
3023         framecnt_t l = _output->user_latency();
3024
3025         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3026                 if ((*i)->active ()) {
3027                         l += (*i)->signal_latency ();
3028                 }
3029         }
3030
3031         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3032
3033         if (_signal_latency != l) {
3034                 _signal_latency = l;
3035                 signal_latency_changed (); /* EMIT SIGNAL */
3036         }
3037
3038         return _signal_latency;
3039 }
3040
3041 void
3042 Route::set_user_latency (framecnt_t nframes)
3043 {
3044         _output->set_user_latency (nframes);
3045         _session.update_latency_compensation ();
3046 }
3047
3048 void
3049 Route::set_latency_compensation (framecnt_t longest_session_latency)
3050 {
3051         framecnt_t old = _initial_delay;
3052
3053         if (_signal_latency < longest_session_latency) {
3054                 _initial_delay = longest_session_latency - _signal_latency;
3055         } else {
3056                 _initial_delay = 0;
3057         }
3058
3059         DEBUG_TRACE (DEBUG::Latency, string_compose (
3060                              "%1: compensate for maximum latency of %2,"
3061                              "given own latency of %3, using initial delay of %4\n",
3062                              name(), longest_session_latency, _signal_latency, _initial_delay));
3063
3064         if (_initial_delay != old) {
3065                 initial_delay_changed (); /* EMIT SIGNAL */
3066         }
3067
3068         if (_session.transport_stopped()) {
3069                 _roll_delay = _initial_delay;
3070         }
3071 }
3072
3073 void
3074 Route::automation_snapshot (framepos_t now, bool force)
3075 {
3076         if (_pannable) {
3077                 _pannable->automation_snapshot (now, force);
3078         }
3079
3080         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3081                 (*i)->automation_snapshot (now, force);
3082         }
3083 }
3084
3085 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3086         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3087                              boost::shared_ptr<AutomationList>(), name)
3088         , _route (r)
3089 {
3090         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3091         set_list (gl);
3092 }
3093
3094 void
3095 Route::SoloControllable::set_value (double val)
3096 {
3097         bool bval = ((val >= 0.5f) ? true: false);
3098
3099         boost::shared_ptr<RouteList> rl (new RouteList);
3100
3101         boost::shared_ptr<Route> r = _route.lock ();
3102         if (!r) {
3103                 return;
3104         }
3105
3106         rl->push_back (r);
3107
3108         if (Config->get_solo_control_is_listen_control()) {
3109                 _session.set_listen (rl, bval);
3110         } else {
3111                 _session.set_solo (rl, bval);
3112         }
3113 }
3114
3115 double
3116 Route::SoloControllable::get_value () const
3117 {
3118         boost::shared_ptr<Route> r = _route.lock ();
3119         if (!r) {
3120                 return 0;
3121         }
3122
3123         if (Config->get_solo_control_is_listen_control()) {
3124                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3125         } else {
3126                 return r->self_soloed() ? 1.0f : 0.0f;
3127         }
3128 }
3129
3130 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3131         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3132                              boost::shared_ptr<AutomationList>(), name)
3133         , _route (r)
3134 {
3135         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3136         set_list (gl);
3137 }
3138
3139 void
3140 Route::MuteControllable::set_value (double val)
3141 {
3142         bool bval = ((val >= 0.5f) ? true: false);
3143
3144         boost::shared_ptr<RouteList> rl (new RouteList);
3145
3146         boost::shared_ptr<Route> r = _route.lock ();
3147         if (!r) {
3148                 return;
3149         }
3150
3151         rl->push_back (r);
3152         _session.set_mute (rl, bval);
3153 }
3154
3155 double
3156 Route::MuteControllable::get_value () const
3157 {
3158         boost::shared_ptr<Route> r = _route.lock ();
3159         if (!r) {
3160                 return 0;
3161         }
3162
3163         return r->muted() ? 1.0f : 0.0f;
3164 }
3165
3166 void
3167 Route::set_block_size (pframes_t nframes)
3168 {
3169         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3170                 (*i)->set_block_size (nframes);
3171         }
3172
3173         _session.ensure_buffers (n_process_buffers ());
3174 }
3175
3176 void
3177 Route::protect_automation ()
3178 {
3179         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3180                 (*i)->protect_automation();
3181 }
3182
3183 void
3184 Route::set_pending_declick (int declick)
3185 {
3186         if (_declickable) {
3187                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3188                 if (declick) {
3189                         _pending_declick = declick;
3190                 }
3191                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3192         } else {
3193                 _pending_declick = 0;
3194         }
3195
3196 }
3197
3198 /** Shift automation forwards from a particular place, thereby inserting time.
3199  *  Adds undo commands for any shifts that are performed.
3200  *
3201  * @param pos Position to start shifting from.
3202  * @param frames Amount to shift forwards by.
3203  */
3204
3205 void
3206 Route::shift (framepos_t pos, framecnt_t frames)
3207 {
3208         /* gain automation */
3209         {
3210                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3211
3212                 XMLNode &before = gc->alist()->get_state ();
3213                 gc->alist()->shift (pos, frames);
3214                 XMLNode &after = gc->alist()->get_state ();
3215                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3216         }
3217
3218         /* pan automation */
3219         if (_pannable) {
3220                 ControlSet::Controls& c (_pannable->controls());
3221
3222                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3223                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3224                         if (pc) {
3225                                 boost::shared_ptr<AutomationList> al = pc->alist();
3226                                 XMLNode& before = al->get_state ();
3227                                 al->shift (pos, frames);
3228                                 XMLNode& after = al->get_state ();
3229                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3230                         }
3231                 }
3232         }
3233
3234         /* redirect automation */
3235         {
3236                 Glib::RWLock::ReaderLock lm (_processor_lock);
3237                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3238
3239                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3240
3241                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3242                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3243                                 if (ac) {
3244                                         boost::shared_ptr<AutomationList> al = ac->alist();
3245                                         XMLNode &before = al->get_state ();
3246                                         al->shift (pos, frames);
3247                                         XMLNode &after = al->get_state ();
3248                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3249                                 }
3250                         }
3251                 }
3252         }
3253 }
3254
3255
3256 int
3257 Route::save_as_template (const string& path, const string& name)
3258 {
3259         XMLNode& node (state (false));
3260         XMLTree tree;
3261
3262         IO::set_name_in_state (*node.children().front(), name);
3263
3264         tree.set_root (&node);
3265         return tree.write (path.c_str());
3266 }
3267
3268
3269 bool
3270 Route::set_name (const string& str)
3271 {
3272         bool ret;
3273         string ioproc_name;
3274         string name;
3275
3276         name = Route::ensure_track_or_route_name (str, _session);
3277         SessionObject::set_name (name);
3278
3279         ret = (_input->set_name(name) && _output->set_name(name));
3280
3281         if (ret) {
3282                 /* rename the main outs. Leave other IO processors
3283                  * with whatever name they already have, because its
3284                  * just fine as it is (it will not contain the route
3285                  * name if its a port insert, port send or port return).
3286                  */
3287
3288                 if (_main_outs) {
3289                         if (_main_outs->set_name (name)) {
3290                                 /* XXX returning false here is stupid because
3291                                    we already changed the route name.
3292                                 */
3293                                 return false;
3294                         }
3295                 }
3296         }
3297
3298         return ret;
3299 }
3300
3301 boost::shared_ptr<Send>
3302 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3303 {
3304         Glib::RWLock::ReaderLock lm (_processor_lock);
3305
3306         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3307                 boost::shared_ptr<InternalSend> send;
3308
3309                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3310                         if (send->target_route() == target) {
3311                                 return send;
3312                         }
3313                 }
3314         }
3315
3316         return boost::shared_ptr<Send>();
3317 }
3318
3319 /** @param c Audio channel index.
3320  *  @param yn true to invert phase, otherwise false.
3321  */
3322 void
3323 Route::set_phase_invert (uint32_t c, bool yn)
3324 {
3325         if (_phase_invert[c] != yn) {
3326                 _phase_invert[c] = yn;
3327                 phase_invert_changed (); /* EMIT SIGNAL */
3328                 _session.set_dirty ();
3329         }
3330 }
3331
3332 void
3333 Route::set_phase_invert (boost::dynamic_bitset<> p)
3334 {
3335         if (_phase_invert != p) {
3336                 _phase_invert = p;
3337                 phase_invert_changed (); /* EMIT SIGNAL */
3338                 _session.set_dirty ();
3339         }
3340 }
3341
3342 bool
3343 Route::phase_invert (uint32_t c) const
3344 {
3345         return _phase_invert[c];
3346 }
3347
3348 boost::dynamic_bitset<>
3349 Route::phase_invert () const
3350 {
3351         return _phase_invert;
3352 }
3353
3354 void
3355 Route::set_denormal_protection (bool yn)
3356 {
3357         if (_denormal_protection != yn) {
3358                 _denormal_protection = yn;
3359                 denormal_protection_changed (); /* EMIT SIGNAL */
3360         }
3361 }
3362
3363 bool
3364 Route::denormal_protection () const
3365 {
3366         return _denormal_protection;
3367 }
3368
3369 void
3370 Route::set_active (bool yn, void* src)
3371 {
3372         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3373                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3374                 return;
3375         }
3376
3377         if (_active != yn) {
3378                 _active = yn;
3379                 _input->set_active (yn);
3380                 _output->set_active (yn);
3381                 active_changed (); // EMIT SIGNAL
3382         }
3383 }
3384
3385 void
3386 Route::meter ()
3387 {
3388         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3389
3390         assert (_meter);
3391
3392         _meter->meter ();
3393
3394         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3395
3396                 boost::shared_ptr<Send> s;
3397                 boost::shared_ptr<Return> r;
3398
3399                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3400                         s->meter()->meter();
3401                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3402                         r->meter()->meter ();
3403                 }
3404         }
3405 }
3406
3407 boost::shared_ptr<Pannable>
3408 Route::pannable() const
3409 {
3410         return _pannable;
3411 }
3412
3413 boost::shared_ptr<Panner>
3414 Route::panner() const
3415 {
3416         /* may be null ! */
3417         return _main_outs->panner_shell()->panner();
3418 }
3419
3420 boost::shared_ptr<PannerShell>
3421 Route::panner_shell() const
3422 {
3423         return _main_outs->panner_shell();
3424 }
3425
3426 boost::shared_ptr<AutomationControl>
3427 Route::gain_control() const
3428 {
3429         return _amp->gain_control();
3430 }
3431
3432 boost::shared_ptr<AutomationControl>
3433 Route::get_control (const Evoral::Parameter& param)
3434 {
3435         /* either we own the control or .... */
3436
3437         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3438
3439         if (!c) {
3440
3441                 /* maybe one of our processors does or ... */
3442
3443                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3444                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3445                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3446                                 break;
3447                         }
3448                 }
3449         }
3450
3451         if (!c) {
3452
3453                 /* nobody does so we'll make a new one */
3454
3455                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3456                 add_control(c);
3457         }
3458
3459         return c;
3460 }
3461
3462 boost::shared_ptr<Processor>
3463 Route::nth_plugin (uint32_t n)
3464 {
3465         Glib::RWLock::ReaderLock lm (_processor_lock);
3466         ProcessorList::iterator i;
3467
3468         for (i = _processors.begin(); i != _processors.end(); ++i) {
3469                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3470                         if (n-- == 0) {
3471                                 return *i;
3472                         }
3473                 }
3474         }
3475
3476         return boost::shared_ptr<Processor> ();
3477 }
3478
3479 boost::shared_ptr<Processor>
3480 Route::nth_send (uint32_t n)
3481 {
3482         Glib::RWLock::ReaderLock lm (_processor_lock);
3483         ProcessorList::iterator i;
3484
3485         for (i = _processors.begin(); i != _processors.end(); ++i) {
3486                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3487                         if (n-- == 0) {
3488                                 return *i;
3489                         }
3490                 }
3491         }
3492
3493         return boost::shared_ptr<Processor> ();
3494 }
3495
3496 bool
3497 Route::has_io_processor_named (const string& name)
3498 {
3499         Glib::RWLock::ReaderLock lm (_processor_lock);
3500         ProcessorList::iterator i;
3501
3502         for (i = _processors.begin(); i != _processors.end(); ++i) {
3503                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3504                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3505                         if ((*i)->name() == name) {
3506                                 return true;
3507                         }
3508                 }
3509         }
3510
3511         return false;
3512 }
3513
3514 MuteMaster::MutePoint
3515 Route::mute_points () const
3516 {
3517         return _mute_master->mute_points ();
3518 }
3519
3520 void
3521 Route::set_processor_positions ()
3522 {
3523         Glib::RWLock::ReaderLock lm (_processor_lock);
3524
3525         bool had_amp = false;
3526         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3527                 (*i)->set_pre_fader (!had_amp);
3528                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3529                         had_amp = true;
3530                 }
3531         }
3532 }
3533
3534 /** Called when there is a proposed change to the input port count */
3535 bool
3536 Route::input_port_count_changing (ChanCount to)
3537 {
3538         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3539         if (c.empty()) {
3540                 /* The processors cannot be configured with the new input arrangement, so
3541                    block the change.
3542                 */
3543                 return true;
3544         }
3545
3546         /* The change is ok */
3547         return false;
3548 }
3549
3550 list<string>
3551 Route::unknown_processors () const
3552 {
3553         list<string> p;
3554
3555         Glib::RWLock::ReaderLock lm (_processor_lock);
3556         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3557                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3558                         p.push_back ((*i)->name ());
3559                 }
3560         }
3561
3562         return p;
3563 }
3564
3565
3566 framecnt_t
3567 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3568 {
3569         /* we assume that all our input ports feed all our output ports. its not
3570            universally true, but the alternative is way too corner-case to worry about.
3571         */
3572
3573         jack_latency_range_t all_connections;
3574
3575         all_connections.min = ~((jack_nframes_t) 0);
3576         all_connections.max = 0;
3577
3578         /* iterate over all "from" ports and determine the latency range for all of their
3579            connections to the "outside" (outside of this Route).
3580         */
3581
3582         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3583
3584                 jack_latency_range_t range;
3585
3586                 p->get_connected_latency_range (range, playback);
3587
3588                 all_connections.min = min (all_connections.min, range.min);
3589                 all_connections.max = max (all_connections.max, range.max);
3590         }
3591
3592         /* set the "from" port latencies to the max/min range of all their connections */
3593
3594         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3595                 p->set_private_latency_range (all_connections, playback);
3596         }
3597
3598         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3599
3600         all_connections.min += our_latency;
3601         all_connections.max += our_latency;
3602
3603         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3604                 p->set_private_latency_range (all_connections, playback);
3605         }
3606
3607         return all_connections.max;
3608 }
3609
3610 framecnt_t
3611 Route::set_private_port_latencies (bool playback) const
3612 {
3613         framecnt_t own_latency = 0;
3614
3615         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3616            OR LATENCY CALLBACK.
3617
3618            This is called (early) from the latency callback. It computes the REAL
3619            latency associated with each port and stores the result as the "private"
3620            latency of the port. A later call to Route::set_public_port_latencies()
3621            sets all ports to the same value to reflect the fact that we do latency
3622            compensation and so all signals are delayed by the same amount as they
3623            flow through ardour.
3624         */
3625
3626         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3627                 if ((*i)->active ()) {
3628                         own_latency += (*i)->signal_latency ();
3629                 }
3630         }
3631
3632         if (playback) {
3633                 /* playback: propagate latency from "outside the route" to outputs to inputs */
3634                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3635         } else {
3636                 /* capture: propagate latency from "outside the route" to inputs to outputs */
3637                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3638         }
3639 }
3640
3641 void
3642 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3643 {
3644         /* this is called to set the JACK-visible port latencies, which take
3645            latency compensation into account.
3646         */
3647
3648         jack_latency_range_t range;
3649
3650         range.min = value;
3651         range.max = value;
3652
3653         {
3654                 const PortSet& ports (_input->ports());
3655                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3656                         p->set_public_latency_range (range, playback);
3657                 }
3658         }
3659
3660         {
3661                 const PortSet& ports (_output->ports());
3662                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3663                         p->set_public_latency_range (range, playback);
3664                 }
3665         }
3666 }
3667
3668 /** Put the invisible processors in the right place in _processors.
3669  *  Must be called with a writer lock on _processor_lock held.
3670  */
3671 void
3672 Route::setup_invisible_processors ()
3673 {
3674 #ifndef NDEBUG
3675         Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3676         assert (!lm.locked ());
3677 #endif
3678
3679         if (!_main_outs) {
3680                 /* too early to be doing this stuff */
3681                 return;
3682         }
3683
3684         /* we'll build this new list here and then use it */
3685
3686         ProcessorList new_processors;
3687
3688         /* find visible processors */
3689
3690         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3691                 if ((*i)->display_to_user ()) {
3692                         new_processors.push_back (*i);
3693                 }
3694         }
3695
3696         /* find the amp */
3697
3698         ProcessorList::iterator amp = new_processors.begin ();
3699         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3700                 ++amp;
3701         }
3702
3703         assert (amp != _processors.end ());
3704
3705         /* and the processor after the amp */
3706
3707         ProcessorList::iterator after_amp = amp;
3708         ++after_amp;
3709
3710         /* METER */
3711
3712         if (_meter) {
3713                 switch (_meter_point) {
3714                 case MeterInput:
3715                         assert (!_meter->display_to_user ());
3716                         new_processors.push_front (_meter);
3717                         break;
3718                 case MeterPreFader:
3719                         assert (!_meter->display_to_user ());
3720                         new_processors.insert (amp, _meter);
3721                         break;
3722                 case MeterPostFader:
3723                         /* do nothing here */
3724                         break;
3725                 case MeterOutput:
3726                         /* do nothing here */
3727                         break;
3728                 case MeterCustom:
3729                         /* the meter is visible, so we don't touch it here */
3730                         break;
3731                 }
3732         }
3733
3734         /* MAIN OUTS */
3735
3736         assert (_main_outs);
3737         assert (!_main_outs->display_to_user ());
3738         new_processors.push_back (_main_outs);
3739
3740         /* iterator for the main outs */
3741
3742         ProcessorList::iterator main = new_processors.end();
3743         --main;
3744
3745         /* OUTPUT METERING */
3746
3747         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3748                 assert (!_meter->display_to_user ());
3749
3750                 /* add the processor just before or just after the main outs */
3751
3752                 ProcessorList::iterator meter_point = main;
3753
3754                 if (_meter_point == MeterOutput) {
3755                         ++meter_point;
3756                 }
3757                 new_processors.insert (meter_point, _meter);
3758         }
3759
3760         /* MONITOR SEND */
3761
3762         if (_monitor_send && !is_monitor ()) {
3763                 assert (!_monitor_send->display_to_user ());
3764                 if (Config->get_solo_control_is_listen_control()) {
3765                         switch (Config->get_listen_position ()) {
3766                         case PreFaderListen:
3767                                 switch (Config->get_pfl_position ()) {
3768                                 case PFLFromBeforeProcessors:
3769                                         new_processors.push_front (_monitor_send);
3770                                         break;
3771                                 case PFLFromAfterProcessors:
3772                                         new_processors.insert (amp, _monitor_send);
3773                                         break;
3774                                 }
3775                                 _monitor_send->set_can_pan (false);
3776                                 break;
3777                         case AfterFaderListen:
3778                                 switch (Config->get_afl_position ()) {
3779                                 case AFLFromBeforeProcessors:
3780                                         new_processors.insert (after_amp, _monitor_send);
3781                                         break;
3782                                 case AFLFromAfterProcessors:
3783                                         new_processors.insert (new_processors.end(), _monitor_send);
3784                                         break;
3785                                 }
3786                                 _monitor_send->set_can_pan (true);
3787                                 break;
3788                         }
3789                 }  else {
3790                         new_processors.insert (new_processors.end(), _monitor_send);
3791                         _monitor_send->set_can_pan (false);
3792                 }
3793         }
3794
3795         /* MONITOR CONTROL */
3796
3797         if (_monitor_control && is_monitor ()) {
3798                 assert (!_monitor_control->display_to_user ());
3799                 new_processors.push_front (_monitor_control);
3800         }
3801
3802         /* INTERNAL RETURN */
3803
3804         /* doing this here means that any monitor control will come just after
3805            the return.
3806         */
3807
3808         if (_intreturn) {
3809                 assert (!_intreturn->display_to_user ());
3810                 new_processors.push_front (_intreturn);
3811         }
3812
3813         /* EXPORT PROCESSOR */
3814
3815         if (_capturing_processor) {
3816                 assert (!_capturing_processor->display_to_user ());
3817                 new_processors.push_front (_capturing_processor);
3818         }
3819
3820         _processors = new_processors;
3821
3822         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3823         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3824                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3825         }
3826 }
3827
3828 bool
3829 Route::should_monitor () const
3830 {
3831         switch (Config->get_monitoring_model()) {
3832         case HardwareMonitoring:
3833         case ExternalMonitoring:
3834                 return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
3835                 break;
3836         default:
3837                 break;
3838         }
3839
3840         return true;
3841 }
3842
3843 void
3844 Route::unpan ()
3845 {
3846         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3847         Glib::RWLock::ReaderLock lp (_processor_lock);
3848
3849         _pannable.reset ();
3850
3851         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3852                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
3853                 if (d) {
3854                         d->unpan ();
3855                 }
3856         }
3857 }