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