libs/ardour/route.cc

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