libs/ardour/route.cc

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