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