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