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         if (true) {
1769                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1770                 set_processor_positions ();
1771         }
1772
1773         return 0;
1774 }
1775
1776 XMLNode&
1777 Route::get_state()
1778 {
1779         return state(true);
1780 }
1781
1782 XMLNode&
1783 Route::get_template()
1784 {
1785         return state(false);
1786 }
1787
1788 XMLNode&
1789 Route::state(bool full_state)
1790 {
1791         XMLNode *node = new XMLNode("Route");
1792         ProcessorList::iterator i;
1793         char buf[32];
1794
1795         id().print (buf, sizeof (buf));
1796         node->add_property("id", buf);
1797         node->add_property ("name", _name);
1798         node->add_property("default-type", _default_type.to_string());
1799
1800         if (_flags) {
1801                 node->add_property("flags", enum_2_string (_flags));
1802         }
1803
1804         node->add_property("active", _active?"yes":"no");
1805         string p;
1806         boost::to_string (_phase_invert, p);
1807         node->add_property("phase-invert", p);
1808         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1809         node->add_property("meter-point", enum_2_string (_meter_point));
1810
1811         if (_route_group) {
1812                 node->add_property("route-group", _route_group->name());
1813         }
1814
1815         string order_string;
1816         OrderKeys::iterator x = order_keys.begin();
1817
1818         while (x != order_keys.end()) {
1819                 order_string += string ((*x).first);
1820                 order_string += '=';
1821                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1822                 order_string += buf;
1823
1824                 ++x;
1825
1826                 if (x == order_keys.end()) {
1827                         break;
1828                 }
1829
1830                 order_string += ':';
1831         }
1832         node->add_property ("order-keys", order_string);
1833         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1834         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1835         node->add_property ("soloed-by-upstream", buf);
1836         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1837         node->add_property ("soloed-by-downstream", buf);
1838         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1839         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1840
1841         node->add_child_nocopy (_input->state (full_state));
1842         node->add_child_nocopy (_output->state (full_state));
1843         node->add_child_nocopy (_solo_control->get_state ());
1844         node->add_child_nocopy (_mute_control->get_state ());
1845         node->add_child_nocopy (_mute_master->get_state ());
1846
1847         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1848         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1849         remote_control_node->add_property (X_("id"), buf);
1850         node->add_child_nocopy (*remote_control_node);
1851
1852         if (_comment.length()) {
1853                 XMLNode *cmt = node->add_child ("Comment");
1854                 cmt->add_content (_comment);
1855         }
1856
1857         node->add_child_nocopy (_pannable->state (full_state));
1858
1859         for (i = _processors.begin(); i != _processors.end(); ++i) {
1860                 node->add_child_nocopy((*i)->state (full_state));
1861         }
1862
1863         if (_extra_xml){
1864                 node->add_child_copy (*_extra_xml);
1865         }
1866
1867         return *node;
1868 }
1869
1870 int
1871 Route::set_state (const XMLNode& node, int version)
1872 {
1873         return _set_state (node, version, true);
1874 }
1875
1876 int
1877 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1878 {
1879         if (version < 3000) {
1880                 return _set_state_2X (node, version);
1881         }
1882
1883         XMLNodeList nlist;
1884         XMLNodeConstIterator niter;
1885         XMLNode *child;
1886         const XMLProperty *prop;
1887
1888         if (node.name() != "Route"){
1889                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1890                 return -1;
1891         }
1892
1893         if ((prop = node.property (X_("name"))) != 0) {
1894                 Route::set_name (prop->value());
1895         }
1896
1897         if ((prop = node.property ("id")) != 0) {
1898                 _id = prop->value ();
1899         }
1900
1901         if ((prop = node.property (X_("flags"))) != 0) {
1902                 _flags = Flag (string_2_enum (prop->value(), _flags));
1903         } else {
1904                 _flags = Flag (0);
1905         }
1906
1907         if (is_master() || is_monitor() || is_hidden()) {
1908                 _mute_master->set_solo_ignore (true);
1909         }
1910
1911         /* add all processors (except amp, which is always present) */
1912
1913         nlist = node.children();
1914         XMLNode processor_state (X_("processor_state"));
1915
1916         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1917
1918                 child = *niter;
1919
1920                 if (child->name() == IO::state_node_name) {
1921                         if ((prop = child->property (X_("direction"))) == 0) {
1922                                 continue;
1923                         }
1924
1925                         if (prop->value() == "Input") {
1926                                 _input->set_state (*child, version);
1927                         } else if (prop->value() == "Output") {
1928                                 _output->set_state (*child, version);
1929                         }
1930                 }
1931
1932                 if (child->name() == X_("Processor")) {
1933                         processor_state.add_child_copy (*child);
1934                 }
1935
1936
1937                 if (child->name() == X_("Pannable")) {
1938                         _pannable->set_state (*child, version);
1939                 }
1940         }
1941
1942         set_processor_state (processor_state);
1943
1944         if ((prop = node.property ("self-solo")) != 0) {
1945                 set_self_solo (string_is_affirmative (prop->value()));
1946         }
1947
1948         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1949                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1950                 mod_solo_by_others_upstream (atoi (prop->value()));
1951         }
1952
1953         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1954                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1955                 mod_solo_by_others_downstream (atoi (prop->value()));
1956         }
1957
1958         if ((prop = node.property ("solo-isolated")) != 0) {
1959                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1960         }
1961
1962         if ((prop = node.property ("solo-safe")) != 0) {
1963                 set_solo_safe (string_is_affirmative (prop->value()), this);
1964         }
1965
1966         if ((prop = node.property (X_("phase-invert"))) != 0) {
1967                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1968         }
1969
1970         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1971                 set_denormal_protection (string_is_affirmative (prop->value()));
1972         }
1973
1974         if ((prop = node.property (X_("active"))) != 0) {
1975                 bool yn = string_is_affirmative (prop->value());
1976                 _active = !yn; // force switch
1977                 set_active (yn, this);
1978         }
1979
1980         if ((prop = node.property (X_("meter-point"))) != 0) {
1981                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1982                 set_meter_point (mp, true);
1983                 if (_meter) {
1984                         _meter->set_display_to_user (_meter_point == MeterCustom);
1985                 }
1986         }
1987
1988         if ((prop = node.property (X_("order-keys"))) != 0) {
1989
1990                 int32_t n;
1991
1992                 string::size_type colon, equal;
1993                 string remaining = prop->value();
1994
1995                 while (remaining.length()) {
1996
1997                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1998                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1999                                       << endmsg;
2000                         } else {
2001                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2002                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2003                                               << endmsg;
2004                                 } else {
2005                                         set_order_key (remaining.substr (0, equal), n);
2006                                 }
2007                         }
2008
2009                         colon = remaining.find_first_of (':');
2010
2011                         if (colon != string::npos) {
2012                                 remaining = remaining.substr (colon+1);
2013                         } else {
2014                                 break;
2015                         }
2016                 }
2017         }
2018
2019         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2020                 child = *niter;
2021
2022                 if (child->name() == X_("Comment")) {
2023
2024                         /* XXX this is a terrible API design in libxml++ */
2025
2026                         XMLNode *cmt = *(child->children().begin());
2027                         _comment = cmt->content();
2028
2029                 } else if (child->name() == X_("Extra")) {
2030
2031                         _extra_xml = new XMLNode (*child);
2032
2033                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2034                         if (prop->value() == "solo") {
2035                                 _solo_control->set_state (*child, version);
2036                         }
2037
2038                 } else if (child->name() == X_("RemoteControl")) {
2039                         if ((prop = child->property (X_("id"))) != 0) {
2040                                 int32_t x;
2041                                 sscanf (prop->value().c_str(), "%d", &x);
2042                                 set_remote_control_id (x);
2043                         }
2044
2045                 } else if (child->name() == X_("MuteMaster")) {
2046                         _mute_master->set_state (*child, version);
2047                 }
2048         }
2049
2050         return 0;
2051 }
2052
2053 int
2054 Route::_set_state_2X (const XMLNode& node, int version)
2055 {
2056         XMLNodeList nlist;
2057         XMLNodeConstIterator niter;
2058         XMLNode *child;
2059         const XMLProperty *prop;
2060
2061         /* 2X things which still remain to be handled:
2062          * default-type
2063          * automation
2064          * controlouts
2065          */
2066
2067         if (node.name() != "Route") {
2068                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2069                 return -1;
2070         }
2071
2072         if ((prop = node.property (X_("flags"))) != 0) {
2073                 _flags = Flag (string_2_enum (prop->value(), _flags));
2074         } else {
2075                 _flags = Flag (0);
2076         }
2077
2078         if ((prop = node.property (X_("phase-invert"))) != 0) {
2079                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2080                 if (string_is_affirmative (prop->value ())) {
2081                         p.set ();
2082                 }
2083                 set_phase_invert (p);
2084         }
2085
2086         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2087                 set_denormal_protection (string_is_affirmative (prop->value()));
2088         }
2089
2090         if ((prop = node.property (X_("soloed"))) != 0) {
2091                 bool yn = string_is_affirmative (prop->value());
2092
2093                 /* XXX force reset of solo status */
2094
2095                 set_solo (yn, this);
2096         }
2097
2098         if ((prop = node.property (X_("muted"))) != 0) {
2099
2100                 bool first = true;
2101                 bool muted = string_is_affirmative (prop->value());
2102
2103                 if (muted){
2104
2105                         string mute_point;
2106
2107                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2108
2109                                 if (string_is_affirmative (prop->value())){
2110                                         mute_point = mute_point + "PreFader";
2111                                         first = false;
2112                                 }
2113                         }
2114
2115                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2116
2117                                 if (string_is_affirmative (prop->value())){
2118
2119                                         if (!first) {
2120                                                 mute_point = mute_point + ",";
2121                                         }
2122
2123                                         mute_point = mute_point + "PostFader";
2124                                         first = false;
2125                                 }
2126                         }
2127
2128                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2129
2130                                 if (string_is_affirmative (prop->value())){
2131
2132                                         if (!first) {
2133                                                 mute_point = mute_point + ",";
2134                                         }
2135
2136                                         mute_point = mute_point + "Listen";
2137                                         first = false;
2138                                 }
2139                         }
2140
2141                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2142
2143                                 if (string_is_affirmative (prop->value())){
2144
2145                                         if (!first) {
2146                                                 mute_point = mute_point + ",";
2147                                         }
2148
2149                                         mute_point = mute_point + "Main";
2150                                 }
2151                         }
2152
2153                         _mute_master->set_mute_points (mute_point);
2154                 }
2155         }
2156
2157         if ((prop = node.property (X_("meter-point"))) != 0) {
2158                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2159         }
2160
2161         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2162            don't mean the same thing.
2163         */
2164
2165         if ((prop = node.property (X_("order-keys"))) != 0) {
2166
2167                 int32_t n;
2168
2169                 string::size_type colon, equal;
2170                 string remaining = prop->value();
2171
2172                 while (remaining.length()) {
2173
2174                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2175                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2176                                         << endmsg;
2177                         } else {
2178                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2179                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2180                                                 << endmsg;
2181                                 } else {
2182                                         set_order_key (remaining.substr (0, equal), n);
2183                                 }
2184                         }
2185
2186                         colon = remaining.find_first_of (':');
2187
2188                         if (colon != string::npos) {
2189                                 remaining = remaining.substr (colon+1);
2190                         } else {
2191                                 break;
2192                         }
2193                 }
2194         }
2195
2196         /* IOs */
2197
2198         nlist = node.children ();
2199         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2200
2201                 child = *niter;
2202
2203                 if (child->name() == IO::state_node_name) {
2204
2205                         /* there is a note in IO::set_state_2X() about why we have to call
2206                            this directly.
2207                            */
2208
2209                         _input->set_state_2X (*child, version, true);
2210                         _output->set_state_2X (*child, version, false);
2211
2212                         if ((prop = child->property (X_("name"))) != 0) {
2213                                 Route::set_name (prop->value ());
2214                         }
2215
2216                         if ((prop = child->property (X_("id"))) != 0) {
2217                                 _id = prop->value ();
2218                         }
2219
2220                         if ((prop = child->property (X_("active"))) != 0) {
2221                                 bool yn = string_is_affirmative (prop->value());
2222                                 _active = !yn; // force switch
2223                                 set_active (yn, this);
2224                         }
2225
2226                         if ((prop = child->property (X_("gain"))) != 0) {
2227                                 gain_t val;
2228
2229                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2230                                         _amp->gain_control()->set_value (val);
2231                                 }
2232                         }
2233
2234                         /* Set up Panners in the IO */
2235                         XMLNodeList io_nlist = child->children ();
2236
2237                         XMLNodeConstIterator io_niter;
2238                         XMLNode *io_child;
2239
2240                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2241
2242                                 io_child = *io_niter;
2243
2244                                 if (io_child->name() == X_("Panner")) {
2245                                         _main_outs->panner_shell()->set_state(*io_child, version);
2246                                 } else if (io_child->name() == X_("Automation")) {
2247                                         /* IO's automation is for the fader */
2248                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2249                                 }
2250                         }
2251                 }
2252         }
2253
2254         XMLNodeList redirect_nodes;
2255
2256         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2257
2258                 child = *niter;
2259
2260                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2261                         redirect_nodes.push_back(child);
2262                 }
2263
2264         }
2265
2266         set_processor_state_2X (redirect_nodes, version);
2267
2268         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2269                 child = *niter;
2270
2271                 if (child->name() == X_("Comment")) {
2272
2273                         /* XXX this is a terrible API design in libxml++ */
2274
2275                         XMLNode *cmt = *(child->children().begin());
2276                         _comment = cmt->content();
2277
2278                 } else if (child->name() == X_("extra")) {
2279
2280                         _extra_xml = new XMLNode (*child);
2281
2282                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2283                         if (prop->value() == X_("solo")) {
2284                                 _solo_control->set_state (*child, version);
2285                         } else if (prop->value() == X_("mute")) {
2286                                 _mute_control->set_state (*child, version);
2287                         }
2288
2289                 } else if (child->name() == X_("RemoteControl")) {
2290                         if ((prop = child->property (X_("id"))) != 0) {
2291                                 int32_t x;
2292                                 sscanf (prop->value().c_str(), "%d", &x);
2293                                 set_remote_control_id (x);
2294                         }
2295
2296                 }
2297         }
2298
2299         return 0;
2300 }
2301
2302 XMLNode&
2303 Route::get_processor_state ()
2304 {
2305         XMLNode* root = new XMLNode (X_("redirects"));
2306         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2307                 root->add_child_nocopy ((*i)->state (true));
2308         }
2309
2310         return *root;
2311 }
2312
2313 void
2314 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2315 {
2316         /* We don't bother removing existing processors not in nList, as this
2317            method will only be called when creating a Route from scratch, not
2318            for undo purposes.  Just put processors in at the appropriate place
2319            in the list.
2320         */
2321
2322         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2323                 add_processor_from_xml_2X (**i, version);
2324         }
2325 }
2326
2327 void
2328 Route::set_processor_state (const XMLNode& node)
2329 {
2330         const XMLNodeList &nlist = node.children();
2331         XMLNodeConstIterator niter;
2332         ProcessorList new_order;
2333         bool must_configure = false;
2334
2335         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2336
2337                 XMLProperty* prop = (*niter)->property ("type");
2338
2339                 if (prop->value() == "amp") {
2340                         _amp->set_state (**niter, Stateful::current_state_version);
2341                         new_order.push_back (_amp);
2342                 } else if (prop->value() == "meter") {
2343                         _meter->set_state (**niter, Stateful::current_state_version);
2344                         new_order.push_back (_meter);
2345                 } else if (prop->value() == "main-outs") {
2346                         _main_outs->set_state (**niter, Stateful::current_state_version);
2347                         new_order.push_back (_main_outs);
2348                 } else if (prop->value() == "intreturn") {
2349                         if (!_intreturn) {
2350                                 _intreturn.reset (new InternalReturn (_session));
2351                                 must_configure = true;
2352                         }
2353                         _intreturn->set_state (**niter, Stateful::current_state_version);
2354                         new_order.push_back (_intreturn);
2355                 } else if (is_monitor() && prop->value() == "monitor") {
2356                         if (!_monitor_control) {
2357                                 _monitor_control.reset (new MonitorProcessor (_session));
2358                                 must_configure = true;
2359                         }
2360                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2361                         new_order.push_back (_monitor_control);
2362                 } else {
2363                         ProcessorList::iterator o;
2364
2365                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2366                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2367                                 if (id_prop && (*o)->id() == id_prop->value()) {
2368                                         (*o)->set_state (**niter, Stateful::current_state_version);
2369                                         new_order.push_back (*o);
2370                                         break;
2371                                 }
2372                         }
2373
2374                         // If the processor (*niter) is not on the route then create it
2375
2376                         if (o == _processors.end()) {
2377
2378                                 boost::shared_ptr<Processor> processor;
2379
2380                                 if (prop->value() == "intsend") {
2381
2382                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2383
2384                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2385                                            prop->value() == "lv2" ||
2386                                            prop->value() == "vst" ||
2387                                            prop->value() == "audiounit") {
2388
2389                                         processor.reset (new PluginInsert(_session));
2390
2391                                 } else if (prop->value() == "port") {
2392
2393                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2394
2395                                 } else if (prop->value() == "send") {
2396
2397                                         processor.reset (new Send (_session, _pannable, _mute_master));
2398
2399                                 } else {
2400                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2401                                         continue;
2402                                 }
2403
2404                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2405                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2406                                         processor.reset (new UnknownProcessor (_session, **niter));
2407                                 }
2408
2409                                 new_order.push_back (processor);
2410                                 must_configure = true;
2411                         }
2412                 }
2413         }
2414
2415         {
2416                 Glib::RWLock::WriterLock lm (_processor_lock);
2417                 _processors = new_order;
2418                 if (must_configure) {
2419                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2420                         configure_processors_unlocked (0);
2421                 }
2422         }
2423
2424         processors_changed (RouteProcessorChange ());
2425         set_processor_positions ();
2426 }
2427
2428 void
2429 Route::curve_reallocate ()
2430 {
2431 //      _gain_automation_curve.finish_resize ();
2432 //      _pan_automation_curve.finish_resize ();
2433 }
2434
2435 void
2436 Route::silence (framecnt_t nframes)
2437 {
2438         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2439         if (!lm.locked()) {
2440                 return;
2441         }
2442
2443         silence_unlocked (nframes);
2444 }
2445
2446 void
2447 Route::silence_unlocked (framecnt_t nframes)
2448 {
2449         /* Must be called with the processor lock held */
2450
2451         if (!_silent) {
2452
2453                 _output->silence (nframes);
2454
2455                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2456                         boost::shared_ptr<PluginInsert> pi;
2457
2458                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2459                                 // skip plugins, they don't need anything when we're not active
2460                                 continue;
2461                         }
2462
2463                         (*i)->silence (nframes);
2464                 }
2465
2466                 if (nframes == _session.get_block_size()) {
2467                         // _silent = true;
2468                 }
2469         }
2470 }
2471
2472 void
2473 Route::add_internal_return ()
2474 {
2475         if (!_intreturn) {
2476                 _intreturn.reset (new InternalReturn (_session));
2477                 add_processor (_intreturn, PreFader);
2478         }
2479 }
2480
2481 BufferSet*
2482 Route::get_return_buffer () const
2483 {
2484         Glib::RWLock::ReaderLock rm (_processor_lock);
2485
2486         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2487                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2488
2489                 if (d) {
2490                         BufferSet* bs = d->get_buffers ();
2491                         return bs;
2492                 }
2493         }
2494
2495         return 0;
2496 }
2497
2498 void
2499 Route::release_return_buffer () const
2500 {
2501         Glib::RWLock::ReaderLock rm (_processor_lock);
2502
2503         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2504                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2505
2506                 if (d) {
2507                         return d->release_buffers ();
2508                 }
2509         }
2510 }
2511
2512 int
2513 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2514 {
2515         vector<string> ports;
2516         vector<string>::const_iterator i;
2517
2518         {
2519                 Glib::RWLock::ReaderLock rm (_processor_lock);
2520
2521                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2522
2523                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2524
2525                         if (d && d->target_route() == route) {
2526
2527                                 /* if the target is the control outs, then make sure
2528                                    we take note of which i-send is doing that.
2529                                 */
2530
2531                                 if (route == _session.monitor_out()) {
2532                                         _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
2533                                 }
2534
2535                                 /* already listening via the specified IO: do nothing */
2536
2537                                 return 0;
2538                         }
2539                 }
2540         }
2541
2542         boost::shared_ptr<InternalSend> listener;
2543
2544         try {
2545
2546                 if (is_master()) {
2547
2548                         if (route == _session.monitor_out()) {
2549                                 /* master never sends to control outs */
2550                                 return 0;
2551                         } else {
2552                                 listener.reset (new InternalSend (_session, _pannable, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2553                         }
2554
2555                 } else {
2556                         listener.reset (new InternalSend (_session, _pannable, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2557                 }
2558
2559         } catch (failed_constructor& err) {
2560                 return -1;
2561         }
2562
2563         if (route == _session.monitor_out()) {
2564                 _monitor_send = listener;
2565         }
2566
2567
2568         if (aux) {
2569
2570                 add_processor (listener, placement);
2571
2572         } else {
2573
2574                 if (placement == PostFader) {
2575                         /* put it *really* at the end, not just after the panner (main outs)
2576                          */
2577                         add_processor (listener, _processors.end());
2578                 } else {
2579                         add_processor (listener, PreFader);
2580                 }
2581
2582         }
2583
2584         return 0;
2585 }
2586
2587 void
2588 Route::drop_listen (boost::shared_ptr<Route> route)
2589 {
2590         ProcessorStreams err;
2591         ProcessorList::iterator tmp;
2592
2593         Glib::RWLock::ReaderLock rl(_processor_lock);
2594         rl.acquire ();
2595
2596   again:
2597         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2598
2599                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2600
2601                 if (d && d->target_route() == route) {
2602                         rl.release ();
2603                         remove_processor (*x, &err);
2604                         rl.acquire ();
2605
2606                         /* list could have been demolished while we dropped the lock
2607                            so start over.
2608                         */
2609
2610                         goto again;
2611                 }
2612         }
2613
2614         rl.release ();
2615
2616         if (route == _session.monitor_out()) {
2617                 _monitor_send.reset ();
2618         }
2619 }
2620
2621 void
2622 Route::set_comment (string cmt, void *src)
2623 {
2624         _comment = cmt;
2625         comment_changed (src);
2626         _session.set_dirty ();
2627 }
2628
2629 bool
2630 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2631 {
2632         FeedRecord fr (other, via_sends_only);
2633
2634         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2635
2636         if (!result.second) {
2637
2638                 /* already a record for "other" - make sure sends-only information is correct */
2639                 if (!via_sends_only && result.first->sends_only) {
2640                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2641                         frp->sends_only = false;
2642                 }
2643         }
2644
2645         return result.second;
2646 }
2647
2648 void
2649 Route::clear_fed_by ()
2650 {
2651         _fed_by.clear ();
2652 }
2653
2654 bool
2655 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2656 {
2657         const FedBy& fed_by (other->fed_by());
2658
2659         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2660                 boost::shared_ptr<Route> sr = f->r.lock();
2661
2662                 if (sr && (sr.get() == this)) {
2663
2664                         if (via_sends_only) {
2665                                 *via_sends_only = f->sends_only;
2666                         }
2667
2668                         return true;
2669                 }
2670         }
2671
2672         return false;
2673 }
2674
2675 bool
2676 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2677 {
2678         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2679
2680         if (_output->connected_to (other->input())) {
2681                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2682                 if (only_send) {
2683                         *only_send = false;
2684                 }
2685
2686                 return true;
2687         }
2688
2689
2690         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2691
2692                 boost::shared_ptr<IOProcessor> iop;
2693
2694                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2695                         if (iop->feeds (other)) {
2696                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2697                                 if (only_send) {
2698                                         *only_send = true;
2699                                 }
2700                                 return true;
2701                         } else {
2702                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2703                         }
2704                 } else {
2705                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2706                 }
2707
2708         }
2709
2710         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2711         return false;
2712 }
2713
2714 /** Called from the (non-realtime) butler thread when the transport is stopped */
2715 void
2716 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2717 {
2718         framepos_t now = _session.transport_frame();
2719
2720         {
2721                 Glib::RWLock::ReaderLock lm (_processor_lock);
2722
2723                 if (!did_locate) {
2724                         automation_snapshot (now, true);
2725                 }
2726
2727                 Automatable::transport_stopped (now);
2728
2729                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2730
2731                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2732                                 (*i)->flush ();
2733                         }
2734
2735                         (*i)->transport_stopped (now);
2736                 }
2737         }
2738
2739         _roll_delay = _initial_delay;
2740 }
2741
2742 /** Called with the process lock held if change contains ConfigurationChanged */
2743 void
2744 Route::input_change_handler (IOChange change, void * /*src*/)
2745 {
2746         if ((change.type & IOChange::ConfigurationChanged)) {
2747                 configure_processors (0);
2748                 _phase_invert.resize (_input->n_ports().n_audio ());
2749                 io_changed (); /* EMIT SIGNAL */
2750         }
2751 }
2752
2753 /** Called with the process lock held if change contains ConfigurationChanged */
2754 void
2755 Route::output_change_handler (IOChange change, void * /*src*/)
2756 {
2757         if ((change.type & IOChange::ConfigurationChanged)) {
2758
2759                 /* XXX resize all listeners to match _main_outs? */
2760
2761                 /* Auto-connect newly-created outputs, unless we're auto-connecting to master
2762                    and we are master (as an auto-connect in this situation would cause a
2763                    feedback loop)
2764                 */
2765                 AutoConnectOption ac = Config->get_output_auto_connect ();
2766                 if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
2767
2768                         ChanCount start = change.before;
2769
2770                         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
2771                                 if (change.before.get(*i) < change.after.get(*i)) {
2772                                         /* the existing ChanCounts don't matter for this call as they are only
2773                                            to do with matching input and output indices, and we are only changing
2774                                            outputs here.
2775                                         */
2776                                         ChanCount dummy;
2777
2778                                         /* only auto-connect the newly-created outputs, not the ones that were
2779                                            already there
2780                                         */
2781                                         start.set (*i, start.get (*i) + 1);
2782
2783                                         _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
2784                                 }
2785                         }
2786                 }
2787
2788                 // configure_processors (0);
2789         }
2790 }
2791
2792 uint32_t
2793 Route::pans_required () const
2794 {
2795         if (n_outputs().n_audio() < 2) {
2796                 return 0;
2797         }
2798
2799         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2800 }
2801
2802 int
2803 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2804                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2805 {
2806         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2807         if (!lm.locked()) {
2808                 return 0;
2809         }
2810
2811         if (n_outputs().n_total() == 0) {
2812                 return 0;
2813         }
2814
2815         if (!_active || n_inputs() == ChanCount::ZERO)  {
2816                 silence_unlocked (nframes);
2817                 return 0;
2818         }
2819         if (session_state_changing) {
2820                 if (_session.transport_speed() != 0.0f) {
2821                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2822                            so we cannot use them. Be silent till this is over.
2823
2824                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2825                         */
2826                         silence_unlocked (nframes);
2827                         return 0;
2828                 }
2829                 /* we're really not rolling, so we're either delivery silence or actually
2830                    monitoring, both of which are safe to do while session_state_changing is true.
2831                 */
2832         }
2833
2834         _amp->apply_gain_automation (false);
2835         passthru (start_frame, end_frame, nframes, 0);
2836
2837         return 0;
2838 }
2839
2840 framecnt_t
2841 Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
2842 {
2843         if (_roll_delay > nframes) {
2844
2845                 _roll_delay -= nframes;
2846                 silence_unlocked (nframes);
2847                 /* transport frame is not legal for caller to use */
2848                 return 0;
2849
2850         } else if (_roll_delay > 0) {
2851
2852                 nframes -= _roll_delay;
2853                 silence_unlocked (_roll_delay);
2854                 /* we've written _roll_delay of samples into the
2855                    output ports, so make a note of that for
2856                    future reference.
2857                 */
2858                 _main_outs->increment_output_offset (_roll_delay);
2859                 transport_frame += _roll_delay;
2860
2861                 _roll_delay = 0;
2862         }
2863
2864         return nframes;
2865 }
2866
2867 int
2868 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2869              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2870 {
2871         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2872         if (!lm.locked()) {
2873                 return 0;
2874         }
2875
2876         automation_snapshot (_session.transport_frame(), false);
2877
2878         if (n_outputs().n_total() == 0) {
2879                 return 0;
2880         }
2881
2882         if (!_active || n_inputs().n_total() == 0) {
2883                 silence_unlocked (nframes);
2884                 return 0;
2885         }
2886
2887         framecnt_t unused = 0;
2888
2889         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2890                 return 0;
2891         }
2892
2893         _silent = false;
2894
2895         passthru (start_frame, end_frame, nframes, declick);
2896
2897         return 0;
2898 }
2899
2900 int
2901 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2902                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2903 {
2904         silence (nframes);
2905         return 0;
2906 }
2907
2908 void
2909 Route::toggle_monitor_input ()
2910 {
2911         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2912                 i->ensure_monitor_input( ! i->monitoring_input());
2913         }
2914 }
2915
2916 bool
2917 Route::has_external_redirects () const
2918 {
2919         // FIXME: what about sends? - they don't return a signal back to ardour?
2920
2921         boost::shared_ptr<const PortInsert> pi;
2922
2923         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2924
2925                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2926
2927                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2928
2929                                 string port_name = port->name();
2930                                 string client_name = port_name.substr (0, port_name.find(':'));
2931
2932                                 /* only say "yes" if the redirect is actually in use */
2933
2934                                 if (client_name != "ardour" && pi->active()) {
2935                                         return true;
2936                                 }
2937                         }
2938                 }
2939         }
2940
2941         return false;
2942 }
2943
2944 void
2945 Route::flush_processors ()
2946 {
2947         /* XXX shouldn't really try to take this lock, since
2948            this is called from the RT audio thread.
2949         */
2950
2951         Glib::RWLock::ReaderLock lm (_processor_lock);
2952
2953         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2954                 (*i)->flush ();
2955         }
2956 }
2957
2958 void
2959 Route::set_meter_point (MeterPoint p, bool force)
2960 {
2961         /* CAN BE CALLED FROM PROCESS CONTEXT */
2962
2963         if (_meter_point == p && !force) {
2964                 return;
2965         }
2966
2967         bool meter_was_visible_to_user = _meter->display_to_user ();
2968
2969         {
2970                 Glib::RWLock::WriterLock lm (_processor_lock);
2971
2972                 if (p != MeterCustom) {
2973                         // Move meter in the processors list to reflect the new position
2974                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2975                         _processors.erase(loc);
2976                         switch (p) {
2977                         case MeterInput:
2978                                 loc = _processors.begin();
2979                                 break;
2980                         case MeterPreFader:
2981                                 loc = find (_processors.begin(), _processors.end(), _amp);
2982                                 break;
2983                         case MeterPostFader:
2984                                 loc = _processors.end();
2985                                 break;
2986                         default:
2987                                 break;
2988                         }
2989
2990                         ChanCount m_in;
2991
2992                         if (loc == _processors.begin()) {
2993                                 m_in = _input->n_ports();
2994                         } else {
2995                                 ProcessorList::iterator before = loc;
2996                                 --before;
2997                                 m_in = (*before)->output_streams ();
2998                         }
2999
3000                         _meter->reflect_inputs (m_in);
3001
3002                         _processors.insert (loc, _meter);
3003
3004                         /* we do not need to reconfigure the processors, because the meter
3005                            (a) is always ready to handle processor_max_streams
3006                            (b) is always an N-in/N-out processor, and thus moving
3007                            it doesn't require any changes to the other processors.
3008                         */
3009
3010                         _meter->set_display_to_user (false);
3011
3012                 } else {
3013
3014                         // just make it visible and let the user move it
3015
3016                         _meter->set_display_to_user (true);
3017                 }
3018         }
3019
3020         _meter_point = p;
3021         meter_change (); /* EMIT SIGNAL */
3022
3023         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3024
3025         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3026 }
3027
3028 void
3029 Route::put_monitor_send_at (Placement p)
3030 {
3031         if (!_monitor_send) {
3032                 return;
3033         }
3034
3035         {
3036                 Glib::RWLock::WriterLock lm (_processor_lock);
3037                 ProcessorList as_it_was (_processors);
3038                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
3039                 _processors.erase(loc);
3040
3041                 switch (p) {
3042                 case PreFader:
3043                         loc = find(_processors.begin(), _processors.end(), _amp);
3044                         if (loc != _processors.begin()) {
3045                                 --loc;
3046                         }
3047                         break;
3048                 case PostFader:
3049                         loc = _processors.end();
3050                         break;
3051                 }
3052
3053                 _processors.insert (loc, _monitor_send);
3054
3055                 {
3056                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3057
3058                         if (configure_processors_unlocked (0)) {
3059                                 _processors = as_it_was;
3060                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
3061                                 return;
3062                         }
3063                 }
3064         }
3065
3066         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3067         _session.set_dirty ();
3068 }
3069
3070 boost::shared_ptr<CapturingProcessor>
3071 Route::add_export_point()
3072 {
3073         // Check if it exists already
3074         boost::shared_ptr<CapturingProcessor> processor;
3075         if ((processor = boost::dynamic_pointer_cast<CapturingProcessor> (*_processors.begin()))) {
3076                 return processor;
3077         }
3078
3079         // ...else add it
3080         processor.reset (new CapturingProcessor (_session));
3081         add_processor (processor, _processors.begin());
3082         return processor;
3083 }
3084
3085 framecnt_t
3086 Route::update_total_latency ()
3087 {
3088         framecnt_t old = _output->effective_latency();
3089         framecnt_t own_latency = _output->user_latency();
3090
3091         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3092                 if ((*i)->active ()) {
3093                         own_latency += (*i)->signal_latency ();
3094                 }
3095         }
3096
3097         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
3098
3099         _output->set_port_latency (own_latency);
3100
3101         if (_output->user_latency() == 0) {
3102
3103                 /* this (virtual) function is used for pure Routes,
3104                    not derived classes like AudioTrack.  this means
3105                    that the data processed here comes from an input
3106                    port, not prerecorded material, and therefore we
3107                    have to take into account any input latency.
3108                 */
3109
3110                 own_latency += _input->signal_latency ();
3111         }
3112
3113         if (old != own_latency) {
3114                 _output->set_latency_delay (own_latency);
3115                 signal_latency_changed (); /* EMIT SIGNAL */
3116         }
3117
3118         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
3119
3120         return _output->effective_latency ();
3121 }
3122
3123 void
3124 Route::set_user_latency (framecnt_t nframes)
3125 {
3126         _output->set_user_latency (nframes);
3127         _session.update_latency_compensation (false, false);
3128 }
3129
3130 void
3131 Route::set_latency_delay (framecnt_t longest_session_latency)
3132 {
3133         framecnt_t old = _initial_delay;
3134
3135         if (_output->effective_latency() < longest_session_latency) {
3136                 _initial_delay = longest_session_latency - _output->effective_latency();
3137         } else {
3138                 _initial_delay = 0;
3139         }
3140
3141         if (_initial_delay != old) {
3142                 initial_delay_changed (); /* EMIT SIGNAL */
3143         }
3144
3145         if (_session.transport_stopped()) {
3146                 _roll_delay = _initial_delay;
3147         }
3148 }
3149
3150 void
3151 Route::automation_snapshot (framepos_t now, bool force)
3152 {
3153         _pannable->automation_snapshot (now, force);
3154         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3155                 (*i)->automation_snapshot (now, force);
3156         }
3157 }
3158
3159 Route::SoloControllable::SoloControllable (std::string name, Route& r)
3160         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
3161                              boost::shared_ptr<AutomationList>(), name)
3162         , route (r)
3163 {
3164         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3165         set_list (gl);
3166 }
3167
3168 void
3169 Route::SoloControllable::set_value (double val)
3170 {
3171         bool bval = ((val >= 0.5f) ? true: false);
3172 # if 0
3173         this is how it should be done
3174
3175         boost::shared_ptr<RouteList> rl (new RouteList);
3176         rl->push_back (route);
3177
3178         if (Config->get_solo_control_is_listen_control()) {
3179                 _session.set_listen (rl, bval);
3180         } else {
3181                 _session.set_solo (rl, bval);
3182         }
3183 #else
3184         route.set_solo (bval, this);
3185 #endif
3186 }
3187
3188 double
3189 Route::SoloControllable::get_value (void) const
3190 {
3191         if (Config->get_solo_control_is_listen_control()) {
3192                 return route.listening() ? 1.0f : 0.0f;
3193         } else {
3194                 return route.self_soloed() ? 1.0f : 0.0f;
3195         }
3196 }
3197
3198 Route::MuteControllable::MuteControllable (std::string name, Route& r)
3199         : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
3200                              boost::shared_ptr<AutomationList>(), name)
3201         , route (r)
3202 {
3203         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3204         set_list (gl);
3205 }
3206
3207 void
3208 Route::MuteControllable::set_value (double val)
3209 {
3210         bool bval = ((val >= 0.5f) ? true: false);
3211 # if 0
3212         this is how it should be done
3213
3214         boost::shared_ptr<RouteList> rl (new RouteList);
3215         rl->push_back (route);
3216         _session.set_mute (rl, bval);
3217 #else
3218         route.set_mute (bval, this);
3219 #endif
3220 }
3221
3222 double
3223 Route::MuteControllable::get_value (void) const
3224 {
3225         return route.muted() ? 1.0f : 0.0f;
3226 }
3227
3228 void
3229 Route::set_block_size (pframes_t nframes)
3230 {
3231         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3232                 (*i)->set_block_size (nframes);
3233         }
3234
3235         _session.ensure_buffers (n_process_buffers ());
3236 }
3237
3238 void
3239 Route::protect_automation ()
3240 {
3241         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3242                 (*i)->protect_automation();
3243 }
3244
3245 void
3246 Route::set_pending_declick (int declick)
3247 {
3248         if (_declickable) {
3249                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3250                 if (declick) {
3251                         _pending_declick = declick;
3252                 }
3253                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3254         } else {
3255                 _pending_declick = 0;
3256         }
3257
3258 }
3259
3260 /** Shift automation forwards from a particular place, thereby inserting time.
3261  *  Adds undo commands for any shifts that are performed.
3262  *
3263  * @param pos Position to start shifting from.
3264  * @param frames Amount to shift forwards by.
3265  */
3266
3267 void
3268 Route::shift (framepos_t pos, framecnt_t frames)
3269 {
3270         /* gain automation */
3271         {
3272                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3273
3274                 XMLNode &before = gc->alist()->get_state ();
3275                 gc->alist()->shift (pos, frames);
3276                 XMLNode &after = gc->alist()->get_state ();
3277                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3278         }
3279
3280         /* pan automation */
3281         {
3282                 ControlSet::Controls& c (_pannable->controls());
3283
3284                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3285                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3286                         if (pc) {
3287                                 boost::shared_ptr<AutomationList> al = pc->alist();
3288                                 XMLNode& before = al->get_state ();
3289                                 al->shift (pos, frames);
3290                                 XMLNode& after = al->get_state ();
3291                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3292                         }
3293                 }
3294         }
3295
3296         /* redirect automation */
3297         {
3298                 Glib::RWLock::ReaderLock lm (_processor_lock);
3299                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3300
3301                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3302
3303                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3304                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3305                                 if (ac) {
3306                                         boost::shared_ptr<AutomationList> al = ac->alist();
3307                                         XMLNode &before = al->get_state ();
3308                                         al->shift (pos, frames);
3309                                         XMLNode &after = al->get_state ();
3310                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3311                                 }
3312                         }
3313                 }
3314         }
3315 }
3316
3317
3318 int
3319 Route::save_as_template (const string& path, const string& name)
3320 {
3321         XMLNode& node (state (false));
3322         XMLTree tree;
3323
3324         IO::set_name_in_state (*node.children().front(), name);
3325
3326         tree.set_root (&node);
3327         return tree.write (path.c_str());
3328 }
3329
3330
3331 bool
3332 Route::set_name (const string& str)
3333 {
3334         bool ret;
3335         string ioproc_name;
3336         string name;
3337
3338         name = Route::ensure_track_or_route_name (str, _session);
3339         SessionObject::set_name (name);
3340
3341         ret = (_input->set_name(name) && _output->set_name(name));
3342
3343         if (ret) {
3344
3345                 Glib::RWLock::ReaderLock lm (_processor_lock);
3346
3347                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3348
3349                         /* rename all I/O processors that have inputs or outputs */
3350
3351                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3352
3353                         if (iop && (iop->output() || iop->input())) {
3354                                 if (!iop->set_name (name)) {
3355                                         ret = false;
3356                                 }
3357                         }
3358                 }
3359
3360         }
3361
3362         return ret;
3363 }
3364
3365 boost::shared_ptr<Send>
3366 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3367 {
3368         Glib::RWLock::ReaderLock lm (_processor_lock);
3369
3370         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3371                 boost::shared_ptr<InternalSend> send;
3372
3373                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3374                         if (send->target_route() == target) {
3375                                 return send;
3376                         }
3377                 }
3378         }
3379
3380         return boost::shared_ptr<Send>();
3381 }
3382
3383 /** @param c Audio channel index.
3384  *  @param yn true to invert phase, otherwise false.
3385  */
3386 void
3387 Route::set_phase_invert (uint32_t c, bool yn)
3388 {
3389         if (_phase_invert[c] != yn) {
3390                 _phase_invert[c] = yn;
3391                 phase_invert_changed (); /* EMIT SIGNAL */
3392                 _session.set_dirty ();
3393         }
3394 }
3395
3396 void
3397 Route::set_phase_invert (boost::dynamic_bitset<> p)
3398 {
3399         if (_phase_invert != p) {
3400                 _phase_invert = p;
3401                 phase_invert_changed (); /* EMIT SIGNAL */
3402                 _session.set_dirty ();
3403         }
3404 }
3405
3406 bool
3407 Route::phase_invert (uint32_t c) const
3408 {
3409         return _phase_invert[c];
3410 }
3411
3412 boost::dynamic_bitset<>
3413 Route::phase_invert () const
3414 {
3415         return _phase_invert;
3416 }
3417
3418 void
3419 Route::set_denormal_protection (bool yn)
3420 {
3421         if (_denormal_protection != yn) {
3422                 _denormal_protection = yn;
3423                 denormal_protection_changed (); /* EMIT SIGNAL */
3424         }
3425 }
3426
3427 bool
3428 Route::denormal_protection () const
3429 {
3430         return _denormal_protection;
3431 }
3432
3433 void
3434 Route::set_active (bool yn, void* src)
3435 {
3436         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3437                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3438                 return;
3439         }
3440
3441         if (_active != yn) {
3442                 _active = yn;
3443                 _input->set_active (yn);
3444                 _output->set_active (yn);
3445                 active_changed (); // EMIT SIGNAL
3446         }
3447 }
3448
3449 void
3450 Route::meter ()
3451 {
3452         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3453
3454         assert (_meter);
3455
3456         _meter->meter ();
3457
3458         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3459
3460                 boost::shared_ptr<Send> s;
3461                 boost::shared_ptr<Return> r;
3462
3463                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3464                         s->meter()->meter();
3465                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3466                         r->meter()->meter ();
3467                 }
3468         }
3469 }
3470
3471 boost::shared_ptr<Pannable>
3472 Route::pannable() const
3473 {
3474         return _pannable;
3475 }
3476
3477 boost::shared_ptr<Panner>
3478 Route::panner() const
3479 {
3480         /* may be null ! */
3481         return _main_outs->panner_shell()->panner();
3482 }
3483
3484 boost::shared_ptr<PannerShell>
3485 Route::panner_shell() const
3486 {
3487         return _main_outs->panner_shell();
3488 }
3489
3490 boost::shared_ptr<AutomationControl>
3491 Route::gain_control() const
3492 {
3493         return _amp->gain_control();
3494 }
3495
3496 boost::shared_ptr<AutomationControl>
3497 Route::get_control (const Evoral::Parameter& param)
3498 {
3499         /* either we own the control or .... */
3500
3501         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3502
3503         if (!c) {
3504
3505                 /* maybe one of our processors does or ... */
3506
3507                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3508                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3509                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3510                                 break;
3511                         }
3512                 }
3513         }
3514
3515         if (!c) {
3516
3517                 /* nobody does so we'll make a new one */
3518
3519                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3520                 add_control(c);
3521         }
3522
3523         return c;
3524 }
3525
3526 boost::shared_ptr<Processor>
3527 Route::nth_plugin (uint32_t n)
3528 {
3529         Glib::RWLock::ReaderLock lm (_processor_lock);
3530         ProcessorList::iterator i;
3531
3532         for (i = _processors.begin(); i != _processors.end(); ++i) {
3533                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3534                         if (n-- == 0) {
3535                                 return *i;
3536                         }
3537                 }
3538         }
3539
3540         return boost::shared_ptr<Processor> ();
3541 }
3542
3543 boost::shared_ptr<Processor>
3544 Route::nth_send (uint32_t n)
3545 {
3546         Glib::RWLock::ReaderLock lm (_processor_lock);
3547         ProcessorList::iterator i;
3548
3549         for (i = _processors.begin(); i != _processors.end(); ++i) {
3550                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3551                         if (n-- == 0) {
3552                                 return *i;
3553                         }
3554                 }
3555         }
3556
3557         return boost::shared_ptr<Processor> ();
3558 }
3559
3560 bool
3561 Route::has_io_processor_named (const string& name)
3562 {
3563         Glib::RWLock::ReaderLock lm (_processor_lock);
3564         ProcessorList::iterator i;
3565
3566         for (i = _processors.begin(); i != _processors.end(); ++i) {
3567                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3568                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3569                         if ((*i)->name() == name) {
3570                                 return true;
3571                         }
3572                 }
3573         }
3574
3575         return false;
3576 }
3577
3578 MuteMaster::MutePoint
3579 Route::mute_points () const
3580 {
3581         return _mute_master->mute_points ();
3582 }
3583
3584 void
3585 Route::set_processor_positions ()
3586 {
3587         Glib::RWLock::ReaderLock lm (_processor_lock);
3588
3589         bool had_amp = false;
3590         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3591                 (*i)->set_pre_fader (!had_amp);
3592                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3593                         had_amp = true;
3594                 }
3595         }
3596 }
3597
3598 /** Called when there is a proposed change to the input port count */
3599 bool
3600 Route::input_port_count_changing (ChanCount to)
3601 {
3602         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3603         if (c.empty()) {
3604                 /* The processors cannot be configured with the new input arrangement, so
3605                    block the change.
3606                 */
3607                 return true;
3608         }
3609
3610         /* The change is ok */
3611         return false;
3612 }
3613
3614 list<string>
3615 Route::unknown_processors () const
3616 {
3617         list<string> p;
3618
3619         Glib::RWLock::ReaderLock lm (_processor_lock);
3620         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3621                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3622                         p.push_back ((*i)->name ());
3623                 }
3624         }
3625
3626         return p;
3627 }