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