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