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