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