libs/ardour/route.cc

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