libs/ardour/route.cc

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