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