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         ChanCount old_pms = processor_max_streams;
 875
 876         if (!_session.engine().connected() || !processor) {
 877                 return 1;
 878         }
 879
 880         {
 881                 Glib::RWLock::WriterLock lm (_processor_lock);
 882                 ProcessorState pstate (this);
 883
 884                 boost::shared_ptr<PluginInsert> pi;
 885                 boost::shared_ptr<PortInsert> porti;
 886
 887                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
 888
 889                 if (processor == _amp) {
 890                         // Ensure only one amp is in the list at any time
 891                         if (loc != _processors.end()) {
 892                                 if (iter == loc) { // Already in place, do nothing
 893                                         return 0;
 894                                 } else { // New position given, relocate
 895                                         _processors.erase (loc);
 896                                 }
 897                         }
 898
 899                 } else {
 900                         if (loc != _processors.end()) {
 901                                 cerr << "ERROR: Processor added to route twice!" << endl;
 902                                 return 1;
 903                         }
 904
 905                         loc = iter;
 906                 }
 907
 908                 _processors.insert (loc, processor);
 909
 910                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
 911                 // configure redirect ports properly, etc.
 912
 913                 {
 914                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 915
 916                         if (configure_processors_unlocked (err)) {
 917                                 pstate.restore ();
 918                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
 919                                 cerr << "configure failed\n";
 920                                 return -1;
 921                         }
 922                 }
 923
 924                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
 925
 926                         if (pi->natural_input_streams() == ChanCount::ZERO) {
 927                                 /* generator plugin */
 928                                 _have_internal_generator = true;
 929                         }
 930
 931                 }
 932
 933                 if (activation_allowed) {
 934                         processor->activate ();
 935                 }
 936
 937                 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
 938
 939                 _output->set_user_latency (0);
 940         }
 941
 942         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
 943         set_processor_positions ();
 944
 945         return 0;
 946 }
 947
 948 bool
 949 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
 950 {
 951         const XMLProperty *prop;
 952
 953         try {
 954                 boost::shared_ptr<Processor> processor;
 955
 956                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
 957                    so that we can add the processor in the right place (pre/post-fader)
 958                 */
 959
 960                 XMLNodeList const & children = node.children ();
 961                 XMLNodeList::const_iterator i = children.begin ();
 962
 963                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
 964                         ++i;
 965                 }
 966
 967                 Placement placement = PreFader;
 968
 969                 if (i != children.end()) {
 970                         if ((prop = (*i)->property (X_("placement"))) != 0) {
 971                                 placement = Placement (string_2_enum (prop->value(), placement));
 972                         }
 973                 }
 974
 975                 if (node.name() == "Insert") {
 976
 977                         if ((prop = node.property ("type")) != 0) {
 978
 979                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 980                                                 prop->value() == "lv2" ||
 981                                                 prop->value() == "vst" ||
 982                                                 prop->value() == "audiounit") {
 983
 984                                         processor.reset (new PluginInsert (_session));
 985
 986                                 } else {
 987
 988                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
 989                                 }
 990
 991                         }
 992
 993                 } else if (node.name() == "Send") {
 994
 995                         processor.reset (new Send (_session, _pannable, _mute_master));
 996
 997                 } else {
 998
 999                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1000                         return false;
1001                 }
1002
1003                 if (processor->set_state (node, version)) {
1004                         return false;
1005                 }
1006
1007                 return (add_processor (processor, placement) == 0);
1008         }
1009
1010         catch (failed_constructor &err) {
1011                 warning << _("processor could not be created. Ignored.") << endmsg;
1012                 return false;
1013         }
1014 }
1015
1016 int
1017 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1018 {
1019         /* NOTE: this is intended to be used ONLY when copying
1020            processors from another Route. Hence the subtle
1021            differences between this and ::add_processor()
1022         */
1023
1024         ProcessorList::iterator loc;
1025
1026         if (before) {
1027                 loc = find(_processors.begin(), _processors.end(), before);
1028         } else {
1029                 /* nothing specified - at end */
1030                 loc = _processors.end ();
1031         }
1032
1033         ChanCount old_pms = processor_max_streams;
1034
1035         if (!_session.engine().connected()) {
1036                 return 1;
1037         }
1038
1039         if (others.empty()) {
1040                 return 0;
1041         }
1042
1043         {
1044                 Glib::RWLock::WriterLock lm (_processor_lock);
1045                 ProcessorState pstate (this);
1046
1047                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1048
1049                         if (*i == _meter) {
1050                                 continue;
1051                         }
1052
1053                         boost::shared_ptr<PluginInsert> pi;
1054
1055                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1056                                 pi->set_count (1);
1057                         }
1058
1059                         ProcessorList::iterator inserted = _processors.insert (loc, *i);
1060
1061                         if ((*i)->active()) {
1062                                 (*i)->activate ();
1063                         }
1064
1065                         {
1066                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1067                                 if (configure_processors_unlocked (err)) {
1068                                         pstate.restore ();
1069                                         configure_processors_unlocked (0); // it worked before we tried to add it ...
1070                                         return -1;
1071                                 }
1072                         }
1073
1074                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
1075                 }
1076
1077                 _output->set_user_latency (0);
1078         }
1079
1080         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1081         set_processor_positions ();
1082
1083         return 0;
1084 }
1085
1086 void
1087 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1088 {
1089         if (p == PreFader) {
1090                 start = _processors.begin();
1091                 end = find(_processors.begin(), _processors.end(), _amp);
1092         } else {
1093                 start = find(_processors.begin(), _processors.end(), _amp);
1094                 ++start;
1095                 end = _processors.end();
1096         }
1097 }
1098
1099 /** Turn off all processors with a given placement
1100  * @param p Placement of processors to disable
1101  */
1102 void
1103 Route::disable_processors (Placement p)
1104 {
1105         Glib::RWLock::ReaderLock lm (_processor_lock);
1106
1107         ProcessorList::iterator start, end;
1108         placement_range(p, start, end);
1109
1110         for (ProcessorList::iterator i = start; i != end; ++i) {
1111                 (*i)->deactivate ();
1112         }
1113
1114         _session.set_dirty ();
1115 }
1116
1117 /** Turn off all redirects
1118  */
1119 void
1120 Route::disable_processors ()
1121 {
1122         Glib::RWLock::ReaderLock lm (_processor_lock);
1123
1124         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1125                 (*i)->deactivate ();
1126         }
1127
1128         _session.set_dirty ();
1129 }
1130
1131 /** Turn off all redirects with a given placement
1132  * @param p Placement of redirects to disable
1133  */
1134 void
1135 Route::disable_plugins (Placement p)
1136 {
1137         Glib::RWLock::ReaderLock lm (_processor_lock);
1138
1139         ProcessorList::iterator start, end;
1140         placement_range(p, start, end);
1141
1142         for (ProcessorList::iterator i = start; i != end; ++i) {
1143                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1144                         (*i)->deactivate ();
1145                 }
1146         }
1147
1148         _session.set_dirty ();
1149 }
1150
1151 /** Turn off all plugins
1152  */
1153 void
1154 Route::disable_plugins ()
1155 {
1156         Glib::RWLock::ReaderLock lm (_processor_lock);
1157
1158         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1159                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1160                         (*i)->deactivate ();
1161                 }
1162         }
1163
1164         _session.set_dirty ();
1165 }
1166
1167
1168 void
1169 Route::ab_plugins (bool forward)
1170 {
1171         Glib::RWLock::ReaderLock lm (_processor_lock);
1172
1173         if (forward) {
1174
1175                 /* forward = turn off all active redirects, and mark them so that the next time
1176                    we go the other way, we will revert them
1177                 */
1178
1179                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1180                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1181                                 continue;
1182                         }
1183
1184                         if ((*i)->active()) {
1185                                 (*i)->deactivate ();
1186                                 (*i)->set_next_ab_is_active (true);
1187                         } else {
1188                                 (*i)->set_next_ab_is_active (false);
1189                         }
1190                 }
1191
1192         } else {
1193
1194                 /* backward = if the redirect was marked to go active on the next ab, do so */
1195
1196                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1197
1198                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1199                                 continue;
1200                         }
1201
1202                         if ((*i)->get_next_ab_is_active()) {
1203                                 (*i)->activate ();
1204                         } else {
1205                                 (*i)->deactivate ();
1206                         }
1207                 }
1208         }
1209
1210         _session.set_dirty ();
1211 }
1212
1213
1214 /** Remove processors with a given placement.
1215  * @param p Placement of processors to remove.
1216  */
1217 void
1218 Route::clear_processors (Placement p)
1219 {
1220         const ChanCount old_pms = processor_max_streams;
1221
1222         if (!_session.engine().connected()) {
1223                 return;
1224         }
1225
1226         bool already_deleting = _session.deletion_in_progress();
1227         if (!already_deleting) {
1228                 _session.set_deletion_in_progress();
1229         }
1230
1231         {
1232                 Glib::RWLock::WriterLock lm (_processor_lock);
1233                 ProcessorList new_list;
1234                 ProcessorStreams err;
1235                 bool seen_amp = false;
1236
1237                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1238
1239                         if (*i == _amp) {
1240                                 seen_amp = true;
1241                         }
1242
1243                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1244
1245                                 /* you can't remove these */
1246
1247                                 new_list.push_back (*i);
1248
1249                         } else {
1250                                 if (seen_amp) {
1251
1252                                         switch (p) {
1253                                         case PreFader:
1254                                                 new_list.push_back (*i);
1255                                                 break;
1256                                         case PostFader:
1257                                                 (*i)->drop_references ();
1258                                                 break;
1259                                         }
1260
1261                                 } else {
1262
1263                                         switch (p) {
1264                                         case PreFader:
1265                                                 (*i)->drop_references ();
1266                                                 break;
1267                                         case PostFader:
1268                                                 new_list.push_back (*i);
1269                                                 break;
1270                                         }
1271                                 }
1272                         }
1273                 }
1274
1275                 _processors = new_list;
1276
1277                 {
1278                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1279                         configure_processors_unlocked (&err); // this can't fail
1280                 }
1281         }
1282
1283         processor_max_streams.reset();
1284         _have_internal_generator = false;
1285         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1286         set_processor_positions ();
1287
1288         if (!already_deleting) {
1289                 _session.clear_deletion_in_progress();
1290         }
1291 }
1292
1293 int
1294 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1295 {
1296         /* these can never be removed */
1297
1298         if (processor == _amp || processor == _meter || processor == _main_outs) {
1299                 return 0;
1300         }
1301
1302         ChanCount old_pms = processor_max_streams;
1303
1304         if (!_session.engine().connected()) {
1305                 return 1;
1306         }
1307
1308         processor_max_streams.reset();
1309
1310         {
1311                 Glib::RWLock::WriterLock lm (_processor_lock);
1312                 ProcessorState pstate (this);
1313
1314                 ProcessorList::iterator i;
1315                 bool removed = false;
1316
1317                 for (i = _processors.begin(); i != _processors.end(); ) {
1318                         if (*i == processor) {
1319
1320                                 /* move along, see failure case for configure_processors()
1321                                    where we may need to reconfigure the processor.
1322                                 */
1323
1324                                 /* stop redirects that send signals to JACK ports
1325                                    from causing noise as a result of no longer being
1326                                    run.
1327                                 */
1328
1329                                 boost::shared_ptr<IOProcessor> iop;
1330
1331                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1332                                         if (iop->input()) {
1333                                                 iop->input()->disconnect (this);
1334                                         }
1335                                         if (iop->output()) {
1336                                                 iop->output()->disconnect (this);
1337                                         }
1338                                 }
1339
1340                                 i = _processors.erase (i);
1341                                 removed = true;
1342                                 break;
1343
1344                         } else {
1345                                 ++i;
1346                         }
1347
1348                         _output->set_user_latency (0);
1349                 }
1350
1351                 if (!removed) {
1352                         /* what? */
1353                         return 1;
1354                 }
1355
1356                 {
1357                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1358
1359                         if (configure_processors_unlocked (err)) {
1360                                 pstate.restore ();
1361                                 /* we know this will work, because it worked before :) */
1362                                 configure_processors_unlocked (0);
1363                                 return -1;
1364                         }
1365                 }
1366
1367                 _have_internal_generator = false;
1368
1369                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1370                         boost::shared_ptr<PluginInsert> pi;
1371
1372                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1373                                 if (pi->is_generator()) {
1374                                         _have_internal_generator = true;
1375                                         break;
1376                                 }
1377                         }
1378                 }
1379         }
1380
1381         processor->drop_references ();
1382         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1383         set_processor_positions ();
1384
1385         return 0;
1386 }
1387
1388 int
1389 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1390 {
1391         ProcessorList deleted;
1392
1393         if (!_session.engine().connected()) {
1394                 return 1;
1395         }
1396
1397         processor_max_streams.reset();
1398
1399         {
1400                 Glib::RWLock::WriterLock lm (_processor_lock);
1401                 ProcessorState pstate (this);
1402
1403                 ProcessorList::iterator i;
1404                 boost::shared_ptr<Processor> processor;
1405
1406                 for (i = _processors.begin(); i != _processors.end(); ) {
1407
1408                         processor = *i;
1409
1410                         /* these can never be removed */
1411
1412                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1413                                 ++i;
1414                                 continue;
1415                         }
1416
1417                         /* see if its in the list of processors to delete */
1418
1419                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1420                                 ++i;
1421                                 continue;
1422                         }
1423
1424                         /* stop IOProcessors that send to JACK ports
1425                            from causing noise as a result of no longer being
1426                            run.
1427                         */
1428
1429                         boost::shared_ptr<IOProcessor> iop;
1430
1431                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1432                                 iop->disconnect ();
1433                         }
1434
1435                         deleted.push_back (processor);
1436                         i = _processors.erase (i);
1437                 }
1438
1439                 if (deleted.empty()) {
1440                         /* none of those in the requested list were found */
1441                         return 0;
1442                 }
1443
1444                 _output->set_user_latency (0);
1445
1446                 {
1447                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1448
1449                         if (configure_processors_unlocked (err)) {
1450                                 pstate.restore ();
1451                                 /* we know this will work, because it worked before :) */
1452                                 configure_processors_unlocked (0);
1453                                 return -1;
1454                         }
1455                 }
1456
1457                 _have_internal_generator = false;
1458
1459                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1460                         boost::shared_ptr<PluginInsert> pi;
1461
1462                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1463                                 if (pi->is_generator()) {
1464                                         _have_internal_generator = true;
1465                                         break;
1466                                 }
1467                         }
1468                 }
1469         }
1470
1471         /* now try to do what we need to so that those that were removed will be deleted */
1472
1473         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1474                 (*i)->drop_references ();
1475         }
1476
1477         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1478         set_processor_positions ();
1479
1480         return 0;
1481 }
1482
1483 /** Caller must hold process lock */
1484 int
1485 Route::configure_processors (ProcessorStreams* err)
1486 {
1487         assert (!AudioEngine::instance()->process_lock().trylock());
1488
1489         if (!_in_configure_processors) {
1490                 Glib::RWLock::WriterLock lm (_processor_lock);
1491                 return configure_processors_unlocked (err);
1492         }
1493
1494         return 0;
1495 }
1496
1497 ChanCount
1498 Route::input_streams () const
1499 {
1500         return _input->n_ports ();
1501 }
1502
1503 list<pair<ChanCount, ChanCount> >
1504 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1505 {
1506         Glib::RWLock::ReaderLock lm (_processor_lock);
1507
1508         return try_configure_processors_unlocked (in, err);
1509 }
1510
1511 list<pair<ChanCount, ChanCount> >
1512 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1513 {
1514         // Check each processor in order to see if we can configure as requested
1515         ChanCount out;
1516         list<pair<ChanCount, ChanCount> > configuration;
1517         uint32_t index = 0;
1518
1519         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1520         DEBUG_TRACE (DEBUG::Processors, "{\n");
1521
1522         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1523
1524                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1525                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1526                         break;
1527                 }
1528
1529                 if ((*p)->can_support_io_configuration(in, out)) {
1530                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1531                         configuration.push_back(make_pair(in, out));
1532                         in = out;
1533                 } else {
1534                         if (err) {
1535                                 err->index = index;
1536                                 err->count = in;
1537                         }
1538                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1539                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1540                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1541                         return list<pair<ChanCount, ChanCount> > ();
1542                 }
1543         }
1544
1545         DEBUG_TRACE (DEBUG::Processors, "}\n");
1546
1547         return configuration;
1548 }
1549
1550 /** Set the input/output configuration of each processor in the processors list.
1551  *  Caller must hold process lock.
1552  *  Return 0 on success, otherwise configuration is impossible.
1553  */
1554 int
1555 Route::configure_processors_unlocked (ProcessorStreams* err)
1556 {
1557         assert (!AudioEngine::instance()->process_lock().trylock());
1558
1559         if (_in_configure_processors) {
1560                 return 0;
1561         }
1562
1563         /* put invisible processors where they should be */
1564         setup_invisible_processors ();
1565
1566         _in_configure_processors = true;
1567
1568         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1569
1570         if (configuration.empty ()) {
1571                 _in_configure_processors = false;
1572                 return -1;
1573         }
1574
1575         ChanCount out;
1576
1577         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1578         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1579
1580                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1581                         break;
1582                 }
1583
1584                 (*p)->configure_io(c->first, c->second);
1585                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1586                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1587                 out = c->second;
1588         }
1589
1590         if (_meter) {
1591                 _meter->reset_max_channels (processor_max_streams);
1592         }
1593
1594         /* make sure we have sufficient scratch buffers to cope with the new processor
1595            configuration */
1596         _session.ensure_buffers (n_process_buffers ());
1597
1598         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1599
1600         _in_configure_processors = false;
1601         return 0;
1602 }
1603
1604 void
1605 Route::all_processors_flip ()
1606 {
1607         Glib::RWLock::ReaderLock lm (_processor_lock);
1608
1609         if (_processors.empty()) {
1610                 return;
1611         }
1612
1613         bool first_is_on = _processors.front()->active();
1614
1615         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1616                 if (first_is_on) {
1617                         (*i)->deactivate ();
1618                 } else {
1619                         (*i)->activate ();
1620                 }
1621         }
1622
1623         _session.set_dirty ();
1624 }
1625
1626 /** Set all processors with a given placement to a given active state.
1627  * @param p Placement of processors to change.
1628  * @param state New active state for those processors.
1629  */
1630 void
1631 Route::all_processors_active (Placement p, bool state)
1632 {
1633         Glib::RWLock::ReaderLock lm (_processor_lock);
1634
1635         if (_processors.empty()) {
1636                 return;
1637         }
1638         ProcessorList::iterator start, end;
1639         placement_range(p, start, end);
1640
1641         bool before_amp = true;
1642         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1643                 if ((*i) == _amp) {
1644                         before_amp = false;
1645                         continue;
1646                 }
1647                 if (p == PreFader && before_amp) {
1648                         if (state) {
1649                                 (*i)->activate ();
1650                         } else {
1651                                 (*i)->deactivate ();
1652                         }
1653                 }
1654         }
1655
1656         _session.set_dirty ();
1657 }
1658
1659 bool
1660 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1661 {
1662         bool pre_fader = true;
1663         Glib::RWLock::ReaderLock lm (_processor_lock);
1664
1665         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1666
1667                 /* semantic note: if p == amp, we want to return true, so test
1668                    for equality before checking if this is the amp
1669                 */
1670
1671                 if ((*i) == p) {
1672                         break;
1673                 }
1674
1675                 if ((*i) == _amp) {
1676                         pre_fader = false;
1677                         break;
1678                 }
1679         }
1680
1681         return pre_fader;
1682 }
1683
1684 int
1685 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1686 {
1687         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1688            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1689            processors in the current actual processor list that are hidden. Any visible processors
1690            in the current list but not in "new_order" will be assumed to be deleted.
1691         */
1692
1693         {
1694                 Glib::RWLock::WriterLock lm (_processor_lock);
1695                 ProcessorState pstate (this);
1696
1697                 ProcessorList::iterator oiter;
1698                 ProcessorList::const_iterator niter;
1699                 ProcessorList as_it_will_be;
1700
1701                 oiter = _processors.begin();
1702                 niter = new_order.begin();
1703
1704                 while (niter !=  new_order.end()) {
1705
1706                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1707                            then append it to the temp list.
1708
1709                            Otherwise, see if the next processor in the old list is in the new list. if not,
1710                            its been deleted. If its there, append it to the temp list.
1711                         */
1712
1713                         if (oiter == _processors.end()) {
1714
1715                                 /* no more elements in the old list, so just stick the rest of
1716                                    the new order onto the temp list.
1717                                 */
1718
1719                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1720                                 while (niter != new_order.end()) {
1721                                         ++niter;
1722                                 }
1723                                 break;
1724
1725                         } else {
1726
1727                                 if (!(*oiter)->display_to_user()) {
1728
1729                                         as_it_will_be.push_back (*oiter);
1730
1731                                 } else {
1732
1733                                         /* visible processor: check that its in the new order */
1734
1735                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1736                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1737                                         } else {
1738                                                 /* ignore this one, and add the next item from the new order instead */
1739                                                 as_it_will_be.push_back (*niter);
1740                                                 ++niter;
1741                                         }
1742                                 }
1743
1744                                 /* now remove from old order - its taken care of no matter what */
1745                                 oiter = _processors.erase (oiter);
1746                         }
1747
1748                 }
1749
1750                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1751
1752                 {
1753                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1754
1755                         if (configure_processors_unlocked (err)) {
1756                                 pstate.restore ();
1757                                 return -1;
1758                         }
1759                 }
1760         }
1761
1762         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1763         set_processor_positions ();
1764
1765         return 0;
1766 }
1767
1768 XMLNode&
1769 Route::get_state()
1770 {
1771         return state(true);
1772 }
1773
1774 XMLNode&
1775 Route::get_template()
1776 {
1777         return state(false);
1778 }
1779
1780 XMLNode&
1781 Route::state(bool full_state)
1782 {
1783         XMLNode *node = new XMLNode("Route");
1784         ProcessorList::iterator i;
1785         char buf[32];
1786
1787         id().print (buf, sizeof (buf));
1788         node->add_property("id", buf);
1789         node->add_property ("name", _name);
1790         node->add_property("default-type", _default_type.to_string());
1791
1792         if (_flags) {
1793                 node->add_property("flags", enum_2_string (_flags));
1794         }
1795
1796         node->add_property("active", _active?"yes":"no");
1797         string p;
1798         boost::to_string (_phase_invert, p);
1799         node->add_property("phase-invert", p);
1800         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1801         node->add_property("meter-point", enum_2_string (_meter_point));
1802
1803         if (_route_group) {
1804                 node->add_property("route-group", _route_group->name());
1805         }
1806
1807         string order_string;
1808         OrderKeys::iterator x = order_keys.begin();
1809
1810         while (x != order_keys.end()) {
1811                 order_string += string ((*x).first);
1812                 order_string += '=';
1813                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1814                 order_string += buf;
1815
1816                 ++x;
1817
1818                 if (x == order_keys.end()) {
1819                         break;
1820                 }
1821
1822                 order_string += ':';
1823         }
1824         node->add_property ("order-keys", order_string);
1825         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1826         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1827         node->add_property ("soloed-by-upstream", buf);
1828         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1829         node->add_property ("soloed-by-downstream", buf);
1830         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1831         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1832
1833         node->add_child_nocopy (_input->state (full_state));
1834         node->add_child_nocopy (_output->state (full_state));
1835         node->add_child_nocopy (_solo_control->get_state ());
1836         node->add_child_nocopy (_mute_control->get_state ());
1837         node->add_child_nocopy (_mute_master->get_state ());
1838
1839         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1840         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1841         remote_control_node->add_property (X_("id"), buf);
1842         node->add_child_nocopy (*remote_control_node);
1843
1844         if (_comment.length()) {
1845                 XMLNode *cmt = node->add_child ("Comment");
1846                 cmt->add_content (_comment);
1847         }
1848
1849         node->add_child_nocopy (_pannable->state (full_state));
1850
1851         for (i = _processors.begin(); i != _processors.end(); ++i) {
1852                 node->add_child_nocopy((*i)->state (full_state));
1853         }
1854
1855         if (_extra_xml){
1856                 node->add_child_copy (*_extra_xml);
1857         }
1858
1859         return *node;
1860 }
1861
1862 int
1863 Route::set_state (const XMLNode& node, int version)
1864 {
1865         return _set_state (node, version, true);
1866 }
1867
1868 int
1869 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1870 {
1871         if (version < 3000) {
1872                 return _set_state_2X (node, version);
1873         }
1874
1875         XMLNodeList nlist;
1876         XMLNodeConstIterator niter;
1877         XMLNode *child;
1878         const XMLProperty *prop;
1879
1880         if (node.name() != "Route"){
1881                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1882                 return -1;
1883         }
1884
1885         if ((prop = node.property (X_("name"))) != 0) {
1886                 Route::set_name (prop->value());
1887         }
1888
1889         if ((prop = node.property ("id")) != 0) {
1890                 _id = prop->value ();
1891         }
1892
1893         if ((prop = node.property (X_("flags"))) != 0) {
1894                 _flags = Flag (string_2_enum (prop->value(), _flags));
1895         } else {
1896                 _flags = Flag (0);
1897         }
1898
1899         if (is_master() || is_monitor() || is_hidden()) {
1900                 _mute_master->set_solo_ignore (true);
1901         }
1902
1903         /* add all processors (except amp, which is always present) */
1904
1905         nlist = node.children();
1906         XMLNode processor_state (X_("processor_state"));
1907
1908         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1909
1910                 child = *niter;
1911
1912                 if (child->name() == IO::state_node_name) {
1913                         if ((prop = child->property (X_("direction"))) == 0) {
1914                                 continue;
1915                         }
1916
1917                         if (prop->value() == "Input") {
1918                                 _input->set_state (*child, version);
1919                         } else if (prop->value() == "Output") {
1920                                 _output->set_state (*child, version);
1921                         }
1922                 }
1923
1924                 if (child->name() == X_("Processor")) {
1925                         processor_state.add_child_copy (*child);
1926                 }
1927
1928
1929                 if (child->name() == X_("Pannable")) {
1930                         _pannable->set_state (*child, version);
1931                 }
1932         }
1933
1934         set_processor_state (processor_state);
1935
1936         if ((prop = node.property ("self-solo")) != 0) {
1937                 set_self_solo (string_is_affirmative (prop->value()));
1938         }
1939
1940         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1941                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1942                 mod_solo_by_others_upstream (atoi (prop->value()));
1943         }
1944
1945         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1946                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1947                 mod_solo_by_others_downstream (atoi (prop->value()));
1948         }
1949
1950         if ((prop = node.property ("solo-isolated")) != 0) {
1951                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1952         }
1953
1954         if ((prop = node.property ("solo-safe")) != 0) {
1955                 set_solo_safe (string_is_affirmative (prop->value()), this);
1956         }
1957
1958         if ((prop = node.property (X_("phase-invert"))) != 0) {
1959                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1960         }
1961
1962         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1963                 set_denormal_protection (string_is_affirmative (prop->value()));
1964         }
1965
1966         if ((prop = node.property (X_("active"))) != 0) {
1967                 bool yn = string_is_affirmative (prop->value());
1968                 _active = !yn; // force switch
1969                 set_active (yn, this);
1970         }
1971
1972         if ((prop = node.property (X_("meter-point"))) != 0) {
1973                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1974                 set_meter_point (mp, true);
1975                 if (_meter) {
1976                         _meter->set_display_to_user (_meter_point == MeterCustom);
1977                 }
1978         }
1979
1980         if ((prop = node.property (X_("order-keys"))) != 0) {
1981
1982                 int32_t n;
1983
1984                 string::size_type colon, equal;
1985                 string remaining = prop->value();
1986
1987                 while (remaining.length()) {
1988
1989                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1990                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1991                                       << endmsg;
1992                         } else {
1993                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
1994                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1995                                               << endmsg;
1996                                 } else {
1997                                         set_order_key (remaining.substr (0, equal), n);
1998                                 }
1999                         }
2000
2001                         colon = remaining.find_first_of (':');
2002
2003                         if (colon != string::npos) {
2004                                 remaining = remaining.substr (colon+1);
2005                         } else {
2006                                 break;
2007                         }
2008                 }
2009         }
2010
2011         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2012                 child = *niter;
2013
2014                 if (child->name() == X_("Comment")) {
2015
2016                         /* XXX this is a terrible API design in libxml++ */
2017
2018                         XMLNode *cmt = *(child->children().begin());
2019                         _comment = cmt->content();
2020
2021                 } else if (child->name() == X_("Extra")) {
2022
2023                         _extra_xml = new XMLNode (*child);
2024
2025                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2026                         if (prop->value() == "solo") {
2027                                 _solo_control->set_state (*child, version);
2028                         }
2029
2030                 } else if (child->name() == X_("RemoteControl")) {
2031                         if ((prop = child->property (X_("id"))) != 0) {
2032                                 int32_t x;
2033                                 sscanf (prop->value().c_str(), "%d", &x);
2034                                 set_remote_control_id (x);
2035                         }
2036
2037                 } else if (child->name() == X_("MuteMaster")) {
2038                         _mute_master->set_state (*child, version);
2039                 }
2040         }
2041
2042         return 0;
2043 }
2044
2045 int
2046 Route::_set_state_2X (const XMLNode& node, int version)
2047 {
2048         XMLNodeList nlist;
2049         XMLNodeConstIterator niter;
2050         XMLNode *child;
2051         const XMLProperty *prop;
2052
2053         /* 2X things which still remain to be handled:
2054          * default-type
2055          * automation
2056          * controlouts
2057          */
2058
2059         if (node.name() != "Route") {
2060                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2061                 return -1;
2062         }
2063
2064         if ((prop = node.property (X_("flags"))) != 0) {
2065                 _flags = Flag (string_2_enum (prop->value(), _flags));
2066         } else {
2067                 _flags = Flag (0);
2068         }
2069
2070         if ((prop = node.property (X_("phase-invert"))) != 0) {
2071                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2072                 if (string_is_affirmative (prop->value ())) {
2073                         p.set ();
2074                 }
2075                 set_phase_invert (p);
2076         }
2077
2078         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2079                 set_denormal_protection (string_is_affirmative (prop->value()));
2080         }
2081
2082         if ((prop = node.property (X_("soloed"))) != 0) {
2083                 bool yn = string_is_affirmative (prop->value());
2084
2085                 /* XXX force reset of solo status */
2086
2087                 set_solo (yn, this);
2088         }
2089
2090         if ((prop = node.property (X_("muted"))) != 0) {
2091
2092                 bool first = true;
2093                 bool muted = string_is_affirmative (prop->value());
2094
2095                 if (muted){
2096
2097                         string mute_point;
2098
2099                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2100
2101                                 if (string_is_affirmative (prop->value())){
2102                                         mute_point = mute_point + "PreFader";
2103                                         first = false;
2104                                 }
2105                         }
2106
2107                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2108
2109                                 if (string_is_affirmative (prop->value())){
2110
2111                                         if (!first) {
2112                                                 mute_point = mute_point + ",";
2113                                         }
2114
2115                                         mute_point = mute_point + "PostFader";
2116                                         first = false;
2117                                 }
2118                         }
2119
2120                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2121
2122                                 if (string_is_affirmative (prop->value())){
2123
2124                                         if (!first) {
2125                                                 mute_point = mute_point + ",";
2126                                         }
2127
2128                                         mute_point = mute_point + "Listen";
2129                                         first = false;
2130                                 }
2131                         }
2132
2133                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2134
2135                                 if (string_is_affirmative (prop->value())){
2136
2137                                         if (!first) {
2138                                                 mute_point = mute_point + ",";
2139                                         }
2140
2141                                         mute_point = mute_point + "Main";
2142                                 }
2143                         }
2144
2145                         _mute_master->set_mute_points (mute_point);
2146                 }
2147         }
2148
2149         if ((prop = node.property (X_("meter-point"))) != 0) {
2150                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2151         }
2152
2153         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2154            don't mean the same thing.
2155         */
2156
2157         if ((prop = node.property (X_("order-keys"))) != 0) {
2158
2159                 int32_t n;
2160
2161                 string::size_type colon, equal;
2162                 string remaining = prop->value();
2163
2164                 while (remaining.length()) {
2165
2166                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2167                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2168                                         << endmsg;
2169                         } else {
2170                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2171                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2172                                                 << endmsg;
2173                                 } else {
2174                                         set_order_key (remaining.substr (0, equal), n);
2175                                 }
2176                         }
2177
2178                         colon = remaining.find_first_of (':');
2179
2180                         if (colon != string::npos) {
2181                                 remaining = remaining.substr (colon+1);
2182                         } else {
2183                                 break;
2184                         }
2185                 }
2186         }
2187
2188         /* IOs */
2189
2190         nlist = node.children ();
2191         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2192
2193                 child = *niter;
2194
2195                 if (child->name() == IO::state_node_name) {
2196
2197                         /* there is a note in IO::set_state_2X() about why we have to call
2198                            this directly.
2199                            */
2200
2201                         _input->set_state_2X (*child, version, true);
2202                         _output->set_state_2X (*child, version, false);
2203
2204                         if ((prop = child->property (X_("name"))) != 0) {
2205                                 Route::set_name (prop->value ());
2206                         }
2207
2208                         if ((prop = child->property (X_("id"))) != 0) {
2209                                 _id = prop->value ();
2210                         }
2211
2212                         if ((prop = child->property (X_("active"))) != 0) {
2213                                 bool yn = string_is_affirmative (prop->value());
2214                                 _active = !yn; // force switch
2215                                 set_active (yn, this);
2216                         }
2217
2218                         if ((prop = child->property (X_("gain"))) != 0) {
2219                                 gain_t val;
2220
2221                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2222                                         _amp->gain_control()->set_value (val);
2223                                 }
2224                         }
2225
2226                         /* Set up Panners in the IO */
2227                         XMLNodeList io_nlist = child->children ();
2228
2229                         XMLNodeConstIterator io_niter;
2230                         XMLNode *io_child;
2231
2232                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2233
2234                                 io_child = *io_niter;
2235
2236                                 if (io_child->name() == X_("Panner")) {
2237                                         _main_outs->panner_shell()->set_state(*io_child, version);
2238                                 } else if (io_child->name() == X_("Automation")) {
2239                                         /* IO's automation is for the fader */
2240                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2241                                 }
2242                         }
2243                 }
2244         }
2245
2246         XMLNodeList redirect_nodes;
2247
2248         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2249
2250                 child = *niter;
2251
2252                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2253                         redirect_nodes.push_back(child);
2254                 }
2255
2256         }
2257
2258         set_processor_state_2X (redirect_nodes, version);
2259
2260         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2261                 child = *niter;
2262
2263                 if (child->name() == X_("Comment")) {
2264
2265                         /* XXX this is a terrible API design in libxml++ */
2266
2267                         XMLNode *cmt = *(child->children().begin());
2268                         _comment = cmt->content();
2269
2270                 } else if (child->name() == X_("extra")) {
2271
2272                         _extra_xml = new XMLNode (*child);
2273
2274                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2275                         if (prop->value() == X_("solo")) {
2276                                 _solo_control->set_state (*child, version);
2277                         } else if (prop->value() == X_("mute")) {
2278                                 _mute_control->set_state (*child, version);
2279                         }
2280
2281                 } else if (child->name() == X_("RemoteControl")) {
2282                         if ((prop = child->property (X_("id"))) != 0) {
2283                                 int32_t x;
2284                                 sscanf (prop->value().c_str(), "%d", &x);
2285                                 set_remote_control_id (x);
2286                         }
2287
2288                 }
2289         }
2290
2291         return 0;
2292 }
2293
2294 XMLNode&
2295 Route::get_processor_state ()
2296 {
2297         XMLNode* root = new XMLNode (X_("redirects"));
2298         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2299                 root->add_child_nocopy ((*i)->state (true));
2300         }
2301
2302         return *root;
2303 }
2304
2305 void
2306 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2307 {
2308         /* We don't bother removing existing processors not in nList, as this
2309            method will only be called when creating a Route from scratch, not
2310            for undo purposes.  Just put processors in at the appropriate place
2311            in the list.
2312         */
2313
2314         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2315                 add_processor_from_xml_2X (**i, version);
2316         }
2317 }
2318
2319 void
2320 Route::set_processor_state (const XMLNode& node)
2321 {
2322         const XMLNodeList &nlist = node.children();
2323         XMLNodeConstIterator niter;
2324         ProcessorList new_order;
2325         bool must_configure = false;
2326
2327         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2328
2329                 XMLProperty* prop = (*niter)->property ("type");
2330
2331                 if (prop->value() == "amp") {
2332                         _amp->set_state (**niter, Stateful::current_state_version);
2333                         new_order.push_back (_amp);
2334                 } else if (prop->value() == "meter") {
2335                         _meter->set_state (**niter, Stateful::current_state_version);
2336                 } else if (prop->value() == "main-outs") {
2337                         _main_outs->set_state (**niter, Stateful::current_state_version);
2338                 } else if (prop->value() == "intreturn") {
2339                         if (!_intreturn) {
2340                                 _intreturn.reset (new InternalReturn (_session));
2341                                 must_configure = true;
2342                         }
2343                         _intreturn->set_state (**niter, Stateful::current_state_version);
2344                 } else if (is_monitor() && prop->value() == "monitor") {
2345                         if (!_monitor_control) {
2346                                 _monitor_control.reset (new MonitorProcessor (_session));
2347                                 must_configure = true;
2348                         }
2349                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2350                 } else {
2351                         ProcessorList::iterator o;
2352
2353                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2354                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2355                                 if (id_prop && (*o)->id() == id_prop->value()) {
2356                                         (*o)->set_state (**niter, Stateful::current_state_version);
2357                                         new_order.push_back (*o);
2358                                         break;
2359                                 }
2360                         }
2361
2362                         // If the processor (*niter) is not on the route then create it
2363
2364                         if (o == _processors.end()) {
2365
2366                                 boost::shared_ptr<Processor> processor;
2367
2368                                 if (prop->value() == "intsend") {
2369
2370                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2371                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2372                                            prop->value() == "lv2" ||
2373                                            prop->value() == "vst" ||
2374                                            prop->value() == "audiounit") {
2375
2376                                         processor.reset (new PluginInsert(_session));
2377
2378                                 } else if (prop->value() == "port") {
2379
2380                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2381
2382                                 } else if (prop->value() == "send") {
2383
2384                                         processor.reset (new Send (_session, _pannable, _mute_master));
2385
2386                                 } else {
2387                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2388                                         continue;
2389                                 }
2390
2391                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2392                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2393                                         processor.reset (new UnknownProcessor (_session, **niter));
2394                                 }
2395
2396                                 /* we have to note the monitor send here, otherwise a new one will be created
2397                                    and the state of this one will be lost.
2398                                 */
2399                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2400                                 if (isend && isend->role() == Delivery::Listen) {
2401                                         _monitor_send = isend;
2402                                 }
2403
2404                                 /* it doesn't matter if invisible processors are added here, as they
2405                                    will be sorted out by setup_invisible_processors () shortly.
2406                                 */
2407
2408                                 new_order.push_back (processor);
2409                                 must_configure = true;
2410                         }
2411                 }
2412         }
2413
2414         {
2415                 Glib::RWLock::WriterLock lm (_processor_lock);
2416                 _processors = new_order;
2417                 if (must_configure) {
2418                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2419                         configure_processors_unlocked (0);
2420                 }
2421         }
2422
2423         processors_changed (RouteProcessorChange ());
2424         set_processor_positions ();
2425 }
2426
2427 void
2428 Route::curve_reallocate ()
2429 {
2430 //      _gain_automation_curve.finish_resize ();
2431 //      _pan_automation_curve.finish_resize ();
2432 }
2433
2434 void
2435 Route::silence (framecnt_t nframes)
2436 {
2437         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2438         if (!lm.locked()) {
2439                 return;
2440         }
2441
2442         silence_unlocked (nframes);
2443 }
2444
2445 void
2446 Route::silence_unlocked (framecnt_t nframes)
2447 {
2448         /* Must be called with the processor lock held */
2449
2450         if (!_silent) {
2451
2452                 _output->silence (nframes);
2453
2454                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2455                         boost::shared_ptr<PluginInsert> pi;
2456
2457                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2458                                 // skip plugins, they don't need anything when we're not active
2459                                 continue;
2460                         }
2461
2462                         (*i)->silence (nframes);
2463                 }
2464
2465                 if (nframes == _session.get_block_size()) {
2466                         // _silent = true;
2467                 }
2468         }
2469 }
2470
2471 void
2472 Route::add_internal_return ()
2473 {
2474         if (!_intreturn) {
2475                 _intreturn.reset (new InternalReturn (_session));
2476                 add_processor (_intreturn, PreFader);
2477         }
2478 }
2479
2480 void
2481 Route::add_send_to_internal_return (InternalSend* send)
2482 {
2483         Glib::RWLock::ReaderLock rm (_processor_lock);
2484
2485         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2486                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2487
2488                 if (d) {
2489                         return d->add_send (send);
2490                 }
2491         }
2492 }
2493
2494 void
2495 Route::remove_send_from_internal_return (InternalSend* send)
2496 {
2497         Glib::RWLock::ReaderLock rm (_processor_lock);
2498
2499         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2500                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2501
2502                 if (d) {
2503                         return d->remove_send (send);
2504                 }
2505         }
2506 }
2507
2508 /** Add a monitor send (if we don't already have one) but don't activate it */
2509 int
2510 Route::listen_via_monitor ()
2511 {
2512         /* master never sends to control outs */
2513         assert (!is_master ());
2514
2515         /* make sure we have one */
2516         if (!_monitor_send) {
2517                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2518                 _monitor_send->set_display_to_user (false);
2519         }
2520
2521         /* set it up */
2522         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2523         configure_processors (0);
2524
2525         return 0;
2526 }
2527
2528 /** Add an internal send to a route.
2529  *  @param route route to send to.
2530  *  @param placement placement for the send.
2531  */
2532 int
2533 Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
2534 {
2535         assert (route != _session.monitor_out ());
2536
2537         {
2538                 Glib::RWLock::ReaderLock rm (_processor_lock);
2539
2540                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2541
2542                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2543
2544                         if (d && d->target_route() == route) {
2545                                 /* already listening via the specified IO: do nothing */
2546                                 return 0;
2547                         }
2548                 }
2549         }
2550
2551         try {
2552                 boost::shared_ptr<InternalSend> listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2553                 add_processor (listener, placement);
2554
2555         } catch (failed_constructor& err) {
2556                 return -1;
2557         }
2558
2559         return 0;
2560 }
2561
2562 void
2563 Route::drop_listen (boost::shared_ptr<Route> route)
2564 {
2565         ProcessorStreams err;
2566         ProcessorList::iterator tmp;
2567
2568         Glib::RWLock::ReaderLock rl(_processor_lock);
2569         rl.acquire ();
2570
2571   again:
2572         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2573
2574                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2575
2576                 if (d && d->target_route() == route) {
2577                         rl.release ();
2578                         remove_processor (*x, &err);
2579                         rl.acquire ();
2580
2581                         /* list could have been demolished while we dropped the lock
2582                            so start over.
2583                         */
2584
2585                         goto again;
2586                 }
2587         }
2588
2589         rl.release ();
2590
2591         if (route == _session.monitor_out()) {
2592                 _monitor_send.reset ();
2593         }
2594 }
2595
2596 void
2597 Route::set_comment (string cmt, void *src)
2598 {
2599         _comment = cmt;
2600         comment_changed (src);
2601         _session.set_dirty ();
2602 }
2603
2604 bool
2605 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2606 {
2607         FeedRecord fr (other, via_sends_only);
2608
2609         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2610
2611         if (!result.second) {
2612
2613                 /* already a record for "other" - make sure sends-only information is correct */
2614                 if (!via_sends_only && result.first->sends_only) {
2615                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2616                         frp->sends_only = false;
2617                 }
2618         }
2619
2620         return result.second;
2621 }
2622
2623 void
2624 Route::clear_fed_by ()
2625 {
2626         _fed_by.clear ();
2627 }
2628
2629 bool
2630 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2631 {
2632         const FedBy& fed_by (other->fed_by());
2633
2634         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2635                 boost::shared_ptr<Route> sr = f->r.lock();
2636
2637                 if (sr && (sr.get() == this)) {
2638
2639                         if (via_sends_only) {
2640                                 *via_sends_only = f->sends_only;
2641                         }
2642
2643                         return true;
2644                 }
2645         }
2646
2647         return false;
2648 }
2649
2650 bool
2651 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2652 {
2653         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2654
2655         if (_output->connected_to (other->input())) {
2656                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2657                 if (only_send) {
2658                         *only_send = false;
2659                 }
2660
2661                 return true;
2662         }
2663
2664
2665         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2666
2667                 boost::shared_ptr<IOProcessor> iop;
2668
2669                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2670                         if (iop->feeds (other)) {
2671                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2672                                 if (only_send) {
2673                                         *only_send = true;
2674                                 }
2675                                 return true;
2676                         } else {
2677                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2678                         }
2679                 } else {
2680                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2681                 }
2682
2683         }
2684
2685         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2686         return false;
2687 }
2688
2689 /** Called from the (non-realtime) butler thread when the transport is stopped */
2690 void
2691 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2692 {
2693         framepos_t now = _session.transport_frame();
2694
2695         {
2696                 Glib::RWLock::ReaderLock lm (_processor_lock);
2697
2698                 if (!did_locate) {
2699                         automation_snapshot (now, true);
2700                 }
2701
2702                 Automatable::transport_stopped (now);
2703
2704                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2705
2706                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2707                                 (*i)->flush ();
2708                         }
2709
2710                         (*i)->transport_stopped (now);
2711                 }
2712         }
2713
2714         _roll_delay = _initial_delay;
2715 }
2716
2717 /** Called with the process lock held if change contains ConfigurationChanged */
2718 void
2719 Route::input_change_handler (IOChange change, void * /*src*/)
2720 {
2721         if ((change.type & IOChange::ConfigurationChanged)) {
2722                 configure_processors (0);
2723                 _phase_invert.resize (_input->n_ports().n_audio ());
2724                 io_changed (); /* EMIT SIGNAL */
2725         }
2726 }
2727
2728 /** Called with the process lock held if change contains ConfigurationChanged */
2729 void
2730 Route::output_change_handler (IOChange change, void * /*src*/)
2731 {
2732         if ((change.type & IOChange::ConfigurationChanged)) {
2733
2734                 /* XXX resize all listeners to match _main_outs? */
2735
2736                 /* Auto-connect newly-created outputs, unless we're auto-connecting to master
2737                    and we are master (as an auto-connect in this situation would cause a
2738                    feedback loop)
2739                 */
2740                 AutoConnectOption ac = Config->get_output_auto_connect ();
2741                 if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
2742
2743                         ChanCount start = change.before;
2744
2745                         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
2746                                 if (change.before.get(*i) < change.after.get(*i)) {
2747                                         /* the existing ChanCounts don't matter for this call as they are only
2748                                            to do with matching input and output indices, and we are only changing
2749                                            outputs here.
2750                                         */
2751                                         ChanCount dummy;
2752
2753                                         /* only auto-connect the newly-created outputs, not the ones that were
2754                                            already there
2755                                         */
2756                                         start.set (*i, start.get (*i) + 1);
2757
2758                                         _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
2759                                 }
2760                         }
2761                 }
2762
2763                 // configure_processors (0);
2764         }
2765 }
2766
2767 uint32_t
2768 Route::pans_required () const
2769 {
2770         if (n_outputs().n_audio() < 2) {
2771                 return 0;
2772         }
2773
2774         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2775 }
2776
2777 int
2778 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2779                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2780 {
2781         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2782         if (!lm.locked()) {
2783                 return 0;
2784         }
2785
2786         if (n_outputs().n_total() == 0) {
2787                 return 0;
2788         }
2789
2790         if (!_active || n_inputs() == ChanCount::ZERO)  {
2791                 silence_unlocked (nframes);
2792                 return 0;
2793         }
2794         if (session_state_changing) {
2795                 if (_session.transport_speed() != 0.0f) {
2796                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2797                            so we cannot use them. Be silent till this is over.
2798
2799                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2800                         */
2801                         silence_unlocked (nframes);
2802                         return 0;
2803                 }
2804                 /* we're really not rolling, so we're either delivery silence or actually
2805                    monitoring, both of which are safe to do while session_state_changing is true.
2806                 */
2807         }
2808
2809         _amp->apply_gain_automation (false);
2810         passthru (start_frame, end_frame, nframes, 0);
2811
2812         return 0;
2813 }
2814
2815 framecnt_t
2816 Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
2817 {
2818         if (_roll_delay > nframes) {
2819
2820                 _roll_delay -= nframes;
2821                 silence_unlocked (nframes);
2822                 /* transport frame is not legal for caller to use */
2823                 return 0;
2824
2825         } else if (_roll_delay > 0) {
2826
2827                 nframes -= _roll_delay;
2828                 silence_unlocked (_roll_delay);
2829                 /* we've written _roll_delay of samples into the
2830                    output ports, so make a note of that for
2831                    future reference.
2832                 */
2833                 _main_outs->increment_output_offset (_roll_delay);
2834                 transport_frame += _roll_delay;
2835
2836                 _roll_delay = 0;
2837         }
2838
2839         return nframes;
2840 }
2841
2842 int
2843 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2844              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2845 {
2846         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2847         if (!lm.locked()) {
2848                 return 0;
2849         }
2850
2851         automation_snapshot (_session.transport_frame(), false);
2852
2853         if (n_outputs().n_total() == 0) {
2854                 return 0;
2855         }
2856
2857         if (!_active || n_inputs().n_total() == 0) {
2858                 silence_unlocked (nframes);
2859                 return 0;
2860         }
2861
2862         framecnt_t unused = 0;
2863
2864         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2865                 return 0;
2866         }
2867
2868         _silent = false;
2869
2870         passthru (start_frame, end_frame, nframes, declick);
2871
2872         return 0;
2873 }
2874
2875 int
2876 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2877                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2878 {
2879         silence (nframes);
2880         return 0;
2881 }
2882
2883 void
2884 Route::toggle_monitor_input ()
2885 {
2886         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2887                 i->ensure_monitor_input( ! i->monitoring_input());
2888         }
2889 }
2890
2891 bool
2892 Route::has_external_redirects () const
2893 {
2894         // FIXME: what about sends? - they don't return a signal back to ardour?
2895
2896         boost::shared_ptr<const PortInsert> pi;
2897
2898         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2899
2900                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2901
2902                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2903
2904                                 string port_name = port->name();
2905                                 string client_name = port_name.substr (0, port_name.find(':'));
2906
2907                                 /* only say "yes" if the redirect is actually in use */
2908
2909                                 if (client_name != "ardour" && pi->active()) {
2910                                         return true;
2911                                 }
2912                         }
2913                 }
2914         }
2915
2916         return false;
2917 }
2918
2919 void
2920 Route::flush_processors ()
2921 {
2922         /* XXX shouldn't really try to take this lock, since
2923            this is called from the RT audio thread.
2924         */
2925
2926         Glib::RWLock::ReaderLock lm (_processor_lock);
2927
2928         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2929                 (*i)->flush ();
2930         }
2931 }
2932
2933 void
2934 Route::set_meter_point (MeterPoint p, bool force)
2935 {
2936         /* CAN BE CALLED FROM PROCESS CONTEXT */
2937
2938         if (_meter_point == p && !force) {
2939                 return;
2940         }
2941
2942         _meter_point = p;
2943
2944         bool meter_was_visible_to_user = _meter->display_to_user ();
2945
2946         {
2947                 Glib::RWLock::WriterLock lm (_processor_lock);
2948
2949                 if (_meter_point != MeterCustom) {
2950
2951                         _meter->set_display_to_user (false);
2952
2953                         setup_invisible_processors ();
2954
2955                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2956
2957                         ChanCount m_in;
2958
2959                         if (loc == _processors.begin()) {
2960                                 m_in = _input->n_ports();
2961                         } else {
2962                                 ProcessorList::iterator before = loc;
2963                                 --before;
2964                                 m_in = (*before)->output_streams ();
2965                         }
2966
2967                         _meter->reflect_inputs (m_in);
2968
2969                         /* we do not need to reconfigure the processors, because the meter
2970                            (a) is always ready to handle processor_max_streams
2971                            (b) is always an N-in/N-out processor, and thus moving
2972                            it doesn't require any changes to the other processors.
2973                         */
2974
2975                 } else {
2976
2977                         // just make it visible and let the user move it
2978
2979                         _meter->set_display_to_user (true);
2980                 }
2981         }
2982
2983         meter_change (); /* EMIT SIGNAL */
2984
2985         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2986
2987         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2988 }
2989
2990 void
2991 Route::listen_position_changed ()
2992 {
2993         {
2994                 Glib::RWLock::WriterLock lm (_processor_lock);
2995                 ProcessorState pstate (this);
2996
2997                 {
2998                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2999
3000                         if (configure_processors_unlocked (0)) {
3001                                 pstate.restore ();
3002                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
3003                                 return;
3004                         }
3005                 }
3006         }
3007
3008         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3009         _session.set_dirty ();
3010 }
3011
3012 boost::shared_ptr<CapturingProcessor>
3013 Route::add_export_point()
3014 {
3015         if (!_capturing_processor) {
3016
3017                 _capturing_processor.reset (new CapturingProcessor (_session));
3018                 _capturing_processor->activate ();
3019
3020                 {
3021                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3022                         configure_processors (0);
3023                 }
3024
3025         }
3026
3027         return _capturing_processor;
3028 }
3029
3030 framecnt_t
3031 Route::update_total_latency ()
3032 {
3033         framecnt_t old = _output->effective_latency();
3034         framecnt_t own_latency = _output->user_latency();
3035
3036         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3037                 if ((*i)->active ()) {
3038                         own_latency += (*i)->signal_latency ();
3039                 }
3040         }
3041
3042         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
3043
3044         _output->set_port_latency (own_latency);
3045
3046         if (_output->user_latency() == 0) {
3047
3048                 /* this (virtual) function is used for pure Routes,
3049                    not derived classes like AudioTrack.  this means
3050                    that the data processed here comes from an input
3051                    port, not prerecorded material, and therefore we
3052                    have to take into account any input latency.
3053                 */
3054
3055                 own_latency += _input->signal_latency ();
3056         }
3057
3058         if (old != own_latency) {
3059                 _output->set_latency_delay (own_latency);
3060                 signal_latency_changed (); /* EMIT SIGNAL */
3061         }
3062
3063         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
3064
3065         return _output->effective_latency ();
3066 }
3067
3068 void
3069 Route::set_user_latency (framecnt_t nframes)
3070 {
3071         _output->set_user_latency (nframes);
3072         _session.update_latency_compensation (false, false);
3073 }
3074
3075 void
3076 Route::set_latency_delay (framecnt_t longest_session_latency)
3077 {
3078         framecnt_t old = _initial_delay;
3079
3080         if (_output->effective_latency() < longest_session_latency) {
3081                 _initial_delay = longest_session_latency - _output->effective_latency();
3082         } else {
3083                 _initial_delay = 0;
3084         }
3085
3086         if (_initial_delay != old) {
3087                 initial_delay_changed (); /* EMIT SIGNAL */
3088         }
3089
3090         if (_session.transport_stopped()) {
3091                 _roll_delay = _initial_delay;
3092         }
3093 }
3094
3095 void
3096 Route::automation_snapshot (framepos_t now, bool force)
3097 {
3098         _pannable->automation_snapshot (now, force);
3099         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3100                 (*i)->automation_snapshot (now, force);
3101         }
3102 }
3103
3104 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3105         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3106                              boost::shared_ptr<AutomationList>(), name)
3107         , _route (r)
3108 {
3109         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3110         set_list (gl);
3111 }
3112
3113 void
3114 Route::SoloControllable::set_value (double val)
3115 {
3116         bool bval = ((val >= 0.5f) ? true: false);
3117
3118         boost::shared_ptr<RouteList> rl (new RouteList);
3119
3120         boost::shared_ptr<Route> r = _route.lock ();
3121         if (!r) {
3122                 return;
3123         }
3124
3125         rl->push_back (r);
3126
3127         if (Config->get_solo_control_is_listen_control()) {
3128                 _session.set_listen (rl, bval);
3129         } else {
3130                 _session.set_solo (rl, bval);
3131         }
3132 }
3133
3134 double
3135 Route::SoloControllable::get_value () const
3136 {
3137         boost::shared_ptr<Route> r = _route.lock ();
3138         if (!r) {
3139                 return 0;
3140         }
3141
3142         if (Config->get_solo_control_is_listen_control()) {
3143                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3144         } else {
3145                 return r->self_soloed() ? 1.0f : 0.0f;
3146         }
3147 }
3148
3149 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3150         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3151                              boost::shared_ptr<AutomationList>(), name)
3152         , _route (r)
3153 {
3154         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3155         set_list (gl);
3156 }
3157
3158 void
3159 Route::MuteControllable::set_value (double val)
3160 {
3161         bool bval = ((val >= 0.5f) ? true: false);
3162
3163         boost::shared_ptr<RouteList> rl (new RouteList);
3164
3165         boost::shared_ptr<Route> r = _route.lock ();
3166         if (!r) {
3167                 return;
3168         }
3169
3170         rl->push_back (r);
3171         _session.set_mute (rl, bval);
3172 }
3173
3174 double
3175 Route::MuteControllable::get_value () const
3176 {
3177         boost::shared_ptr<Route> r = _route.lock ();
3178         if (!r) {
3179                 return 0;
3180         }
3181
3182         return r->muted() ? 1.0f : 0.0f;
3183 }
3184
3185 void
3186 Route::set_block_size (pframes_t nframes)
3187 {
3188         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3189                 (*i)->set_block_size (nframes);
3190         }
3191
3192         _session.ensure_buffers (n_process_buffers ());
3193 }
3194
3195 void
3196 Route::protect_automation ()
3197 {
3198         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3199                 (*i)->protect_automation();
3200 }
3201
3202 void
3203 Route::set_pending_declick (int declick)
3204 {
3205         if (_declickable) {
3206                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3207                 if (declick) {
3208                         _pending_declick = declick;
3209                 }
3210                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3211         } else {
3212                 _pending_declick = 0;
3213         }
3214
3215 }
3216
3217 /** Shift automation forwards from a particular place, thereby inserting time.
3218  *  Adds undo commands for any shifts that are performed.
3219  *
3220  * @param pos Position to start shifting from.
3221  * @param frames Amount to shift forwards by.
3222  */
3223
3224 void
3225 Route::shift (framepos_t pos, framecnt_t frames)
3226 {
3227         /* gain automation */
3228         {
3229                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3230
3231                 XMLNode &before = gc->alist()->get_state ();
3232                 gc->alist()->shift (pos, frames);
3233                 XMLNode &after = gc->alist()->get_state ();
3234                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3235         }
3236
3237         /* pan automation */
3238         {
3239                 ControlSet::Controls& c (_pannable->controls());
3240
3241                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3242                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3243                         if (pc) {
3244                                 boost::shared_ptr<AutomationList> al = pc->alist();
3245                                 XMLNode& before = al->get_state ();
3246                                 al->shift (pos, frames);
3247                                 XMLNode& after = al->get_state ();
3248                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3249                         }
3250                 }
3251         }
3252
3253         /* redirect automation */
3254         {
3255                 Glib::RWLock::ReaderLock lm (_processor_lock);
3256                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3257
3258                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3259
3260                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3261                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3262                                 if (ac) {
3263                                         boost::shared_ptr<AutomationList> al = ac->alist();
3264                                         XMLNode &before = al->get_state ();
3265                                         al->shift (pos, frames);
3266                                         XMLNode &after = al->get_state ();
3267                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3268                                 }
3269                         }
3270                 }
3271         }
3272 }
3273
3274
3275 int
3276 Route::save_as_template (const string& path, const string& name)
3277 {
3278         XMLNode& node (state (false));
3279         XMLTree tree;
3280
3281         IO::set_name_in_state (*node.children().front(), name);
3282
3283         tree.set_root (&node);
3284         return tree.write (path.c_str());
3285 }
3286
3287
3288 bool
3289 Route::set_name (const string& str)
3290 {
3291         bool ret;
3292         string ioproc_name;
3293         string name;
3294
3295         name = Route::ensure_track_or_route_name (str, _session);
3296         SessionObject::set_name (name);
3297
3298         ret = (_input->set_name(name) && _output->set_name(name));
3299
3300         if (ret) {
3301
3302                 Glib::RWLock::ReaderLock lm (_processor_lock);
3303
3304                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3305
3306                         /* rename all I/O processors that have inputs or outputs */
3307
3308                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3309
3310                         if (iop && (iop->output() || iop->input())) {
3311                                 if (!iop->set_name (name)) {
3312                                         ret = false;
3313                                 }
3314                         }
3315                 }
3316
3317         }
3318
3319         return ret;
3320 }
3321
3322 boost::shared_ptr<Send>
3323 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3324 {
3325         Glib::RWLock::ReaderLock lm (_processor_lock);
3326
3327         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3328                 boost::shared_ptr<InternalSend> send;
3329
3330                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3331                         if (send->target_route() == target) {
3332                                 return send;
3333                         }
3334                 }
3335         }
3336
3337         return boost::shared_ptr<Send>();
3338 }
3339
3340 /** @param c Audio channel index.
3341  *  @param yn true to invert phase, otherwise false.
3342  */
3343 void
3344 Route::set_phase_invert (uint32_t c, bool yn)
3345 {
3346         if (_phase_invert[c] != yn) {
3347                 _phase_invert[c] = yn;
3348                 phase_invert_changed (); /* EMIT SIGNAL */
3349                 _session.set_dirty ();
3350         }
3351 }
3352
3353 void
3354 Route::set_phase_invert (boost::dynamic_bitset<> p)
3355 {
3356         if (_phase_invert != p) {
3357                 _phase_invert = p;
3358                 phase_invert_changed (); /* EMIT SIGNAL */
3359                 _session.set_dirty ();
3360         }
3361 }
3362
3363 bool
3364 Route::phase_invert (uint32_t c) const
3365 {
3366         return _phase_invert[c];
3367 }
3368
3369 boost::dynamic_bitset<>
3370 Route::phase_invert () const
3371 {
3372         return _phase_invert;
3373 }
3374
3375 void
3376 Route::set_denormal_protection (bool yn)
3377 {
3378         if (_denormal_protection != yn) {
3379                 _denormal_protection = yn;
3380                 denormal_protection_changed (); /* EMIT SIGNAL */
3381         }
3382 }
3383
3384 bool
3385 Route::denormal_protection () const
3386 {
3387         return _denormal_protection;
3388 }
3389
3390 void
3391 Route::set_active (bool yn, void* src)
3392 {
3393         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3394                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3395                 return;
3396         }
3397
3398         if (_active != yn) {
3399                 _active = yn;
3400                 _input->set_active (yn);
3401                 _output->set_active (yn);
3402                 active_changed (); // EMIT SIGNAL
3403         }
3404 }
3405
3406 void
3407 Route::meter ()
3408 {
3409         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3410
3411         assert (_meter);
3412
3413         _meter->meter ();
3414
3415         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3416
3417                 boost::shared_ptr<Send> s;
3418                 boost::shared_ptr<Return> r;
3419
3420                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3421                         s->meter()->meter();
3422                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3423                         r->meter()->meter ();
3424                 }
3425         }
3426 }
3427
3428 boost::shared_ptr<Pannable>
3429 Route::pannable() const
3430 {
3431         return _pannable;
3432 }
3433
3434 boost::shared_ptr<Panner>
3435 Route::panner() const
3436 {
3437         /* may be null ! */
3438         return _main_outs->panner_shell()->panner();
3439 }
3440
3441 boost::shared_ptr<PannerShell>
3442 Route::panner_shell() const
3443 {
3444         return _main_outs->panner_shell();
3445 }
3446
3447 boost::shared_ptr<AutomationControl>
3448 Route::gain_control() const
3449 {
3450         return _amp->gain_control();
3451 }
3452
3453 boost::shared_ptr<AutomationControl>
3454 Route::get_control (const Evoral::Parameter& param)
3455 {
3456         /* either we own the control or .... */
3457
3458         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3459
3460         if (!c) {
3461
3462                 /* maybe one of our processors does or ... */
3463
3464                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3465                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3466                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3467                                 break;
3468                         }
3469                 }
3470         }
3471
3472         if (!c) {
3473
3474                 /* nobody does so we'll make a new one */
3475
3476                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3477                 add_control(c);
3478         }
3479
3480         return c;
3481 }
3482
3483 boost::shared_ptr<Processor>
3484 Route::nth_plugin (uint32_t n)
3485 {
3486         Glib::RWLock::ReaderLock lm (_processor_lock);
3487         ProcessorList::iterator i;
3488
3489         for (i = _processors.begin(); i != _processors.end(); ++i) {
3490                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3491                         if (n-- == 0) {
3492                                 return *i;
3493                         }
3494                 }
3495         }
3496
3497         return boost::shared_ptr<Processor> ();
3498 }
3499
3500 boost::shared_ptr<Processor>
3501 Route::nth_send (uint32_t n)
3502 {
3503         Glib::RWLock::ReaderLock lm (_processor_lock);
3504         ProcessorList::iterator i;
3505
3506         for (i = _processors.begin(); i != _processors.end(); ++i) {
3507                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3508                         if (n-- == 0) {
3509                                 return *i;
3510                         }
3511                 }
3512         }
3513
3514         return boost::shared_ptr<Processor> ();
3515 }
3516
3517 bool
3518 Route::has_io_processor_named (const string& name)
3519 {
3520         Glib::RWLock::ReaderLock lm (_processor_lock);
3521         ProcessorList::iterator i;
3522
3523         for (i = _processors.begin(); i != _processors.end(); ++i) {
3524                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3525                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3526                         if ((*i)->name() == name) {
3527                                 return true;
3528                         }
3529                 }
3530         }
3531
3532         return false;
3533 }
3534
3535 MuteMaster::MutePoint
3536 Route::mute_points () const
3537 {
3538         return _mute_master->mute_points ();
3539 }
3540
3541 void
3542 Route::set_processor_positions ()
3543 {
3544         Glib::RWLock::ReaderLock lm (_processor_lock);
3545
3546         bool had_amp = false;
3547         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3548                 (*i)->set_pre_fader (!had_amp);
3549                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3550                         had_amp = true;
3551                 }
3552         }
3553 }
3554
3555 /** Called when there is a proposed change to the input port count */
3556 bool
3557 Route::input_port_count_changing (ChanCount to)
3558 {
3559         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3560         if (c.empty()) {
3561                 /* The processors cannot be configured with the new input arrangement, so
3562                    block the change.
3563                 */
3564                 return true;
3565         }
3566
3567         /* The change is ok */
3568         return false;
3569 }
3570
3571 list<string>
3572 Route::unknown_processors () const
3573 {
3574         list<string> p;
3575
3576         Glib::RWLock::ReaderLock lm (_processor_lock);
3577         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3578                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3579                         p.push_back ((*i)->name ());
3580                 }
3581         }
3582
3583         return p;
3584 }
3585
3586 void
3587 Route::set_latency_ranges (bool playback) const
3588 {
3589         framecnt_t own_latency = 0;
3590
3591         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD OR
3592            LATENCY CALLBACK
3593         */
3594
3595         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3596                 if ((*i)->active ()) {
3597                         own_latency += (*i)->signal_latency ();
3598                 }
3599         }
3600
3601         if (playback) {
3602                 update_port_latencies (_input->ports (), _output->ports (), true, own_latency);
3603         } else {
3604                 update_port_latencies (_output->ports (), _input->ports (), false, own_latency);
3605         }
3606 }
3607
3608 void
3609 Route::update_port_latencies (const PortSet& operands, const PortSet& feeders, bool playback, framecnt_t our_latency) const
3610 {
3611 #ifdef HAVE_JACK_NEW_LATENCY
3612
3613         /* we assume that all our input ports feed all our output ports. its not
3614            universally true, but the alternative is way too corner-case to worry about.
3615         */
3616
3617         jack_latency_range_t all_connections;
3618
3619         all_connections.min = ~((jack_nframes_t) 0);
3620         all_connections.max = 0;
3621
3622         /* iterate over all feeder ports and determine their relevant latency, taking
3623            the maximum and minimum across all of them.
3624         */
3625
3626         for (PortSet::const_iterator p = feeders.begin(); p != feeders.end(); ++p) {
3627
3628                 jack_latency_range_t range;
3629
3630                 p->get_connected_latency_range (range, playback);
3631
3632                 all_connections.min = min (all_connections.min, range.min);
3633                 all_connections.max = max (all_connections.max, range.max);
3634         }
3635
3636         all_connections.min += our_latency;
3637         all_connections.max += our_latency;
3638
3639         for (PortSet::const_iterator p = operands.begin(); p != operands.end(); ++p) {
3640
3641                 p->set_latency_range (all_connections, playback);
3642
3643                 DEBUG_TRACE (DEBUG::Latency, string_compose ("Port %1 %5 latency range %2 .. %3 (including route latency of %4)\n",
3644                                                              p->name(),
3645                                                              all_connections.min,
3646                                                              all_connections.max,
3647                                                              our_latency,
3648                                                              (playback ? "PLAYBACK" : "CAPTURE")));
3649         }
3650 #endif
3651 }
3652
3653
3654 /** Put the invisible processors in the right place in _processors.
3655  *  Must be called with a writer lock on _processor_lock held.
3656  */
3657 void
3658 Route::setup_invisible_processors ()
3659 {
3660 #ifndef NDEBUG
3661         Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3662         assert (!lm.locked ());
3663 #endif
3664
3665         if (!_main_outs) {
3666                 /* too early to be doing this stuff */
3667                 return;
3668         }
3669
3670         /* we'll build this new list here and then use it */
3671
3672         ProcessorList new_processors;
3673
3674         /* find visible processors */
3675
3676         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3677                 if ((*i)->display_to_user ()) {
3678                         new_processors.push_back (*i);
3679                 }
3680         }
3681
3682         /* find the amp */
3683
3684         ProcessorList::iterator amp = new_processors.begin ();
3685         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3686                 ++amp;
3687         }
3688
3689         assert (amp != _processors.end ());
3690
3691         /* and the processor after the amp */
3692
3693         ProcessorList::iterator after_amp = amp;
3694         ++after_amp;
3695
3696         /* METER */
3697
3698         if (_meter) {
3699                 switch (_meter_point) {
3700                 case MeterInput:
3701                         assert (!_meter->display_to_user ());
3702                         new_processors.push_front (_meter);
3703                         break;
3704                 case MeterPreFader:
3705                         assert (!_meter->display_to_user ());
3706                         new_processors.insert (amp, _meter);
3707                         break;
3708                 case MeterPostFader:
3709                         /* do nothing here */
3710                         break;
3711                 case MeterOutput:
3712                         /* do nothing here */
3713                         break;
3714                 case MeterCustom:
3715                         /* the meter is visible, so we don't touch it here */
3716                         break;
3717                 }
3718         }
3719
3720         /* MAIN OUTS */
3721
3722         assert (_main_outs);
3723         assert (!_main_outs->display_to_user ());
3724         new_processors.push_back (_main_outs);
3725
3726         /* iterator for the main outs */
3727
3728         ProcessorList::iterator main = new_processors.end();
3729         --main;
3730
3731         /* OUTPUT METERING */
3732
3733         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3734                 assert (!_meter->display_to_user ());
3735
3736                 /* add the processor just before or just after the main outs */
3737
3738                 ProcessorList::iterator meter_point = main;
3739
3740                 if (_meter_point == MeterOutput) {
3741                         ++meter_point;
3742                 }
3743                 new_processors.insert (meter_point, _meter);
3744         }
3745
3746         /* MONITOR SEND */
3747
3748         if (_monitor_send && !is_monitor ()) {
3749                 assert (!_monitor_send->display_to_user ());
3750                 if (Config->get_solo_control_is_listen_control()) {
3751                         switch (Config->get_listen_position ()) {
3752                         case PreFaderListen:
3753                                 switch (Config->get_pfl_position ()) {
3754                                 case PFLFromBeforeProcessors:
3755                                         new_processors.push_front (_monitor_send);
3756                                         break;
3757                                 case PFLFromAfterProcessors:
3758                                         new_processors.insert (amp, _monitor_send);
3759                                         break;
3760                                 }
3761                                 break;
3762                         case AfterFaderListen:
3763                                 switch (Config->get_afl_position ()) {
3764                                 case AFLFromBeforeProcessors:
3765                                         new_processors.insert (after_amp, _monitor_send);
3766                                         break;
3767                                 case AFLFromAfterProcessors:
3768                                         new_processors.insert (new_processors.end(), _monitor_send);
3769                                         break;
3770                                 }
3771                                 break;
3772                         }
3773                 }  else {
3774                         new_processors.insert (new_processors.end(), _monitor_send);
3775                 }
3776         }
3777
3778         /* MONITOR CONTROL */
3779
3780         if (_monitor_control && is_monitor ()) {
3781                 assert (!_monitor_control->display_to_user ());
3782                 new_processors.push_front (_monitor_control);
3783         }
3784
3785         /* INTERNAL RETURN */
3786
3787         /* doing this here means that any monitor control will come just after
3788            the return.
3789         */
3790
3791         if (_intreturn) {
3792                 assert (!_intreturn->display_to_user ());
3793                 new_processors.push_front (_intreturn);
3794         }
3795
3796         /* EXPORT PROCESSOR */
3797
3798         if (_capturing_processor) {
3799                 assert (!_capturing_processor->display_to_user ());
3800                 new_processors.push_front (_capturing_processor);
3801         }
3802
3803         _processors = new_processors;
3804
3805         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3806         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3807                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3808         }
3809 }