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