libs/ardour/route.cc

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