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