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