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