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