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