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