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         assert (!AudioEngine::instance()->process_lock().trylock());
1630         if (!_in_configure_processors) {
1631                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1632                 return configure_processors_unlocked (err);
1633         }
1634
1635         return 0;
1636 }
1637
1638 ChanCount
1639 Route::input_streams () const
1640 {
1641         return _input->n_ports ();
1642 }
1643
1644 list<pair<ChanCount, ChanCount> >
1645 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1646 {
1647         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1648
1649         return try_configure_processors_unlocked (in, err);
1650 }
1651
1652 list<pair<ChanCount, ChanCount> >
1653 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1654 {
1655         // Check each processor in order to see if we can configure as requested
1656         ChanCount out;
1657         list<pair<ChanCount, ChanCount> > configuration;
1658         uint32_t index = 0;
1659
1660         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1661         DEBUG_TRACE (DEBUG::Processors, "{\n");
1662
1663         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1664
1665                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1666                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1667                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1668                         return list<pair<ChanCount, ChanCount> > ();
1669                 }
1670
1671                 if ((*p)->can_support_io_configuration(in, out)) {
1672                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1673                         configuration.push_back(make_pair(in, out));
1674                         in = out;
1675                 } else {
1676                         if (err) {
1677                                 err->index = index;
1678                                 err->count = in;
1679                         }
1680                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1681                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1682                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1683                         return list<pair<ChanCount, ChanCount> > ();
1684                 }
1685         }
1686
1687         DEBUG_TRACE (DEBUG::Processors, "}\n");
1688
1689         return configuration;
1690 }
1691
1692 /** Set the input/output configuration of each processor in the processors list.
1693  *  Caller must hold process lock.
1694  *  Return 0 on success, otherwise configuration is impossible.
1695  */
1696 int
1697 Route::configure_processors_unlocked (ProcessorStreams* err)
1698 {
1699         assert (!AudioEngine::instance()->process_lock().trylock());
1700
1701         if (_in_configure_processors) {
1702                 return 0;
1703         }
1704
1705         /* put invisible processors where they should be */
1706         setup_invisible_processors ();
1707
1708         _in_configure_processors = true;
1709
1710         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1711
1712         if (configuration.empty ()) {
1713                 _in_configure_processors = false;
1714                 return -1;
1715         }
1716
1717         ChanCount out;
1718         bool seen_mains_out = false;
1719         processor_out_streams = _input->n_ports();
1720         processor_max_streams.reset();
1721
1722         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1723         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1724
1725                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1726                         break;
1727                 }
1728
1729                 (*p)->configure_io(c->first, c->second);
1730                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1731                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1732                 out = c->second;
1733
1734                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1735                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1736                         /* main delivery will increase port count to match input.
1737                          * the Delivery::Main is usually the last processor - followed only by
1738                          * 'MeterOutput'.
1739                          */
1740                         seen_mains_out = true;
1741                 }
1742                 if (!seen_mains_out) {
1743                         processor_out_streams = out;
1744                 }
1745         }
1746
1747
1748         if (_meter) {
1749                 _meter->reset_max_channels (processor_max_streams);
1750         }
1751
1752         /* make sure we have sufficient scratch buffers to cope with the new processor
1753            configuration
1754         */
1755         _session.ensure_buffers (n_process_buffers ());
1756
1757         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1758
1759         _in_configure_processors = false;
1760         return 0;
1761 }
1762
1763 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1764  *  @param state New active state for those processors.
1765  */
1766 void
1767 Route::all_visible_processors_active (bool state)
1768 {
1769         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1770
1771         if (_processors.empty()) {
1772                 return;
1773         }
1774
1775         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1776                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1777                         continue;
1778                 }
1779
1780                 if (state) {
1781                         (*i)->activate ();
1782                 } else {
1783                         (*i)->deactivate ();
1784                 }
1785         }
1786
1787         _session.set_dirty ();
1788 }
1789
1790 int
1791 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1792 {
1793         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1794            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1795            processors in the current actual processor list that are hidden. Any visible processors
1796            in the current list but not in "new_order" will be assumed to be deleted.
1797         */
1798
1799         {
1800                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1801                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1802                 ProcessorState pstate (this);
1803
1804                 ProcessorList::iterator oiter;
1805                 ProcessorList::const_iterator niter;
1806                 ProcessorList as_it_will_be;
1807
1808                 oiter = _processors.begin();
1809                 niter = new_order.begin();
1810
1811                 while (niter !=  new_order.end()) {
1812
1813                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1814                            then append it to the temp list.
1815
1816                            Otherwise, see if the next processor in the old list is in the new list. if not,
1817                            its been deleted. If its there, append it to the temp list.
1818                         */
1819
1820                         if (oiter == _processors.end()) {
1821
1822                                 /* no more elements in the old list, so just stick the rest of
1823                                    the new order onto the temp list.
1824                                 */
1825
1826                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1827                                 while (niter != new_order.end()) {
1828                                         ++niter;
1829                                 }
1830                                 break;
1831
1832                         } else {
1833
1834                                 if (!(*oiter)->display_to_user()) {
1835
1836                                         as_it_will_be.push_back (*oiter);
1837
1838                                 } else {
1839
1840                                         /* visible processor: check that its in the new order */
1841
1842                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1843                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1844                                         } else {
1845                                                 /* ignore this one, and add the next item from the new order instead */
1846                                                 as_it_will_be.push_back (*niter);
1847                                                 ++niter;
1848                                         }
1849                                 }
1850
1851                                 /* now remove from old order - its taken care of no matter what */
1852                                 oiter = _processors.erase (oiter);
1853                         }
1854
1855                 }
1856
1857                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1858
1859                 /* If the meter is in a custom position, find it and make a rough note of its position */
1860                 maybe_note_meter_position ();
1861
1862                 if (configure_processors_unlocked (err)) {
1863                         pstate.restore ();
1864                         return -1;
1865                 }
1866         }
1867
1868         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1869         set_processor_positions ();
1870
1871         return 0;
1872 }
1873
1874 XMLNode&
1875 Route::get_state()
1876 {
1877         return state(true);
1878 }
1879
1880 XMLNode&
1881 Route::get_template()
1882 {
1883         return state(false);
1884 }
1885
1886 XMLNode&
1887 Route::state(bool full_state)
1888 {
1889         XMLNode *node = new XMLNode("Route");
1890         ProcessorList::iterator i;
1891         char buf[32];
1892
1893         id().print (buf, sizeof (buf));
1894         node->add_property("id", buf);
1895         node->add_property ("name", _name);
1896         node->add_property("default-type", _default_type.to_string());
1897
1898         if (_flags) {
1899                 node->add_property("flags", enum_2_string (_flags));
1900         }
1901
1902         node->add_property("active", _active?"yes":"no");
1903         string p;
1904         boost::to_string (_phase_invert, p);
1905         node->add_property("phase-invert", p);
1906         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1907         node->add_property("meter-point", enum_2_string (_meter_point));
1908
1909         node->add_property("meter-type", enum_2_string (_meter_type));
1910
1911         if (_route_group) {
1912                 node->add_property("route-group", _route_group->name());
1913         }
1914
1915         snprintf (buf, sizeof (buf), "%d", _order_key);
1916         node->add_property ("order-key", buf);
1917         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1918         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1919         node->add_property ("soloed-by-upstream", buf);
1920         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1921         node->add_property ("soloed-by-downstream", buf);
1922         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1923         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1924
1925         node->add_child_nocopy (_input->state (full_state));
1926         node->add_child_nocopy (_output->state (full_state));
1927         node->add_child_nocopy (_solo_control->get_state ());
1928         node->add_child_nocopy (_mute_control->get_state ());
1929         node->add_child_nocopy (_mute_master->get_state ());
1930
1931         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1932         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1933         remote_control_node->add_property (X_("id"), buf);
1934         node->add_child_nocopy (*remote_control_node);
1935
1936         if (_comment.length()) {
1937                 XMLNode *cmt = node->add_child ("Comment");
1938                 cmt->add_content (_comment);
1939         }
1940
1941         if (_pannable) {
1942                 node->add_child_nocopy (_pannable->state (full_state));
1943         }
1944
1945         for (i = _processors.begin(); i != _processors.end(); ++i) {
1946                 if (!full_state) {
1947                         /* template save: do not include internal sends functioning as
1948                            aux sends because the chance of the target ID
1949                            in the session where this template is used
1950                            is not very likely.
1951
1952                            similarly, do not save listen sends which connect to
1953                            the monitor section, because these will always be
1954                            added if necessary.
1955                         */
1956                         boost::shared_ptr<InternalSend> is;
1957
1958                         if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
1959                                 if (is->role() == Delivery::Listen) {
1960                                         continue;
1961                                 }
1962                         }
1963                 }
1964                 node->add_child_nocopy((*i)->state (full_state));
1965         }
1966
1967         if (_extra_xml) {
1968                 node->add_child_copy (*_extra_xml);
1969         }
1970
1971         if (_custom_meter_position_noted) {
1972                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
1973                 if (after) {
1974                         after->id().print (buf, sizeof (buf));
1975                         node->add_property (X_("processor-after-last-custom-meter"), buf);
1976                 }
1977
1978                 node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
1979         }
1980
1981         return *node;
1982 }
1983
1984 int
1985 Route::set_state (const XMLNode& node, int version)
1986 {
1987         if (version < 3000) {
1988                 return set_state_2X (node, version);
1989         }
1990
1991         XMLNodeList nlist;
1992         XMLNodeConstIterator niter;
1993         XMLNode *child;
1994         const XMLProperty *prop;
1995
1996         if (node.name() != "Route"){
1997                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1998                 return -1;
1999         }
2000
2001         if ((prop = node.property (X_("name"))) != 0) {
2002                 Route::set_name (prop->value());
2003         }
2004
2005         set_id (node);
2006         _initial_io_setup = true;
2007
2008         if ((prop = node.property (X_("flags"))) != 0) {
2009                 _flags = Flag (string_2_enum (prop->value(), _flags));
2010         } else {
2011                 _flags = Flag (0);
2012         }
2013
2014         if (is_master() || is_monitor() || is_auditioner()) {
2015                 _mute_master->set_solo_ignore (true);
2016         }
2017
2018         if (is_monitor()) {
2019                 /* monitor bus does not get a panner, but if (re)created
2020                    via XML, it will already have one by the time we
2021                    call ::set_state(). so ... remove it.
2022                 */
2023                 unpan ();
2024         }
2025
2026         /* add all processors (except amp, which is always present) */
2027
2028         nlist = node.children();
2029         XMLNode processor_state (X_("processor_state"));
2030
2031         Stateful::save_extra_xml (node);
2032
2033         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2034
2035                 child = *niter;
2036
2037                 if (child->name() == IO::state_node_name) {
2038                         if ((prop = child->property (X_("direction"))) == 0) {
2039                                 continue;
2040                         }
2041
2042                         if (prop->value() == "Input") {
2043                                 _input->set_state (*child, version);
2044                         } else if (prop->value() == "Output") {
2045                                 _output->set_state (*child, version);
2046                         }
2047                 }
2048
2049                 if (child->name() == X_("Processor")) {
2050                         processor_state.add_child_copy (*child);
2051                 }
2052
2053                 if (child->name() == X_("Pannable")) {
2054                         if (_pannable) {
2055                                 _pannable->set_state (*child, version);
2056                         } else {
2057                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2058                         }
2059                 }
2060         }
2061
2062         if ((prop = node.property (X_("meter-point"))) != 0) {
2063                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2064                 set_meter_point (mp, true);
2065                 if (_meter) {
2066                         _meter->set_display_to_user (_meter_point == MeterCustom);
2067                 }
2068         }
2069
2070         if ((prop = node.property (X_("meter-type"))) != 0) {
2071                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2072         }
2073
2074         _initial_io_setup = false;
2075
2076         set_processor_state (processor_state);
2077
2078         // this looks up the internal instrument in processors
2079         reset_instrument_info();
2080
2081         if ((prop = node.property ("self-solo")) != 0) {
2082                 set_self_solo (string_is_affirmative (prop->value()));
2083         }
2084
2085         if ((prop = node.property ("soloed-by-upstream")) != 0) {
2086                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2087                 mod_solo_by_others_upstream (atoi (prop->value()));
2088         }
2089
2090         if ((prop = node.property ("soloed-by-downstream")) != 0) {
2091                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2092                 mod_solo_by_others_downstream (atoi (prop->value()));
2093         }
2094
2095         if ((prop = node.property ("solo-isolated")) != 0) {
2096                 set_solo_isolated (string_is_affirmative (prop->value()), this);
2097         }
2098
2099         if ((prop = node.property ("solo-safe")) != 0) {
2100                 set_solo_safe (string_is_affirmative (prop->value()), this);
2101         }
2102
2103         if ((prop = node.property (X_("phase-invert"))) != 0) {
2104                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2105         }
2106
2107         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2108                 set_denormal_protection (string_is_affirmative (prop->value()));
2109         }
2110
2111         if ((prop = node.property (X_("active"))) != 0) {
2112                 bool yn = string_is_affirmative (prop->value());
2113                 _active = !yn; // force switch
2114                 set_active (yn, this);
2115         }
2116
2117         if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering)
2118                 set_order_key (atoi(prop->value()));
2119         }
2120
2121         if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys
2122
2123                 int32_t n;
2124
2125                 string::size_type colon, equal;
2126                 string remaining = prop->value();
2127
2128                 while (remaining.length()) {
2129
2130                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2131                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2132                                       << endmsg;
2133                         } else {
2134                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2135                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2136                                               << endmsg;
2137                                 } else {
2138                                         string keyname = remaining.substr (0, equal);
2139
2140                                         if ((keyname == "EditorSort") || (keyname == "editor")) {
2141                                                 cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl;
2142                                                 set_order_key (n);
2143                                         }
2144                                 }
2145                         }
2146
2147                         colon = remaining.find_first_of (':');
2148
2149                         if (colon != string::npos) {
2150                                 remaining = remaining.substr (colon+1);
2151                         } else {
2152                                 break;
2153                         }
2154                 }
2155         }
2156
2157         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2158                 PBD::ID id (prop->value ());
2159                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2160                 ProcessorList::const_iterator i = _processors.begin ();
2161                 while (i != _processors.end() && (*i)->id() != id) {
2162                         ++i;
2163                 }
2164
2165                 if (i != _processors.end ()) {
2166                         _processor_after_last_custom_meter = *i;
2167                         _custom_meter_position_noted = true;
2168                 }
2169         }
2170
2171         if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
2172                 _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
2173         }
2174
2175         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2176                 child = *niter;
2177
2178                 if (child->name() == X_("Comment")) {
2179
2180                         /* XXX this is a terrible API design in libxml++ */
2181
2182                         XMLNode *cmt = *(child->children().begin());
2183                         _comment = cmt->content();
2184
2185                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2186                         if (prop->value() == "solo") {
2187                                 _solo_control->set_state (*child, version);
2188                         } else if (prop->value() == "mute") {
2189                                 _mute_control->set_state (*child, version);
2190                         }
2191
2192                 } else if (child->name() == X_("RemoteControl")) {
2193                         if ((prop = child->property (X_("id"))) != 0) {
2194                                 int32_t x;
2195                                 sscanf (prop->value().c_str(), "%d", &x);
2196                                 set_remote_control_id_internal (x);
2197                         }
2198
2199                 } else if (child->name() == X_("MuteMaster")) {
2200                         _mute_master->set_state (*child, version);
2201                 }
2202         }
2203
2204         return 0;
2205 }
2206
2207 int
2208 Route::set_state_2X (const XMLNode& node, int version)
2209 {
2210         XMLNodeList nlist;
2211         XMLNodeConstIterator niter;
2212         XMLNode *child;
2213         const XMLProperty *prop;
2214
2215         /* 2X things which still remain to be handled:
2216          * default-type
2217          * automation
2218          * controlouts
2219          */
2220
2221         if (node.name() != "Route") {
2222                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2223                 return -1;
2224         }
2225
2226         if ((prop = node.property (X_("flags"))) != 0) {
2227                 string f = prop->value ();
2228                 boost::replace_all (f, "ControlOut", "MonitorOut");
2229                 _flags = Flag (string_2_enum (f, _flags));
2230         } else {
2231                 _flags = Flag (0);
2232         }
2233
2234         if (is_master() || is_monitor() || is_auditioner()) {
2235                 _mute_master->set_solo_ignore (true);
2236         }
2237
2238         if ((prop = node.property (X_("phase-invert"))) != 0) {
2239                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2240                 if (string_is_affirmative (prop->value ())) {
2241                         p.set ();
2242                 }
2243                 set_phase_invert (p);
2244         }
2245
2246         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2247                 set_denormal_protection (string_is_affirmative (prop->value()));
2248         }
2249
2250         if ((prop = node.property (X_("soloed"))) != 0) {
2251                 bool yn = string_is_affirmative (prop->value());
2252
2253                 /* XXX force reset of solo status */
2254
2255                 set_solo (yn, this);
2256         }
2257
2258         if ((prop = node.property (X_("muted"))) != 0) {
2259
2260                 bool first = true;
2261                 bool muted = string_is_affirmative (prop->value());
2262
2263                 if (muted) {
2264
2265                         string mute_point;
2266
2267                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2268
2269                                 if (string_is_affirmative (prop->value())){
2270                                         mute_point = mute_point + "PreFader";
2271                                         first = false;
2272                                 }
2273                         }
2274
2275                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2276
2277                                 if (string_is_affirmative (prop->value())){
2278
2279                                         if (!first) {
2280                                                 mute_point = mute_point + ",";
2281                                         }
2282
2283                                         mute_point = mute_point + "PostFader";
2284                                         first = false;
2285                                 }
2286                         }
2287
2288                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2289
2290                                 if (string_is_affirmative (prop->value())){
2291
2292                                         if (!first) {
2293                                                 mute_point = mute_point + ",";
2294                                         }
2295
2296                                         mute_point = mute_point + "Listen";
2297                                         first = false;
2298                                 }
2299                         }
2300
2301                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2302
2303                                 if (string_is_affirmative (prop->value())){
2304
2305                                         if (!first) {
2306                                                 mute_point = mute_point + ",";
2307                                         }
2308
2309                                         mute_point = mute_point + "Main";
2310                                 }
2311                         }
2312
2313                         _mute_master->set_mute_points (mute_point);
2314                         _mute_master->set_muted_by_self (true);
2315                 }
2316         }
2317
2318         if ((prop = node.property (X_("meter-point"))) != 0) {
2319                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2320         }
2321
2322         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2323            don't mean the same thing.
2324         */
2325
2326         if ((prop = node.property (X_("order-keys"))) != 0) {
2327
2328                 int32_t n;
2329
2330                 string::size_type colon, equal;
2331                 string remaining = prop->value();
2332
2333                 while (remaining.length()) {
2334
2335                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2336                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2337                                         << endmsg;
2338                         } else {
2339                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2340                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2341                                                 << endmsg;
2342                                 } else {
2343                                         string keyname = remaining.substr (0, equal);
2344
2345                                         if (keyname == "EditorSort" || keyname == "editor") {
2346                                                 info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg;
2347                                                 set_order_key (n);
2348                                         }
2349                                 }
2350                         }
2351
2352                         colon = remaining.find_first_of (':');
2353
2354                         if (colon != string::npos) {
2355                                 remaining = remaining.substr (colon+1);
2356                         } else {
2357                                 break;
2358                         }
2359                 }
2360         }
2361
2362         /* IOs */
2363
2364         nlist = node.children ();
2365         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2366
2367                 child = *niter;
2368
2369                 if (child->name() == IO::state_node_name) {
2370
2371                         /* there is a note in IO::set_state_2X() about why we have to call
2372                            this directly.
2373                            */
2374
2375                         _input->set_state_2X (*child, version, true);
2376                         _output->set_state_2X (*child, version, false);
2377
2378                         if ((prop = child->property (X_("name"))) != 0) {
2379                                 Route::set_name (prop->value ());
2380                         }
2381
2382                         set_id (*child);
2383
2384                         if ((prop = child->property (X_("active"))) != 0) {
2385                                 bool yn = string_is_affirmative (prop->value());
2386                                 _active = !yn; // force switch
2387                                 set_active (yn, this);
2388                         }
2389
2390                         if ((prop = child->property (X_("gain"))) != 0) {
2391                                 gain_t val;
2392
2393                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2394                                         _amp->gain_control()->set_value (val);
2395                                 }
2396                         }
2397
2398                         /* Set up Panners in the IO */
2399                         XMLNodeList io_nlist = child->children ();
2400
2401                         XMLNodeConstIterator io_niter;
2402                         XMLNode *io_child;
2403
2404                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2405
2406                                 io_child = *io_niter;
2407
2408                                 if (io_child->name() == X_("Panner")) {
2409                                         _main_outs->panner_shell()->set_state(*io_child, version);
2410                                 } else if (io_child->name() == X_("Automation")) {
2411                                         /* IO's automation is for the fader */
2412                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2413                                 }
2414                         }
2415                 }
2416         }
2417
2418         XMLNodeList redirect_nodes;
2419
2420         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2421
2422                 child = *niter;
2423
2424                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2425                         redirect_nodes.push_back(child);
2426                 }
2427
2428         }
2429
2430         set_processor_state_2X (redirect_nodes, version);
2431
2432         Stateful::save_extra_xml (node);
2433
2434         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2435                 child = *niter;
2436
2437                 if (child->name() == X_("Comment")) {
2438
2439                         /* XXX this is a terrible API design in libxml++ */
2440
2441                         XMLNode *cmt = *(child->children().begin());
2442                         _comment = cmt->content();
2443
2444                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2445                         if (prop->value() == X_("solo")) {
2446                                 _solo_control->set_state (*child, version);
2447                         } else if (prop->value() == X_("mute")) {
2448                                 _mute_control->set_state (*child, version);
2449                         }
2450
2451                 } else if (child->name() == X_("RemoteControl")) {
2452                         if ((prop = child->property (X_("id"))) != 0) {
2453                                 int32_t x;
2454                                 sscanf (prop->value().c_str(), "%d", &x);
2455                                 set_remote_control_id_internal (x);
2456                         }
2457
2458                 }
2459         }
2460
2461         return 0;
2462 }
2463
2464 XMLNode&
2465 Route::get_processor_state ()
2466 {
2467         XMLNode* root = new XMLNode (X_("redirects"));
2468         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2469                 root->add_child_nocopy ((*i)->state (true));
2470         }
2471
2472         return *root;
2473 }
2474
2475 void
2476 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2477 {
2478         /* We don't bother removing existing processors not in nList, as this
2479            method will only be called when creating a Route from scratch, not
2480            for undo purposes.  Just put processors in at the appropriate place
2481            in the list.
2482         */
2483
2484         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2485                 add_processor_from_xml_2X (**i, version);
2486         }
2487 }
2488
2489 void
2490 Route::set_processor_state (const XMLNode& node)
2491 {
2492         const XMLNodeList &nlist = node.children();
2493         XMLNodeConstIterator niter;
2494         ProcessorList new_order;
2495         bool must_configure = false;
2496
2497         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2498
2499                 XMLProperty* prop = (*niter)->property ("type");
2500
2501                 if (prop->value() == "amp") {
2502                         _amp->set_state (**niter, Stateful::current_state_version);
2503                         new_order.push_back (_amp);
2504                 } else if (prop->value() == "meter") {
2505                         _meter->set_state (**niter, Stateful::current_state_version);
2506                         new_order.push_back (_meter);
2507                 } else if (prop->value() == "main-outs") {
2508                         _main_outs->set_state (**niter, Stateful::current_state_version);
2509                 } else if (prop->value() == "intreturn") {
2510                         if (!_intreturn) {
2511                                 _intreturn.reset (new InternalReturn (_session));
2512                                 must_configure = true;
2513                         }
2514                         _intreturn->set_state (**niter, Stateful::current_state_version);
2515                 } else if (is_monitor() && prop->value() == "monitor") {
2516                         if (!_monitor_control) {
2517                                 _monitor_control.reset (new MonitorProcessor (_session));
2518                                 must_configure = true;
2519                         }
2520                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2521                 } else if (prop->value() == "capture") {
2522                         /* CapturingProcessor should never be restored, it's always
2523                            added explicitly when needed */
2524                 } else {
2525                         ProcessorList::iterator o;
2526
2527                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2528                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2529                                 if (id_prop && (*o)->id() == id_prop->value()) {
2530                                         (*o)->set_state (**niter, Stateful::current_state_version);
2531                                         new_order.push_back (*o);
2532                                         break;
2533                                 }
2534                         }
2535
2536                         // If the processor (*niter) is not on the route then create it
2537
2538                         if (o == _processors.end()) {
2539
2540                                 boost::shared_ptr<Processor> processor;
2541
2542                                 if (prop->value() == "intsend") {
2543
2544                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2545
2546                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2547                                            prop->value() == "lv2" ||
2548                                            prop->value() == "windows-vst" ||
2549                                            prop->value() == "lxvst" ||
2550                                            prop->value() == "audiounit") {
2551
2552                                         processor.reset (new PluginInsert(_session));
2553
2554                                 } else if (prop->value() == "port") {
2555
2556                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2557
2558                                 } else if (prop->value() == "send") {
2559
2560                                         processor.reset (new Send (_session, _pannable, _mute_master));
2561
2562                                 } else {
2563                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2564                                         continue;
2565                                 }
2566
2567                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2568                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2569                                         processor.reset (new UnknownProcessor (_session, **niter));
2570                                 }
2571
2572                                 /* we have to note the monitor send here, otherwise a new one will be created
2573                                    and the state of this one will be lost.
2574                                 */
2575                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2576                                 if (isend && isend->role() == Delivery::Listen) {
2577                                         _monitor_send = isend;
2578                                 }
2579
2580                                 /* it doesn't matter if invisible processors are added here, as they
2581                                    will be sorted out by setup_invisible_processors () shortly.
2582                                 */
2583
2584                                 new_order.push_back (processor);
2585                                 must_configure = true;
2586                         }
2587                 }
2588         }
2589
2590         {
2591                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2592                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2593                 _processors = new_order;
2594
2595                 if (must_configure) {
2596                         configure_processors_unlocked (0);
2597                 }
2598
2599                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2600
2601                         (*i)->set_owner (this);
2602                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2603
2604                         boost::shared_ptr<PluginInsert> pi;
2605
2606                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2607                                 if (pi->has_no_inputs ()) {
2608                                         _have_internal_generator = true;
2609                                         break;
2610                                 }
2611                         }
2612                 }
2613         }
2614
2615         reset_instrument_info ();
2616         processors_changed (RouteProcessorChange ());
2617         set_processor_positions ();
2618 }
2619
2620 void
2621 Route::curve_reallocate ()
2622 {
2623 //      _gain_automation_curve.finish_resize ();
2624 //      _pan_automation_curve.finish_resize ();
2625 }
2626
2627 void
2628 Route::silence (framecnt_t nframes)
2629 {
2630         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2631         if (!lm.locked()) {
2632                 return;
2633         }
2634
2635         silence_unlocked (nframes);
2636 }
2637
2638 void
2639 Route::silence_unlocked (framecnt_t nframes)
2640 {
2641         /* Must be called with the processor lock held */
2642
2643         if (!_silent) {
2644
2645                 _output->silence (nframes);
2646
2647                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2648                         boost::shared_ptr<PluginInsert> pi;
2649
2650                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2651                                 // skip plugins, they don't need anything when we're not active
2652                                 continue;
2653                         }
2654
2655                         (*i)->silence (nframes);
2656                 }
2657
2658                 if (nframes == _session.get_block_size()) {
2659                         // _silent = true;
2660                 }
2661         }
2662 }
2663
2664 void
2665 Route::add_internal_return ()
2666 {
2667         if (!_intreturn) {
2668                 _intreturn.reset (new InternalReturn (_session));
2669                 add_processor (_intreturn, PreFader);
2670         }
2671 }
2672
2673 void
2674 Route::add_send_to_internal_return (InternalSend* send)
2675 {
2676         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2677
2678         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2679                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2680
2681                 if (d) {
2682                         return d->add_send (send);
2683                 }
2684         }
2685 }
2686
2687 void
2688 Route::remove_send_from_internal_return (InternalSend* send)
2689 {
2690         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2691
2692         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2693                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2694
2695                 if (d) {
2696                         return d->remove_send (send);
2697                 }
2698         }
2699 }
2700
2701 void
2702 Route::enable_monitor_send ()
2703 {
2704         /* Caller must hold process lock */
2705         assert (!AudioEngine::instance()->process_lock().trylock());
2706
2707         /* master never sends to monitor section via the normal mechanism */
2708         assert (!is_master ());
2709
2710         /* make sure we have one */
2711         if (!_monitor_send) {
2712                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2713                 _monitor_send->set_display_to_user (false);
2714         }
2715
2716         /* set it up */
2717         configure_processors (0);
2718 }
2719
2720 /** Add an aux send to a route.
2721  *  @param route route to send to.
2722  *  @param before Processor to insert before, or 0 to insert at the end.
2723  */
2724 int
2725 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2726 {
2727         assert (route != _session.monitor_out ());
2728
2729         {
2730                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
2731
2732                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2733
2734                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2735
2736                         if (d && d->target_route() == route) {
2737                                 /* already listening via the specified IO: do nothing */
2738                                 return 0;
2739                         }
2740                 }
2741         }
2742
2743         try {
2744
2745                 boost::shared_ptr<InternalSend> listener;
2746
2747                 {
2748                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2749                         listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2750                 }
2751
2752                 add_processor (listener, before);
2753
2754         } catch (failed_constructor& err) {
2755                 return -1;
2756         }
2757
2758         return 0;
2759 }
2760
2761 void
2762 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
2763 {
2764         ProcessorStreams err;
2765         ProcessorList::iterator tmp;
2766
2767         {
2768                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
2769
2770                 /* have to do this early because otherwise processor reconfig
2771                  * will put _monitor_send back in the list
2772                  */
2773
2774                 if (route == _session.monitor_out()) {
2775                         _monitor_send.reset ();
2776                 }
2777
2778           again:
2779                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2780
2781                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2782
2783                         if (d && d->target_route() == route) {
2784                                 rl.release ();
2785                                 remove_processor (*x, &err, false);
2786                                 rl.acquire ();
2787
2788                                 /* list could have been demolished while we dropped the lock
2789                                    so start over.
2790                                 */
2791
2792                                 goto again;
2793                         }
2794                 }
2795         }
2796 }
2797
2798 void
2799 Route::set_comment (string cmt, void *src)
2800 {
2801         _comment = cmt;
2802         comment_changed (src);
2803         _session.set_dirty ();
2804 }
2805
2806 bool
2807 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2808 {
2809         FeedRecord fr (other, via_sends_only);
2810
2811         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2812
2813         if (!result.second) {
2814
2815                 /* already a record for "other" - make sure sends-only information is correct */
2816                 if (!via_sends_only && result.first->sends_only) {
2817                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2818                         frp->sends_only = false;
2819                 }
2820         }
2821
2822         return result.second;
2823 }
2824
2825 void
2826 Route::clear_fed_by ()
2827 {
2828         _fed_by.clear ();
2829 }
2830
2831 bool
2832 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2833 {
2834         const FedBy& fed_by (other->fed_by());
2835
2836         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2837                 boost::shared_ptr<Route> sr = f->r.lock();
2838
2839                 if (sr && (sr.get() == this)) {
2840
2841                         if (via_sends_only) {
2842                                 *via_sends_only = f->sends_only;
2843                         }
2844
2845                         return true;
2846                 }
2847         }
2848
2849         return false;
2850 }
2851
2852 bool
2853 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
2854 {
2855         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2856
2857         if (_output->connected_to (other->input())) {
2858                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2859                 if (via_send_only) {
2860                         *via_send_only = false;
2861                 }
2862
2863                 return true;
2864         }
2865
2866
2867         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2868
2869                 boost::shared_ptr<IOProcessor> iop;
2870
2871                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2872                         if (iop->feeds (other)) {
2873                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2874                                 if (via_send_only) {
2875                                         *via_send_only = true;
2876                                 }
2877                                 return true;
2878                         } else {
2879                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2880                         }
2881                 } else {
2882                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2883                 }
2884
2885         }
2886
2887         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2888         return false;
2889 }
2890
2891 bool
2892 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
2893 {
2894         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
2895 }
2896
2897 /** Called from the (non-realtime) butler thread when the transport is stopped */
2898 void
2899 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
2900 {
2901         framepos_t now = _session.transport_frame();
2902
2903         {
2904                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2905
2906                 Automatable::transport_stopped (now);
2907
2908                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2909
2910                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2911                                 (*i)->flush ();
2912                         }
2913
2914                         (*i)->transport_stopped (now);
2915                 }
2916         }
2917
2918         _roll_delay = _initial_delay;
2919 }
2920
2921 void
2922 Route::input_change_handler (IOChange change, void * /*src*/)
2923 {
2924         bool need_to_queue_solo_change = true;
2925
2926         if ((change.type & IOChange::ConfigurationChanged)) {
2927                 /* This is called with the process lock held if change
2928                    contains ConfigurationChanged
2929                 */
2930                 need_to_queue_solo_change = false;
2931                 configure_processors (0);
2932                 _phase_invert.resize (_input->n_ports().n_audio ());
2933                 io_changed (); /* EMIT SIGNAL */
2934         }
2935
2936         if (!_input->connected() && _soloed_by_others_upstream) {
2937                 if (need_to_queue_solo_change) {
2938                         _session.cancel_solo_after_disconnect (shared_from_this(), true);
2939                 } else {
2940                         cancel_solo_after_disconnect (true);
2941                 }
2942         }
2943 }
2944
2945 void
2946 Route::output_change_handler (IOChange change, void * /*src*/)
2947 {
2948         bool need_to_queue_solo_change = true;
2949         if (_initial_io_setup) {
2950                 return;
2951         }
2952
2953         if ((change.type & IOChange::ConfigurationChanged)) {
2954                 /* This is called with the process lock held if change
2955                    contains ConfigurationChanged
2956                 */
2957                 need_to_queue_solo_change = false;
2958                 configure_processors (0);
2959                 io_changed (); /* EMIT SIGNAL */
2960         }
2961
2962         if (!_output->connected() && _soloed_by_others_downstream) {
2963                 if (need_to_queue_solo_change) {
2964                         _session.cancel_solo_after_disconnect (shared_from_this(), false);
2965                 } else {
2966                         cancel_solo_after_disconnect (false);
2967                 }
2968         }
2969 }
2970
2971 void
2972 Route::cancel_solo_after_disconnect (bool upstream)
2973 {
2974         if (upstream) {
2975                 _soloed_by_others_upstream = 0;
2976         } else {
2977                 _soloed_by_others_downstream = 0;
2978         }
2979         set_mute_master_solo ();
2980         solo_changed (false, this);
2981 }
2982
2983 uint32_t
2984 Route::pans_required () const
2985 {
2986         if (n_outputs().n_audio() < 2) {
2987                 return 0;
2988         }
2989
2990         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2991 }
2992
2993 int
2994 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
2995 {
2996         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
2997
2998         if (!lm.locked()) {
2999                 return 0;
3000         }
3001
3002         if (n_outputs().n_total() == 0) {
3003                 return 0;
3004         }
3005
3006         if (!_active || n_inputs() == ChanCount::ZERO)  {
3007                 silence_unlocked (nframes);
3008                 return 0;
3009         }
3010
3011         if (session_state_changing) {
3012                 if (_session.transport_speed() != 0.0f) {
3013                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3014                            so we cannot use them. Be silent till this is over.
3015
3016                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3017                         */
3018                         silence_unlocked (nframes);
3019                         return 0;
3020                 }
3021                 /* we're really not rolling, so we're either delivery silence or actually
3022                    monitoring, both of which are safe to do while session_state_changing is true.
3023                 */
3024         }
3025
3026         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3027
3028         fill_buffers_with_input (bufs, _input, nframes);
3029
3030         if (_meter_point == MeterInput) {
3031                 _meter->run (bufs, start_frame, end_frame, nframes, true);
3032         }
3033
3034         _amp->apply_gain_automation (false);
3035         passthru (bufs, start_frame, end_frame, nframes, 0);
3036
3037         return 0;
3038 }
3039
3040 int
3041 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
3042 {
3043         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3044         if (!lm.locked()) {
3045                 return 0;
3046         }
3047
3048         if (n_outputs().n_total() == 0) {
3049                 return 0;
3050         }
3051
3052         if (!_active || n_inputs().n_total() == 0) {
3053                 silence_unlocked (nframes);
3054                 return 0;
3055         }
3056
3057         framepos_t unused = 0;
3058
3059         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
3060                 return 0;
3061         }
3062
3063         _silent = false;
3064
3065         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
3066
3067         fill_buffers_with_input (bufs, _input, nframes);
3068
3069         if (_meter_point == MeterInput) {
3070                 _meter->run (bufs, start_frame, end_frame, nframes, true);
3071         }
3072
3073         passthru (bufs, start_frame, end_frame, nframes, declick);
3074
3075         return 0;
3076 }
3077
3078 int
3079 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3080 {
3081         silence (nframes);
3082         return 0;
3083 }
3084
3085 void
3086 Route::flush_processors ()
3087 {
3088         /* XXX shouldn't really try to take this lock, since
3089            this is called from the RT audio thread.
3090         */
3091
3092         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3093
3094         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3095                 (*i)->flush ();
3096         }
3097 }
3098
3099 void
3100 Route::set_meter_point (MeterPoint p, bool force)
3101 {
3102         if (_meter_point == p && !force) {
3103                 return;
3104         }
3105
3106         bool meter_was_visible_to_user = _meter->display_to_user ();
3107
3108         {
3109                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3110
3111                 maybe_note_meter_position ();
3112
3113                 _meter_point = p;
3114
3115                 if (_meter_point != MeterCustom) {
3116
3117                         _meter->set_display_to_user (false);
3118
3119                         setup_invisible_processors ();
3120
3121                 } else {
3122
3123                         _meter->set_display_to_user (true);
3124
3125                         /* If we have a previous position for the custom meter, try to put it there */
3126                         if (_custom_meter_position_noted) {
3127                                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3128
3129                                 if (after) {
3130                                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3131                                         if (i != _processors.end ()) {
3132                                                 _processors.remove (_meter);
3133                                                 _processors.insert (i, _meter);
3134                                         }
3135                                 } else if (_last_custom_meter_was_at_end) {
3136                                         _processors.remove (_meter);
3137                                         _processors.push_back (_meter);
3138                                 }
3139                         }
3140                 }
3141
3142                 /* Set up the meter for its new position */
3143
3144                 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3145
3146                 ChanCount m_in;
3147
3148                 if (loc == _processors.begin()) {
3149                         m_in = _input->n_ports();
3150                 } else {
3151                         ProcessorList::iterator before = loc;
3152                         --before;
3153                         m_in = (*before)->output_streams ();
3154                 }
3155
3156                 _meter->reflect_inputs (m_in);
3157
3158                 /* we do not need to reconfigure the processors, because the meter
3159                    (a) is always ready to handle processor_max_streams
3160                    (b) is always an N-in/N-out processor, and thus moving
3161                    it doesn't require any changes to the other processors.
3162                 */
3163         }
3164
3165         meter_change (); /* EMIT SIGNAL */
3166
3167         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3168
3169         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3170 }
3171
3172 void
3173 Route::listen_position_changed ()
3174 {
3175         {
3176                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3177                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3178                 ProcessorState pstate (this);
3179
3180                 if (configure_processors_unlocked (0)) {
3181                         pstate.restore ();
3182                         configure_processors_unlocked (0); // it worked before we tried to add it ...
3183                         return;
3184                 }
3185         }
3186
3187         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3188         _session.set_dirty ();
3189 }
3190
3191 boost::shared_ptr<CapturingProcessor>
3192 Route::add_export_point()
3193 {
3194         if (!_capturing_processor) {
3195
3196                 _capturing_processor.reset (new CapturingProcessor (_session));
3197                 _capturing_processor->activate ();
3198
3199                 configure_processors (0);
3200
3201         }
3202
3203         return _capturing_processor;
3204 }
3205
3206 framecnt_t
3207 Route::update_signal_latency ()
3208 {
3209         framecnt_t l = _output->user_latency();
3210
3211         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3212                 if ((*i)->active ()) {
3213                         l += (*i)->signal_latency ();
3214                 }
3215         }
3216
3217         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3218
3219         if (_signal_latency != l) {
3220                 _signal_latency = l;
3221                 signal_latency_changed (); /* EMIT SIGNAL */
3222         }
3223
3224         return _signal_latency;
3225 }
3226
3227 void
3228 Route::set_user_latency (framecnt_t nframes)
3229 {
3230         _output->set_user_latency (nframes);
3231         _session.update_latency_compensation ();
3232 }
3233
3234 void
3235 Route::set_latency_compensation (framecnt_t longest_session_latency)
3236 {
3237         framecnt_t old = _initial_delay;
3238
3239         if (_signal_latency < longest_session_latency) {
3240                 _initial_delay = longest_session_latency - _signal_latency;
3241         } else {
3242                 _initial_delay = 0;
3243         }
3244
3245         DEBUG_TRACE (DEBUG::Latency, string_compose (
3246                              "%1: compensate for maximum latency of %2,"
3247                              "given own latency of %3, using initial delay of %4\n",
3248                              name(), longest_session_latency, _signal_latency, _initial_delay));
3249
3250         if (_initial_delay != old) {
3251                 initial_delay_changed (); /* EMIT SIGNAL */
3252         }
3253
3254         if (_session.transport_stopped()) {
3255                 _roll_delay = _initial_delay;
3256         }
3257 }
3258
3259 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3260         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3261                              boost::shared_ptr<AutomationList>(), name)
3262         , _route (r)
3263 {
3264         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3265         set_list (gl);
3266 }
3267
3268 void
3269 Route::SoloControllable::set_value (double val)
3270 {
3271         bool bval = ((val >= 0.5f) ? true: false);
3272
3273         boost::shared_ptr<RouteList> rl (new RouteList);
3274
3275         boost::shared_ptr<Route> r = _route.lock ();
3276         if (!r) {
3277                 return;
3278         }
3279
3280         rl->push_back (r);
3281
3282         if (Config->get_solo_control_is_listen_control()) {
3283                 _session.set_listen (rl, bval);
3284         } else {
3285                 _session.set_solo (rl, bval);
3286         }
3287 }
3288
3289 double
3290 Route::SoloControllable::get_value () const
3291 {
3292         boost::shared_ptr<Route> r = _route.lock ();
3293         if (!r) {
3294                 return 0;
3295         }
3296
3297         if (Config->get_solo_control_is_listen_control()) {
3298                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3299         } else {
3300                 return r->self_soloed() ? 1.0f : 0.0f;
3301         }
3302 }
3303
3304 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3305         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3306                              boost::shared_ptr<AutomationList>(), name)
3307         , _route (r)
3308 {
3309         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3310         set_list (gl);
3311 }
3312
3313 void
3314 Route::MuteControllable::set_value (double val)
3315 {
3316         bool bval = ((val >= 0.5f) ? true: false);
3317
3318         boost::shared_ptr<RouteList> rl (new RouteList);
3319
3320         boost::shared_ptr<Route> r = _route.lock ();
3321         if (!r) {
3322                 return;
3323         }
3324
3325         rl->push_back (r);
3326         _session.set_mute (rl, bval);
3327 }
3328
3329 double
3330 Route::MuteControllable::get_value () const
3331 {
3332         boost::shared_ptr<Route> r = _route.lock ();
3333         if (!r) {
3334                 return 0;
3335         }
3336
3337         return r->muted() ? 1.0f : 0.0f;
3338 }
3339
3340 void
3341 Route::set_block_size (pframes_t nframes)
3342 {
3343         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3344                 (*i)->set_block_size (nframes);
3345         }
3346
3347         _session.ensure_buffers (n_process_buffers ());
3348 }
3349
3350 void
3351 Route::protect_automation ()
3352 {
3353         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3354                 (*i)->protect_automation();
3355 }
3356
3357 /** @param declick 1 to set a pending declick fade-in,
3358  *                -1 to set a pending declick fade-out
3359  */
3360 void
3361 Route::set_pending_declick (int declick)
3362 {
3363         if (_declickable) {
3364                 /* this call is not allowed to turn off a pending declick */
3365                 if (declick) {
3366                         _pending_declick = declick;
3367                 }
3368         } else {
3369                 _pending_declick = 0;
3370         }
3371 }
3372
3373 /** Shift automation forwards from a particular place, thereby inserting time.
3374  *  Adds undo commands for any shifts that are performed.
3375  *
3376  * @param pos Position to start shifting from.
3377  * @param frames Amount to shift forwards by.
3378  */
3379
3380 void
3381 Route::shift (framepos_t pos, framecnt_t frames)
3382 {
3383         /* gain automation */
3384         {
3385                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3386
3387                 XMLNode &before = gc->alist()->get_state ();
3388                 gc->alist()->shift (pos, frames);
3389                 XMLNode &after = gc->alist()->get_state ();
3390                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3391         }
3392
3393         /* pan automation */
3394         if (_pannable) {
3395                 ControlSet::Controls& c (_pannable->controls());
3396
3397                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3398                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3399                         if (pc) {
3400                                 boost::shared_ptr<AutomationList> al = pc->alist();
3401                                 XMLNode& before = al->get_state ();
3402                                 al->shift (pos, frames);
3403                                 XMLNode& after = al->get_state ();
3404                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3405                         }
3406                 }
3407         }
3408
3409         /* redirect automation */
3410         {
3411                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3412                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3413
3414                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3415
3416                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3417                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3418                                 if (ac) {
3419                                         boost::shared_ptr<AutomationList> al = ac->alist();
3420                                         XMLNode &before = al->get_state ();
3421                                         al->shift (pos, frames);
3422                                         XMLNode &after = al->get_state ();
3423                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3424                                 }
3425                         }
3426                 }
3427         }
3428 }
3429
3430
3431 int
3432 Route::save_as_template (const string& path, const string& name)
3433 {
3434         XMLNode& node (state (false));
3435         XMLTree tree;
3436
3437         IO::set_name_in_state (*node.children().front(), name);
3438
3439         tree.set_root (&node);
3440         return tree.write (path.c_str());
3441 }
3442
3443
3444 bool
3445 Route::set_name (const string& str)
3446 {
3447         bool ret;
3448         string ioproc_name;
3449         string name;
3450
3451         name = Route::ensure_track_or_route_name (str, _session);
3452         SessionObject::set_name (name);
3453
3454         ret = (_input->set_name(name) && _output->set_name(name));
3455
3456         if (ret) {
3457                 /* rename the main outs. Leave other IO processors
3458                  * with whatever name they already have, because its
3459                  * just fine as it is (it will not contain the route
3460                  * name if its a port insert, port send or port return).
3461                  */
3462
3463                 if (_main_outs) {
3464                         if (_main_outs->set_name (name)) {
3465                                 /* XXX returning false here is stupid because
3466                                    we already changed the route name.
3467                                 */
3468                                 return false;
3469                         }
3470                 }
3471         }
3472
3473         return ret;
3474 }
3475
3476 /** Set the name of a route in an XML description.
3477  *  @param node XML <Route> node to set the name in.
3478  *  @param name New name.
3479  */
3480 void
3481 Route::set_name_in_state (XMLNode& node, string const & name)
3482 {
3483         node.add_property (X_("name"), name);
3484
3485         XMLNodeList children = node.children();
3486         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3487
3488                 if ((*i)->name() == X_("IO")) {
3489
3490                         IO::set_name_in_state (**i, name);
3491
3492                 } else if ((*i)->name() == X_("Processor")) {
3493
3494                         XMLProperty* role = (*i)->property (X_("role"));
3495                         if (role && role->value() == X_("Main")) {
3496                                 (*i)->add_property (X_("name"), name);
3497                         }
3498
3499                 } else if ((*i)->name() == X_("Diskstream")) {
3500
3501                         (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3502                         (*i)->add_property (X_("name"), name);
3503
3504                 }
3505         }
3506 }
3507
3508 boost::shared_ptr<Send>
3509 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3510 {
3511         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3512
3513         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3514                 boost::shared_ptr<InternalSend> send;
3515
3516                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3517                         if (send->target_route() == target) {
3518                                 return send;
3519                         }
3520                 }
3521         }
3522
3523         return boost::shared_ptr<Send>();
3524 }
3525
3526 /** @param c Audio channel index.
3527  *  @param yn true to invert phase, otherwise false.
3528  */
3529 void
3530 Route::set_phase_invert (uint32_t c, bool yn)
3531 {
3532         if (_phase_invert[c] != yn) {
3533                 _phase_invert[c] = yn;
3534                 phase_invert_changed (); /* EMIT SIGNAL */
3535                 _session.set_dirty ();
3536         }
3537 }
3538
3539 void
3540 Route::set_phase_invert (boost::dynamic_bitset<> p)
3541 {
3542         if (_phase_invert != p) {
3543                 _phase_invert = p;
3544                 phase_invert_changed (); /* EMIT SIGNAL */
3545                 _session.set_dirty ();
3546         }
3547 }
3548
3549 bool
3550 Route::phase_invert (uint32_t c) const
3551 {
3552         return _phase_invert[c];
3553 }
3554
3555 boost::dynamic_bitset<>
3556 Route::phase_invert () const
3557 {
3558         return _phase_invert;
3559 }
3560
3561 void
3562 Route::set_denormal_protection (bool yn)
3563 {
3564         if (_denormal_protection != yn) {
3565                 _denormal_protection = yn;
3566                 denormal_protection_changed (); /* EMIT SIGNAL */
3567         }
3568 }
3569
3570 bool
3571 Route::denormal_protection () const
3572 {
3573         return _denormal_protection;
3574 }
3575
3576 void
3577 Route::set_active (bool yn, void* src)
3578 {
3579         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3580                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3581                 return;
3582         }
3583
3584         if (_active != yn) {
3585                 _active = yn;
3586                 _input->set_active (yn);
3587                 _output->set_active (yn);
3588                 active_changed (); // EMIT SIGNAL
3589                 _session.set_dirty ();
3590         }
3591 }
3592
3593 void
3594 Route::meter ()
3595 {
3596         Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3597
3598         assert (_meter);
3599
3600         _meter->meter ();
3601
3602         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3603
3604                 boost::shared_ptr<Send> s;
3605                 boost::shared_ptr<Return> r;
3606
3607                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3608                         s->meter()->meter();
3609                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3610                         r->meter()->meter ();
3611                 }
3612         }
3613 }
3614
3615 boost::shared_ptr<Pannable>
3616 Route::pannable() const
3617 {
3618         return _pannable;
3619 }
3620
3621 boost::shared_ptr<Panner>
3622 Route::panner() const
3623 {
3624         /* may be null ! */
3625         return _main_outs->panner_shell()->panner();
3626 }
3627
3628 boost::shared_ptr<PannerShell>
3629 Route::panner_shell() const
3630 {
3631         return _main_outs->panner_shell();
3632 }
3633
3634 boost::shared_ptr<AutomationControl>
3635 Route::gain_control() const
3636 {
3637         return _amp->gain_control();
3638 }
3639
3640 boost::shared_ptr<AutomationControl>
3641 Route::get_control (const Evoral::Parameter& param)
3642 {
3643         /* either we own the control or .... */
3644
3645         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3646
3647         if (!c) {
3648
3649                 /* maybe one of our processors does or ... */
3650
3651                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock, Glib::Threads::TRY_LOCK);
3652                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3653                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3654                                 break;
3655                         }
3656                 }
3657         }
3658
3659         if (!c) {
3660
3661                 /* nobody does so we'll make a new one */
3662
3663                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3664                 add_control(c);
3665         }
3666
3667         return c;
3668 }
3669
3670 boost::shared_ptr<Processor>
3671 Route::nth_plugin (uint32_t n)
3672 {
3673         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3674         ProcessorList::iterator i;
3675
3676         for (i = _processors.begin(); i != _processors.end(); ++i) {
3677                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3678                         if (n-- == 0) {
3679                                 return *i;
3680                         }
3681                 }
3682         }
3683
3684         return boost::shared_ptr<Processor> ();
3685 }
3686
3687 boost::shared_ptr<Processor>
3688 Route::nth_send (uint32_t n)
3689 {
3690         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3691         ProcessorList::iterator i;
3692
3693         for (i = _processors.begin(); i != _processors.end(); ++i) {
3694                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3695                         if (n-- == 0) {
3696                                 return *i;
3697                         }
3698                 }
3699         }
3700
3701         return boost::shared_ptr<Processor> ();
3702 }
3703
3704 bool
3705 Route::has_io_processor_named (const string& name)
3706 {
3707         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3708         ProcessorList::iterator i;
3709
3710         for (i = _processors.begin(); i != _processors.end(); ++i) {
3711                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3712                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3713                         if ((*i)->name() == name) {
3714                                 return true;
3715                         }
3716                 }
3717         }
3718
3719         return false;
3720 }
3721
3722 MuteMaster::MutePoint
3723 Route::mute_points () const
3724 {
3725         return _mute_master->mute_points ();
3726 }
3727
3728 void
3729 Route::set_processor_positions ()
3730 {
3731         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3732
3733         bool had_amp = false;
3734         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3735                 (*i)->set_pre_fader (!had_amp);
3736                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3737                         had_amp = true;
3738                 }
3739         }
3740 }
3741
3742 /** Called when there is a proposed change to the input port count */
3743 bool
3744 Route::input_port_count_changing (ChanCount to)
3745 {
3746         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3747         if (c.empty()) {
3748                 /* The processors cannot be configured with the new input arrangement, so
3749                    block the change.
3750                 */
3751                 return true;
3752         }
3753
3754         /* The change is ok */
3755         return false;
3756 }
3757
3758 /** Called when there is a proposed change to the output port count */
3759 bool
3760 Route::output_port_count_changing (ChanCount to)
3761 {
3762         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
3763                 if (processor_out_streams.get(*t) > to.get(*t)) {
3764                         return true;
3765                 }
3766         }
3767         /* The change is ok */
3768         return false;
3769 }
3770
3771 list<string>
3772 Route::unknown_processors () const
3773 {
3774         list<string> p;
3775
3776         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3777         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3778                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3779                         p.push_back ((*i)->name ());
3780                 }
3781         }
3782
3783         return p;
3784 }
3785
3786
3787 framecnt_t
3788 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3789 {
3790         /* we assume that all our input ports feed all our output ports. its not
3791            universally true, but the alternative is way too corner-case to worry about.
3792         */
3793
3794         LatencyRange all_connections;
3795
3796         if (from.empty()) {
3797                 all_connections.min = 0;
3798                 all_connections.max = 0;
3799         } else {
3800                 all_connections.min = ~((pframes_t) 0);
3801                 all_connections.max = 0;
3802
3803                 /* iterate over all "from" ports and determine the latency range for all of their
3804                    connections to the "outside" (outside of this Route).
3805                 */
3806
3807                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3808
3809                         LatencyRange range;
3810
3811                         p->get_connected_latency_range (range, playback);
3812
3813                         all_connections.min = min (all_connections.min, range.min);
3814                         all_connections.max = max (all_connections.max, range.max);
3815                 }
3816         }
3817
3818         /* set the "from" port latencies to the max/min range of all their connections */
3819
3820         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3821                 p->set_private_latency_range (all_connections, playback);
3822         }
3823
3824         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3825
3826         all_connections.min += our_latency;
3827         all_connections.max += our_latency;
3828
3829         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3830                 p->set_private_latency_range (all_connections, playback);
3831         }
3832
3833         return all_connections.max;
3834 }
3835
3836 framecnt_t
3837 Route::set_private_port_latencies (bool playback) const
3838 {
3839         framecnt_t own_latency = 0;
3840
3841         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3842            OR LATENCY CALLBACK.
3843
3844            This is called (early) from the latency callback. It computes the REAL
3845            latency associated with each port and stores the result as the "private"
3846            latency of the port. A later call to Route::set_public_port_latencies()
3847            sets all ports to the same value to reflect the fact that we do latency
3848            compensation and so all signals are delayed by the same amount as they
3849            flow through ardour.
3850         */
3851
3852         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3853                 if ((*i)->active ()) {
3854                         own_latency += (*i)->signal_latency ();
3855                 }
3856         }
3857
3858         if (playback) {
3859                 /* playback: propagate latency from "outside the route" to outputs to inputs */
3860                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3861         } else {
3862                 /* capture: propagate latency from "outside the route" to inputs to outputs */
3863                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3864         }
3865 }
3866
3867 void
3868 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3869 {
3870         /* this is called to set the JACK-visible port latencies, which take
3871            latency compensation into account.
3872         */
3873
3874         LatencyRange range;
3875
3876         range.min = value;
3877         range.max = value;
3878
3879         {
3880                 const PortSet& ports (_input->ports());
3881                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3882                         p->set_public_latency_range (range, playback);
3883                 }
3884         }
3885
3886         {
3887                 const PortSet& ports (_output->ports());
3888                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3889                         p->set_public_latency_range (range, playback);
3890                 }
3891         }
3892 }
3893
3894 /** Put the invisible processors in the right place in _processors.
3895  *  Must be called with a writer lock on _processor_lock held.
3896  */
3897 void
3898 Route::setup_invisible_processors ()
3899 {
3900 #ifndef NDEBUG
3901         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3902         assert (!lm.locked ());
3903 #endif
3904
3905         if (!_main_outs) {
3906                 /* too early to be doing this stuff */
3907                 return;
3908         }
3909
3910         /* we'll build this new list here and then use it */
3911
3912         ProcessorList new_processors;
3913
3914         /* find visible processors */
3915
3916         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3917                 if ((*i)->display_to_user ()) {
3918                         new_processors.push_back (*i);
3919                 }
3920         }
3921
3922         /* find the amp */
3923
3924         ProcessorList::iterator amp = new_processors.begin ();
3925         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3926                 ++amp;
3927         }
3928
3929         assert (amp != _processors.end ());
3930
3931         /* and the processor after the amp */
3932
3933         ProcessorList::iterator after_amp = amp;
3934         ++after_amp;
3935
3936         /* METER */
3937
3938         if (_meter) {
3939                 switch (_meter_point) {
3940                 case MeterInput:
3941                         assert (!_meter->display_to_user ());
3942                         new_processors.push_front (_meter);
3943                         break;
3944                 case MeterPreFader:
3945                         assert (!_meter->display_to_user ());
3946                         new_processors.insert (amp, _meter);
3947                         break;
3948                 case MeterPostFader:
3949                         /* do nothing here */
3950                         break;
3951                 case MeterOutput:
3952                         /* do nothing here */
3953                         break;
3954                 case MeterCustom:
3955                         /* the meter is visible, so we don't touch it here */
3956                         break;
3957                 }
3958         }
3959
3960         /* MAIN OUTS */
3961
3962         assert (_main_outs);
3963         assert (!_main_outs->display_to_user ());
3964         new_processors.push_back (_main_outs);
3965
3966         /* iterator for the main outs */
3967
3968         ProcessorList::iterator main = new_processors.end();
3969         --main;
3970
3971         /* OUTPUT METERING */
3972
3973         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3974                 assert (!_meter->display_to_user ());
3975
3976                 /* add the processor just before or just after the main outs */
3977
3978                 ProcessorList::iterator meter_point = main;
3979
3980                 if (_meter_point == MeterOutput) {
3981                         ++meter_point;
3982                 }
3983                 new_processors.insert (meter_point, _meter);
3984         }
3985
3986         /* MONITOR SEND */
3987
3988         if (_monitor_send && !is_monitor ()) {
3989                 assert (!_monitor_send->display_to_user ());
3990                 if (Config->get_solo_control_is_listen_control()) {
3991                         switch (Config->get_listen_position ()) {
3992                         case PreFaderListen:
3993                                 switch (Config->get_pfl_position ()) {
3994                                 case PFLFromBeforeProcessors:
3995                                         new_processors.push_front (_monitor_send);
3996                                         break;
3997                                 case PFLFromAfterProcessors:
3998                                         new_processors.insert (amp, _monitor_send);
3999                                         break;
4000                                 }
4001                                 _monitor_send->set_can_pan (false);
4002                                 break;
4003                         case AfterFaderListen:
4004                                 switch (Config->get_afl_position ()) {
4005                                 case AFLFromBeforeProcessors:
4006                                         new_processors.insert (after_amp, _monitor_send);
4007                                         break;
4008                                 case AFLFromAfterProcessors:
4009                                         new_processors.insert (new_processors.end(), _monitor_send);
4010                                         break;
4011                                 }
4012                                 _monitor_send->set_can_pan (true);
4013                                 break;
4014                         }
4015                 }  else {
4016                         new_processors.insert (new_processors.end(), _monitor_send);
4017                         _monitor_send->set_can_pan (false);
4018                 }
4019         }
4020
4021         /* MONITOR CONTROL */
4022
4023         if (_monitor_control && is_monitor ()) {
4024                 assert (!_monitor_control->display_to_user ());
4025                 new_processors.push_front (_monitor_control);
4026         }
4027
4028         /* INTERNAL RETURN */
4029
4030         /* doing this here means that any monitor control will come just after
4031            the return.
4032         */
4033
4034         if (_intreturn) {
4035                 assert (!_intreturn->display_to_user ());
4036                 new_processors.push_front (_intreturn);
4037         }
4038
4039         /* EXPORT PROCESSOR */
4040
4041         if (_capturing_processor) {
4042                 assert (!_capturing_processor->display_to_user ());
4043                 new_processors.push_front (_capturing_processor);
4044         }
4045
4046         _processors = new_processors;
4047
4048         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
4049         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4050                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
4051         }
4052 }
4053
4054 void
4055 Route::unpan ()
4056 {
4057         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
4058         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
4059
4060         _pannable.reset ();
4061
4062         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4063                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
4064                 if (d) {
4065                         d->unpan ();
4066                 }
4067         }
4068 }
4069
4070 /** If the meter point is `Custom', make a note of where the meter is.
4071  *  This is so that if the meter point is subsequently set to something else,
4072  *  and then back to custom, we can put the meter back where it was last time
4073  *  custom was enabled.
4074  *
4075  *  Must be called with the _processor_lock held.
4076  */
4077 void
4078 Route::maybe_note_meter_position ()
4079 {
4080         if (_meter_point != MeterCustom) {
4081                 return;
4082         }
4083
4084         _custom_meter_position_noted = true;
4085         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4086                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4087                         ProcessorList::iterator j = i;
4088                         ++j;
4089                         if (j != _processors.end ()) {
4090                                 _processor_after_last_custom_meter = *j;
4091                                 _last_custom_meter_was_at_end = false;
4092                         } else {
4093                                 _last_custom_meter_was_at_end = true;
4094                         }
4095                 }
4096         }
4097 }
4098
4099 boost::shared_ptr<Processor>
4100 Route::processor_by_id (PBD::ID id) const
4101 {
4102         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4103         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4104                 if ((*i)->id() == id) {
4105                         return *i;
4106                 }
4107         }
4108
4109         return boost::shared_ptr<Processor> ();
4110 }
4111
4112 /** @return the monitoring state, or in other words what data we are pushing
4113  *  into the route (data from the inputs, data from disk or silence)
4114  */
4115 MonitorState
4116 Route::monitoring_state () const
4117 {
4118         return MonitoringInput;
4119 }
4120
4121 /** @return what we should be metering; either the data coming from the input
4122  *  IO or the data that is flowing through the route.
4123  */
4124 MeterState
4125 Route::metering_state () const
4126 {
4127         return MeteringRoute;
4128 }
4129
4130 bool
4131 Route::has_external_redirects () const
4132 {
4133         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4134
4135                 /* ignore inactive processors and obviously ignore the main
4136                  * outs since everything has them and we don't care.
4137                  */
4138
4139                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4140                         return true;;
4141                 }
4142         }
4143
4144         return false;
4145 }
4146
4147 boost::shared_ptr<Processor>
4148 Route::the_instrument () const
4149 {
4150         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4151         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4152         return the_instrument_unlocked ();
4153 }
4154
4155 boost::shared_ptr<Processor>
4156 Route::the_instrument_unlocked () const
4157 {
4158         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4159                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4160                         if ((*i)->input_streams().n_midi() > 0 &&
4161                             (*i)->output_streams().n_audio() > 0) {
4162                                 return (*i);
4163                         }
4164                 }
4165         }
4166         return boost::shared_ptr<Processor>();
4167 }
4168
4169
4170
4171 void
4172 Route::non_realtime_locate (framepos_t pos)
4173 {
4174         if (_pannable) {
4175                 _pannable->transport_located (pos);
4176         }
4177
4178         {
4179                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4180                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4181
4182                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4183                         (*i)->transport_located (pos);
4184                 }
4185         }
4186 }
4187
4188 void
4189 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
4190 {
4191         size_t n_buffers;
4192         size_t i;
4193
4194         /* MIDI
4195          *
4196          * We don't currently mix MIDI input together, so we don't need the
4197          * complex logic of the audio case.
4198          */
4199
4200         n_buffers = bufs.count().n_midi ();
4201
4202         for (i = 0; i < n_buffers; ++i) {
4203
4204                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
4205                 MidiBuffer& buf (bufs.get_midi (i));
4206
4207                 if (source_port) {
4208                         buf.copy (source_port->get_midi_buffer(nframes));
4209                 } else {
4210                         buf.silence (nframes);
4211                 }
4212         }
4213
4214         /* AUDIO */
4215
4216         n_buffers = bufs.count().n_audio();
4217
4218         size_t n_ports = io->n_ports().n_audio();
4219         float scaling = 1.0f;
4220
4221         if (n_ports > n_buffers) {
4222                 scaling = ((float) n_buffers) / n_ports;
4223         }
4224
4225         for (i = 0; i < n_ports; ++i) {
4226
4227                 /* if there are more ports than buffers, map them onto buffers
4228                  * in a round-robin fashion
4229                  */
4230
4231                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
4232                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
4233
4234
4235                 if (i < n_buffers) {
4236
4237                         /* first time through just copy a channel into
4238                            the output buffer.
4239                         */
4240
4241                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
4242
4243                         if (scaling != 1.0f) {
4244                                 buf.apply_gain (scaling, nframes);
4245                         }
4246
4247                 } else {
4248
4249                         /* on subsequent times around, merge data from
4250                          * the port with what is already there
4251                          */
4252
4253                         if (scaling != 1.0f) {
4254                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
4255                         } else {
4256                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
4257                         }
4258                 }
4259         }
4260
4261         /* silence any remaining buffers */
4262
4263         for (; i < n_buffers; ++i) {
4264                 AudioBuffer& buf (bufs.get_audio (i));
4265                 buf.silence (nframes);
4266         }
4267
4268         /* establish the initial setup of the buffer set, reflecting what was
4269            copied into it. unless, of course, we are the auditioner, in which
4270            case nothing was fed into it from the inputs at all.
4271         */
4272
4273         if (!is_auditioner()) {
4274                 bufs.set_count (io->n_ports());
4275         }
4276 }