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