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