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