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