libs/ardour/route.cc

   1 /*
   2  * Copyright (C) 2000-2019 Paul Davis <paul@linuxaudiosystems.com>
   3  * Copyright (C) 2006-2007 Sampo Savolainen <v2@iki.fi>
   4  * Copyright (C) 2006-2014 David Robillard <d@drobilla.net>
   5  * Copyright (C) 2006 Jesse Chappell <jesse@essej.net>
   6  * Copyright (C) 2008-2012 Carl Hetherington <carl@carlh.net>
   7  * Copyright (C) 2011-2012 Sakari Bergen <sakari.bergen@beatwaves.net>
   8  * Copyright (C) 2013-2015 Nick Mainsbridge <mainsbridge@gmail.com>
   9  * Copyright (C) 2013-2017 John Emmas <john@creativepost.co.uk>
  10  * Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
  11  * Copyright (C) 2014-2018 Ben Loftis <ben@harrisonconsoles.com>
  12  * Copyright (C) 2015-2018 Len Ovens <len@ovenwerks.net>
  13  * Copyright (C) 2016 Julien "_FrnchFrgg_" RIVAUD <frnchfrgg@free.fr>
  14  * Copyright (C) 2016 Tim Mayberry <mojofunk@gmail.com>
  15  * Copyright (C) 2017-2018 Johannes Mueller <github@johannes-mueller.org>
  16  *
  17  * This program is free software; you can redistribute it and/or modify
  18  * it under the terms of the GNU General Public License as published by
  19  * the Free Software Foundation; either version 2 of the License, or
  20  * (at your option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  * GNU General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License along
  28  * with this program; if not, write to the Free Software Foundation, Inc.,
  29  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  30  */
  31
  32 #ifdef WAF_BUILD
  33 #include "libardour-config.h"
  34 #endif
  35
  36 #include <cmath>
  37 #include <cassert>
  38 #include <algorithm>
  39
  40 #include <glibmm.h>
  41 #include <boost/algorithm/string.hpp>
  42
  43 #include "pbd/xml++.h"
  44 #include "pbd/enumwriter.h"
  45 #include "pbd/locale_guard.h"
  46 #include "pbd/memento_command.h"
  47 #include "pbd/stacktrace.h"
  48 #include "pbd/types_convert.h"
  49 #include "pbd/unwind.h"
  50
  51 #include "ardour/amp.h"
  52 #include "ardour/audio_buffer.h"
  53 #include "ardour/audio_track.h"
  54 #include "ardour/audio_port.h"
  55 #include "ardour/audioengine.h"
  56 #include "ardour/boost_debug.h"
  57 #include "ardour/buffer.h"
  58 #include "ardour/buffer_set.h"
  59 #include "ardour/capturing_processor.h"
  60 #include "ardour/debug.h"
  61 #include "ardour/delivery.h"
  62 #include "ardour/disk_reader.h"
  63 #include "ardour/disk_writer.h"
  64 #include "ardour/event_type_map.h"
  65 #include "ardour/gain_control.h"
  66 #include "ardour/internal_return.h"
  67 #include "ardour/internal_send.h"
  68 #include "ardour/meter.h"
  69 #include "ardour/delayline.h"
  70 #include "ardour/midi_buffer.h"
  71 #include "ardour/midi_port.h"
  72 #include "ardour/midi_track.h"
  73 #include "ardour/monitor_control.h"
  74 #include "ardour/monitor_processor.h"
  75 #include "ardour/pannable.h"
  76 #include "ardour/panner.h"
  77 #include "ardour/panner_shell.h"
  78 #include "ardour/parameter_descriptor.h"
  79 #include "ardour/phase_control.h"
  80 #include "ardour/plugin_insert.h"
  81 #include "ardour/polarity_processor.h"
  82 #include "ardour/port.h"
  83 #include "ardour/port_insert.h"
  84 #include "ardour/processor.h"
  85 #include "ardour/profile.h"
  86 #include "ardour/revision.h"
  87 #include "ardour/route.h"
  88 #include "ardour/route_group.h"
  89 #include "ardour/send.h"
  90 #include "ardour/session.h"
  91 #include "ardour/solo_control.h"
  92 #include "ardour/solo_isolate_control.h"
  93 #include "ardour/types_convert.h"
  94 #include "ardour/unknown_processor.h"
  95 #include "ardour/utils.h"
  96 #include "ardour/vca.h"
  97
  98 #include "pbd/i18n.h"
  99
 100 using namespace std;
 101 using namespace ARDOUR;
 102 using namespace PBD;
 103
 104 PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, Route::PluginSetupOptions > Route::PluginSetup;
 105
 106 /** Base class for all routable/mixable objects (tracks and busses) */
 107 Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType default_type)
 108         : Stripable (sess, name, PresentationInfo (flag))
 109         , GraphNode (sess._process_graph)
 110         , Muteable (sess, name)
 111         , _active (true)
 112         , _signal_latency (0)
 113         , _disk_io_point (DiskIOPreFader)
 114         , _pending_process_reorder (0)
 115         , _pending_signals (0)
 116         , _meter_point (MeterPostFader)
 117         , _pending_meter_point (MeterPostFader)
 118         , _denormal_protection (false)
 119         , _recordable (true)
 120         , _have_internal_generator (false)
 121         , _default_type (default_type)
 122         , _loop_location (NULL)
 123         , _track_number (0)
 124         , _strict_io (false)
 125         , _in_configure_processors (false)
 126         , _initial_io_setup (false)
 127         , _in_sidechain_setup (false)
 128         , _custom_meter_position_noted (false)
 129         , _pinmgr_proxy (0)
 130         , _patch_selector_dialog (0)
 131 {
 132         processor_max_streams.reset();
 133 }
 134
 135 boost::weak_ptr<Route>
 136 Route::weakroute () {
 137         return boost::weak_ptr<Route> (boost::dynamic_pointer_cast<Route> (shared_from_this ()));
 138 }
 139
 140 int
 141 Route::init ()
 142 {
 143         /* add standard controls */
 144
 145         _gain_control.reset (new GainControl (_session, GainAutomation));
 146         _trim_control.reset (new GainControl (_session, TrimAutomation));
 147         /* While the route has-a gain-control for consistency with Stripable and VCA
 148          * ownership is handed over to the Amp Processor which manages the
 149          * state of the Control and AutomationList as part of its
 150          * Automatable API. -- Don't call add_control () here.
 151          */
 152
 153         _solo_control.reset (new SoloControl (_session, X_("solo"), *this, *this));
 154         add_control (_solo_control);
 155         _solo_control->Changed.connect_same_thread (*this, boost::bind (&Route::solo_control_changed, this, _1, _2));
 156
 157         _mute_control.reset (new MuteControl (_session, X_("mute"), *this));
 158         add_control (_mute_control);
 159
 160         _phase_control.reset (new PhaseControl (_session, X_("phase")));
 161         add_control (_phase_control);
 162
 163         _solo_isolate_control.reset (new SoloIsolateControl (_session, X_("solo-iso"), *this, *this));
 164         add_control (_solo_isolate_control);
 165
 166         _solo_safe_control.reset (new SoloSafeControl (_session, X_("solo-safe")));
 167         add_control (_solo_safe_control);
 168
 169         /* panning */
 170
 171         if (!(_presentation_info.flags() & PresentationInfo::MonitorOut)) {
 172                 _pannable.reset (new Pannable (_session));
 173         }
 174
 175         /* input and output objects */
 176
 177         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 178         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 179
 180         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
 181         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 182
 183         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
 184         _output->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::output_port_count_changing, this, _1));
 185
 186         /* add the amp/fader processor.
 187          * it should be the first processor to be added on every route.
 188          */
 189
 190         _amp.reset (new Amp (_session, X_("Fader"), _gain_control, true));
 191         _amp->activate ();
 192         _amp->set_owner (this);
 193
 194         _polarity.reset (new PolarityProcessor (_session, _phase_control));
 195         _polarity->activate();
 196         _polarity->set_owner (this);
 197
 198         if (is_monitor ()) {
 199                 _amp->set_display_name (_("Monitor"));
 200         }
 201
 202         if (!is_master() && !is_monitor() && !is_auditioner()) {
 203                 _delayline.reset (new DelayLine (_session, name ()));
 204         }
 205
 206         /* and input trim */
 207
 208         _trim.reset (new Amp (_session, X_("Trim"), _trim_control, false));
 209         _trim->set_display_to_user (false);
 210
 211         if (dynamic_cast<AudioTrack*>(this)) {
 212                 /* we can't do this in the AudioTrack's constructor
 213                  * because _trim does not exit then
 214                  */
 215                 _trim->activate();
 216         }
 217         else if (!dynamic_cast<Track*>(this) && ! (is_monitor() || is_auditioner())) {
 218                 /* regular bus */
 219                 _trim->activate();
 220         }
 221
 222         /* create standard processors: meter, main outs, monitor out;
 223            they will be added to _processors by setup_invisible_processors ()
 224         */
 225
 226         _meter.reset (new PeakMeter (_session, _name));
 227         _meter->set_owner (this);
 228         _meter->set_display_to_user (false);
 229         _meter->activate ();
 230
 231         /* set default meter type */
 232         if (is_master()) {
 233 #ifdef MIXBUS
 234                 set_meter_type (MeterK14);
 235 #else
 236                 set_meter_type (Config->get_meter_type_master ());
 237 #endif
 238         } else if (dynamic_cast<Track*>(this)) {
 239                 set_meter_type (Config->get_meter_type_track ());
 240         } else {
 241                 set_meter_type (Config->get_meter_type_bus ());
 242         }
 243
 244         _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
 245         _main_outs->activate ();
 246
 247         if (is_monitor()) {
 248                 /* where we listen to tracks */
 249                 _intreturn.reset (new InternalReturn (_session));
 250                 _intreturn->activate ();
 251
 252                 /* the thing that provides proper control over a control/monitor/listen bus
 253                    (such as per-channel cut, dim, solo, invert, etc).
 254                 */
 255                 _monitor_control.reset (new MonitorProcessor (_session));
 256                 _monitor_control->activate ();
 257         }
 258         if (_presentation_info.flags() & PresentationInfo::FoldbackBus) {
 259                 panner_shell()->select_panner_by_uri ("http://ardour.org/plugin/panner_balance");
 260         }
 261
 262         /* now set up processor chain and invisible processors */
 263         {
 264                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
 265                 {
 266                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 267                         _processors.push_back (_amp);
 268                 }
 269                 if (!_session.loading()) {
 270                         configure_processors (0);
 271                 }
 272         }
 273
 274         return 0;
 275 }
 276
 277 Route::~Route ()
 278 {
 279         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
 280
 281         /* do this early so that we don't get incoming signals as we are going through destruction
 282          */
 283
 284         drop_connections ();
 285
 286         /* don't use clear_processors here, as it depends on the session which may
 287            be half-destroyed by now
 288         */
 289
 290         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
 291         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 292                 (*i)->drop_references ();
 293         }
 294
 295         _processors.clear ();
 296 }
 297
 298 string
 299 Route::ensure_track_or_route_name (string newname) const
 300 {
 301         while (!_session.io_name_is_legal (newname)) {
 302                 newname = bump_name_once (newname, ' ');
 303                 if (newname == name()) {
 304                         break;
 305                 }
 306         }
 307         return newname;
 308 }
 309
 310 void
 311 Route::set_trim (gain_t val, Controllable::GroupControlDisposition /* group override */)
 312 {
 313         // TODO route group, see set_gain()
 314         // _trim_control->route_set_value (val);
 315 }
 316
 317 /** Process this route for one (sub) cycle (process thread)
 318  *
 319  * @param bufs Scratch buffers to use for the signal path
 320  * @param start_sample Initial transport sample
 321  * @param end_sample Final transport sample
 322  * @param nframes Number of samples to output (to ports)
 323  *
 324  * Note that (end_sample - start_sample) may not be equal to nframes when the
 325  * transport speed isn't 1.0 (eg varispeed).
 326  */
 327 void
 328 Route::process_output_buffers (BufferSet& bufs,
 329                                samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes,
 330                                bool gain_automation_ok, bool run_disk_reader)
 331 {
 332         /* Caller must hold process lock */
 333         assert (!AudioEngine::instance()->process_lock().trylock());
 334
 335         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 336         if (!lm.locked()) {
 337                 // can this actually happen?
 338                 // Places that need a WriterLock on (_processor_lock) must also take the process-lock.
 339                 bufs.silence (nframes, 0);
 340                 assert (0); // ...one way to find out.
 341                 return;
 342         }
 343
 344         /* We should offset the route-owned ctrls by the given latency, however
 345          * this only affects Mute. Other route-owned controls (solo, polarity..)
 346          * are not automatable.
 347          *
 348          * Mute has its own issues since there's not a single mute-point,
 349          * but in general
 350          */
 351         automation_run (start_sample, nframes);
 352
 353         if (_pannable) {
 354                 _pannable->automation_run (start_sample + _signal_latency, nframes);
 355         }
 356
 357         /* figure out if we're going to use gain automation */
 358         if (gain_automation_ok) {
 359                 _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
 360                 _amp->setup_gain_automation (
 361                                 start_sample + _amp->output_latency (),
 362                                 end_sample + _amp->output_latency (),
 363                                 nframes);
 364
 365                 _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
 366                 _trim->setup_gain_automation (
 367                                 start_sample + _trim->output_latency (),
 368                                 end_sample + _trim->output_latency (),
 369                                 nframes);
 370         }
 371
 372         /* We align the playhead to output. The user hears what the clock says:
 373          * When the playhead/clock says 1:00:00:00 the user will hear the audio sample
 374          * at 1:00:00:00. sample_start will be [sample at] 1:00:00:00
 375          *
 376          * e.g. clock says Time T = 0,  sample_start = 0
 377          * Disk-read(play) -> latent-plugin (+10) -> fader-automation -> output (+5)
 378          * -> total playback latency "disk -> out" is 15.
 379          * -> at Time T= -15, the disk-reader reads sample T=0.
 380          * By the Time T=0 is reached (dt=15 later) that sample is audible.
 381          */
 382
 383         const double speed = (is_auditioner() ? 1.0 : _session.transport_speed ());
 384
 385         const sampleoffset_t latency_offset = _signal_latency + _output->latency ();
 386         if (speed < 0) {
 387                 /* when rolling backwards this can become negative */
 388                 start_sample -= latency_offset;
 389                 end_sample -= latency_offset;
 390         } else {
 391                 start_sample += latency_offset;
 392                 end_sample += latency_offset;
 393         }
 394
 395         /* Note: during intial pre-roll 'start_sample' as passed as argument can be negative.
 396          * Functions calling process_output_buffers() will set  "run_disk_reader"
 397          * to false if the pre-roll count-down is larger than playback_latency ().
 398          *
 399          * playback_latency() is guarnteed to be <= _signal_latency + _output->latency ()
 400          */
 401         assert (!_disk_reader || !run_disk_reader || start_sample >= 0 || speed < 0);
 402
 403         /* however the disk-writer may need to pick up output from other tracks
 404          * during pre-roll (in particular if this route has latent effects after the disk).
 405          *
 406          * e.g. track 1 play -> latency A --port--> track2 capture -> latency B ---> out
 407          * total pre-roll = A + B.
 408          *
 409          * Note the disk-writer has built-in overlap detection (it's safe to run it early)
 410          * given that
 411          */
 412         bool run_disk_writer = false;
 413         if (_disk_writer && speed > 0) {
 414                 samplecnt_t latency_preroll = _session.remaining_latency_preroll ();
 415                 run_disk_writer = latency_preroll < nframes + (_signal_latency + _output->latency ());
 416                 if (end_sample - _disk_writer->input_latency () < _session.transport_sample ()) {
 417                         run_disk_writer = true;
 418                 }
 419         }
 420
 421         /* Tell main outs what to do about monitoring.  We do this so that
 422          * on a transition between monitoring states we get a de-clicking gain
 423          * change in the _main_outs delivery, if config.get_use_monitor_fades()
 424          * is true.
 425          *
 426          * We override this in the case where we have an internal generator.
 427          *
 428          * FIXME: when punching in/out this also depends on latency compensated time
 429          * for this route. monitoring_state() does not currently handle that correctly,.
 430          *
 431          * Also during remaining_latency_preroll, transport_rolling () is false, but
 432          * we may need to monitor disk instead.
 433          */
 434         const MonitorState ms = monitoring_state ();
 435         const bool silent = _have_internal_generator ? false : (ms == MonitoringSilence);
 436
 437         _main_outs->no_outs_cuz_we_no_monitor (silent);
 438
 439         /* -------------------------------------------------------------------------------------------
 440            DENORMAL CONTROL
 441            ----------------------------------------------------------------------------------------- */
 442         /* XXX We'll need to protect silent inputs as well as silent disk
 443          * (when not monitoring input or monitoring disk and there's no region
 444          * for a longer time).
 445          *
 446          * ...or simply drop that feature.
 447          */
 448         if (_denormal_protection || Config->get_denormal_protection()) {
 449
 450                 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 451                         Sample* const sp = i->data();
 452                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 453                                 sp[nx] += 1.0e-27f;
 454                         }
 455                 }
 456         }
 457
 458
 459         /* -------------------------------------------------------------------------------------------
 460            and go ....
 461            ----------------------------------------------------------------------------------------- */
 462
 463         samplecnt_t latency = 0;
 464
 465         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 466
 467                 /* TODO check for split cycles here.
 468                  *
 469                  * start_frame, end_frame is adjusted by latency and may
 470                  * cross loop points.
 471                  */
 472
 473 #ifndef NDEBUG
 474                 /* if it has any inputs, make sure they match */
 475                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i) == 0 && (*i)->input_streams() != ChanCount::ZERO) {
 476                         if (bufs.count() != (*i)->input_streams()) {
 477                                 DEBUG_TRACE (
 478                                         DEBUG::Processors, string_compose (
 479                                                 "input port mismatch %1 bufs = %2 input for %3 = %4\n",
 480                                                 _name, bufs.count(), (*i)->name(), (*i)->input_streams()
 481                                                 )
 482                                         );
 483                         }
 484                 }
 485 #endif
 486
 487                 bool re_inject_oob_data = false;
 488                 if ((*i) == _disk_reader) {
 489                         /* Well now, we've made it past the disk-writer and to the disk-reader.
 490                          * Time to decide what to do about monitoring.
 491                          *
 492                          * Even when not doing MonitoringDisk, we need to run the processors,
 493                          * so that it advances its internal buffers (IFF run_disk_reader is true).
 494                          *
 495                          */
 496                         if (ms == MonitoringDisk || ms == MonitoringSilence) {
 497                                 /* this will clear out-of-band data, too (e.g. MIDI-PC, Panic etc.
 498                                  * OOB data is written at the end of the cycle (nframes - 1),
 499                                  * and jack does not re-order events, so we push them back later */
 500                                 re_inject_oob_data = true;
 501                                 bufs.silence (nframes, 0);
 502                         }
 503                 }
 504
 505                 double pspeed = speed;
 506                 if ((!run_disk_reader && (*i) == _disk_reader) || (!run_disk_writer && (*i) == _disk_writer)) {
 507                         /* run with speed 0, no-roll */
 508                         pspeed = 0;
 509                 }
 510
 511                 if (speed < 0) {
 512                         (*i)->run (bufs, start_sample + latency, end_sample + latency, pspeed, nframes, *i != _processors.back());
 513                 } else {
 514                         (*i)->run (bufs, start_sample - latency, end_sample - latency, pspeed, nframes, *i != _processors.back());
 515                 }
 516
 517                 bufs.set_count ((*i)->output_streams());
 518
 519                 /* Note: plugin latency may change. While the plugin does inform the session via
 520                  * processor_latency_changed(). But the session may not yet have gotten around to
 521                  * update the actual worste-case and update this track's _signal_latency.
 522                  *
 523                  * So there can be cases where adding up all latencies may not equal _signal_latency.
 524                  */
 525                 if ((*i)->active ()) {
 526                         latency += (*i)->effective_latency ();
 527                 }
 528
 529                 if (re_inject_oob_data) {
 530                         write_out_of_band_data (bufs, nframes);
 531                 }
 532
 533 #if 0
 534                 if ((*i) == _delayline) {
 535                         latency += _delayline->delay ();
 536                 }
 537 #endif
 538         }
 539 }
 540
 541 void
 542 Route::bounce_process (BufferSet& buffers, samplepos_t start, samplecnt_t nframes,
 543                 boost::shared_ptr<Processor> endpoint,
 544                 bool include_endpoint, bool for_export, bool for_freeze)
 545 {
 546         /* If no processing is required, there's no need to go any further. */
 547         if (!endpoint && !include_endpoint) {
 548                 return;
 549         }
 550
 551         samplecnt_t latency = bounce_get_latency(_amp, false, for_export, for_freeze);
 552         _amp->set_gain_automation_buffer (_session.gain_automation_buffer ());
 553         _amp->setup_gain_automation (start - latency, start - latency + nframes, nframes);
 554
 555         /* trim is always at the top, for bounce no latency compensation is needed */
 556         _trim->set_gain_automation_buffer (_session.trim_automation_buffer ());
 557         _trim->setup_gain_automation (start, start + nframes, nframes);
 558
 559         latency = 0;
 560         bool seen_disk_io = false;
 561         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 562
 563                 if (!include_endpoint && (*i) == endpoint) {
 564                         break;
 565                 }
 566
 567                 if (!for_export && !seen_disk_io) {
 568                         if (boost::dynamic_pointer_cast<DiskReader> (*i)) {
 569                                 seen_disk_io = true;
 570                                 buffers.set_count ((*i)->output_streams());
 571                         }
 572                         continue;
 573                 }
 574
 575                 /* if we're *not* exporting, stop processing if we come across a routing processor. */
 576                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 577                         break;
 578                 }
 579                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 580                         break;
 581                 }
 582
 583                 /* special case the panner (export outputs)
 584                  * Ideally we'd only run the panner, not the delivery itself...
 585                  * but panners need separate input/output buffers and some context
 586                  * (panshell, panner type, etc). AFAICT there is no ill side effect
 587                  * of re-using the main delivery when freewheeling/exporting a region.
 588                  */
 589                 if ((*i) == _main_outs) {
 590                         assert ((*i)->does_routing());
 591                         (*i)->run (buffers, start - latency, start - latency + nframes, 1.0, nframes, true);
 592                         buffers.set_count ((*i)->output_streams());
 593                 }
 594
 595                 /* don't run any processors that do routing.
 596                  * Also don't bother with metering.
 597                  */
 598                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 599                         (*i)->run (buffers, start - latency, start - latency + nframes, 1.0, nframes, true);
 600                         buffers.set_count ((*i)->output_streams());
 601                         latency += (*i)->effective_latency ();
 602                 }
 603
 604                 if ((*i) == endpoint) {
 605                         break;
 606                 }
 607         }
 608 }
 609
 610 samplecnt_t
 611 Route::bounce_get_latency (boost::shared_ptr<Processor> endpoint,
 612                 bool include_endpoint, bool for_export, bool for_freeze) const
 613 {
 614         samplecnt_t latency = 0;
 615         if (!endpoint && !include_endpoint) {
 616                 return latency;
 617         }
 618
 619         bool seen_disk_io = false;
 620         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 621                 if (!include_endpoint && (*i) == endpoint) {
 622                         break;
 623                 }
 624                 if (!for_export && !seen_disk_io) {
 625                         if (boost::dynamic_pointer_cast<DiskReader> (*i)) {
 626                                 seen_disk_io = true;
 627                         }
 628                         continue;
 629                 }
 630                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 631                         break;
 632                 }
 633                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 634                         break;
 635                 }
 636                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 637                         latency += (*i)->effective_latency ();
 638                 }
 639                 if ((*i) == endpoint) {
 640                         break;
 641                 }
 642         }
 643         return latency;
 644 }
 645
 646 ChanCount
 647 Route::bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint,
 648                 bool include_endpoint, bool for_export, bool for_freeze) const
 649 {
 650         if (!endpoint && !include_endpoint) {
 651                 return cc;
 652         }
 653
 654         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
 655                 if (!include_endpoint && (*i) == endpoint) {
 656                         break;
 657                 }
 658                 if (!for_export && boost::dynamic_pointer_cast<PortInsert>(*i)) {
 659                         break;
 660                 }
 661                 if (!for_export && for_freeze && (*i)->does_routing() && (*i)->active()) {
 662                         break;
 663                 }
 664                 if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
 665                         cc = (*i)->output_streams();
 666                 }
 667                 if ((*i) == endpoint) {
 668                         break;
 669                 }
 670         }
 671         return cc;
 672 }
 673
 674 ChanCount
 675 Route::n_process_buffers ()
 676 {
 677         return max (_input->n_ports(), processor_max_streams);
 678 }
 679
 680 void
 681 Route::monitor_run (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes)
 682 {
 683         assert (is_monitor());
 684         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
 685         run_route (start_sample, end_sample, nframes, true, false);
 686 }
 687
 688 void
 689 Route::run_route (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, bool gain_automation_ok, bool run_disk_reader)
 690 {
 691         BufferSet& bufs (_session.get_route_buffers (n_process_buffers()));
 692
 693         fill_buffers_with_input (bufs, _input, nframes);
 694
 695         /* filter captured data before meter sees it */
 696         filter_input (bufs);
 697
 698         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
 699
 700                 /* control/monitor bus ignores input ports when something is
 701                    feeding the listen "stream". data will "arrive" into the
 702                    route from the intreturn processor element.
 703                 */
 704
 705                 bufs.silence (nframes, 0);
 706         }
 707
 708         snapshot_out_of_band_data (nframes);
 709         /* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
 710
 711         write_out_of_band_data (bufs, nframes);
 712
 713         /* run processor chain */
 714
 715         process_output_buffers (bufs, start_sample, end_sample, nframes, gain_automation_ok, run_disk_reader);
 716
 717         /* map events (e.g. MIDI-CC) back to control-parameters */
 718         update_controls (bufs);
 719
 720         flush_processor_buffers_locked (nframes);
 721 }
 722
 723 void
 724 Route::set_listen (bool yn)
 725 {
 726         if (_monitor_send) {
 727                 if (_monitor_send->active() == yn) {
 728                         return;
 729                 }
 730                 if (yn) {
 731                         _monitor_send->activate ();
 732                 } else {
 733                         _monitor_send->deactivate ();
 734                 }
 735         }
 736 }
 737
 738 void
 739 Route::solo_control_changed (bool, Controllable::GroupControlDisposition)
 740 {
 741         /* nothing to do if we're not using AFL/PFL. But if we are, we need
 742            to alter the active state of the monitor send.
 743         */
 744
 745         if (Config->get_solo_control_is_listen_control ()) {
 746                 set_listen (_solo_control->self_soloed() || _solo_control->get_masters_value());
 747         }
 748 }
 749
 750 void
 751 Route::push_solo_isolate_upstream (int32_t delta)
 752 {
 753         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
 754
 755         boost::shared_ptr<RouteList> routes = _session.get_routes ();
 756         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 757
 758                 if ((*i).get() == this || !(*i)->can_solo()) {
 759                         continue;
 760                 }
 761
 762                 bool sends_only;
 763                 bool does_feed = feeds (*i, &sends_only);
 764
 765                 if (does_feed && !sends_only) {
 766                         (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (delta);
 767                 }
 768         }
 769 }
 770
 771 void
 772 Route::push_solo_upstream (int delta)
 773 {
 774         DEBUG_TRACE (DEBUG::Solo, string_compose("\t ... INVERT push from %1\n", _name));
 775         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
 776                 if (i->sends_only) {
 777                         continue;
 778                 }
 779                 boost::shared_ptr<Route> sr (i->r.lock());
 780                 if (sr) {
 781                         sr->solo_control()->mod_solo_by_others_downstream (-delta);
 782                 }
 783         }
 784 }
 785
 786 #if 0
 787 static void
 788 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 789 {
 790         cerr << name << " {" << endl;
 791         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 792                         p != procs.end(); ++p) {
 793                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
 794         }
 795         cerr << "}" << endl;
 796 }
 797 #endif
 798
 799 /** Supposing that we want to insert a Processor at a given Placement, return
 800  *  the processor to add the new one before (or 0 to add at the end).
 801  */
 802 boost::shared_ptr<Processor>
 803 Route::before_processor_for_placement (Placement p)
 804 {
 805         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 806
 807         ProcessorList::iterator loc;
 808
 809         if (p == PreFader) {
 810                 /* generic pre-fader: insert immediately before the amp */
 811                 loc = find (_processors.begin(), _processors.end(), _amp);
 812         } else {
 813                 /* generic post-fader: insert right before the main outs */
 814                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 815         }
 816
 817         return loc != _processors.end() ? *loc : boost::shared_ptr<Processor> ();
 818 }
 819
 820 /** Supposing that we want to insert a Processor at a given index, return
 821  *  the processor to add the new one before (or 0 to add at the end).
 822  */
 823 boost::shared_ptr<Processor>
 824 Route::before_processor_for_index (int index)
 825 {
 826         if (index == -1) {
 827                 return boost::shared_ptr<Processor> ();
 828         }
 829
 830         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 831
 832         ProcessorList::iterator i = _processors.begin ();
 833         int j = 0;
 834         while (i != _processors.end() && j < index) {
 835                 if ((*i)->display_to_user()) {
 836                         ++j;
 837                 }
 838
 839                 ++i;
 840         }
 841
 842         return (i != _processors.end() ? *i : boost::shared_ptr<Processor> ());
 843 }
 844
 845 /** Add a processor either pre- or post-fader
 846  *  @return 0 on success, non-0 on failure.
 847  */
 848 int
 849 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
 850 {
 851         return add_processor (processor, before_processor_for_placement (placement), err, activation_allowed);
 852 }
 853
 854
 855 /** Add a processor to a route such that it ends up with a given index into the visible processors.
 856  *  @param index Index to add the processor at, or -1 to add at the end of the list.
 857  *  @return 0 on success, non-0 on failure.
 858  */
 859 int
 860 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
 861 {
 862         return add_processor (processor, before_processor_for_index (index), err, activation_allowed);
 863 }
 864
 865 /** Add a processor to the route.
 866  *  @param before An existing processor in the list, or 0; the new processor will be inserted immediately before it (or at the end).
 867  *  @return 0 on success, non-0 on failure.
 868  */
 869 int
 870 Route::add_processor (boost::shared_ptr<Processor> processor, boost::shared_ptr<Processor> before, ProcessorStreams* err, bool activation_allowed)
 871 {
 872         assert (processor != _meter);
 873         assert (processor != _main_outs);
 874
 875         DEBUG_TRACE (DEBUG::Processors, string_compose (
 876                              "%1 adding processor %2\n", name(), processor->name()));
 877
 878         ProcessorList pl;
 879
 880         pl.push_back (processor);
 881         int rv = add_processors (pl, before, err);
 882
 883         if (rv) {
 884                 return rv;
 885         }
 886
 887         if (activation_allowed && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user ())) {
 888                 processor->activate ();
 889         }
 890
 891         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
 892         if (pi) {
 893                 pi->update_sidechain_name ();
 894         }
 895
 896         return 0;
 897 }
 898
 899 void
 900 Route::processor_selfdestruct (boost::weak_ptr<Processor> wp)
 901 {
 902         /* We cannot destruct the processor here (usually RT-thread
 903          * with various locks held - in case of sends also io_locks).
 904          * Queue for deletion in low-priority thread.
 905          */
 906         Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
 907         selfdestruct_sequence.push_back (wp);
 908 }
 909
 910 bool
 911 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
 912 {
 913         XMLProperty const * prop;
 914
 915         try {
 916                 boost::shared_ptr<Processor> processor;
 917
 918                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
 919                    so that we can add the processor in the right place (pre/post-fader)
 920                 */
 921
 922                 XMLNodeList const & children = node.children ();
 923                 XMLNodeList::const_iterator i = children.begin ();
 924
 925                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
 926                         ++i;
 927                 }
 928
 929                 Placement placement = PreFader;
 930
 931                 if (i != children.end()) {
 932                         if ((prop = (*i)->property (X_("placement"))) != 0) {
 933                                 placement = Placement (string_2_enum (prop->value(), placement));
 934                         }
 935                 }
 936
 937                 if (node.name() == "Insert") {
 938
 939                         if ((prop = node.property ("type")) != 0) {
 940
 941                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 942                                                 prop->value() == "lv2" ||
 943                                                 prop->value() == "windows-vst" ||
 944                                                 prop->value() == "mac-vst" ||
 945                                                 prop->value() == "lxvst" ||
 946                                                 prop->value() == "audiounit") {
 947
 948                                         if (_session.get_disable_all_loaded_plugins ()) {
 949                                                 processor.reset (new UnknownProcessor (_session, node));
 950                                         } else {
 951                                                 processor.reset (new PluginInsert (_session));
 952                                                 processor->set_owner (this);
 953                                         }
 954
 955                                 } else {
 956
 957                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
 958                                 }
 959
 960                         }
 961
 962                 } else if (node.name() == "Send") {
 963
 964                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
 965                         processor.reset (new Send (_session, sendpan, _mute_master));
 966
 967                 } else {
 968
 969                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
 970                         return false;
 971                 }
 972
 973                 if (processor->set_state (node, version)) {
 974                         return false;
 975                 }
 976
 977                 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
 978                 if (i != children.end()) {
 979                         if ((prop = (*i)->property (X_("active"))) != 0) {
 980                                 if (string_to<bool> (prop->value()) && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user ()))
 981                                         processor->activate();
 982                                 else
 983                                         processor->deactivate();
 984                         }
 985                 }
 986
 987                 return (add_processor (processor, placement, 0, false) == 0);
 988         }
 989
 990         catch (failed_constructor &err) {
 991                 warning << _("processor could not be created. Ignored.") << endmsg;
 992                 return false;
 993         }
 994 }
 995
 996
 997 inline Route::PluginSetupOptions operator|= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
 998         return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) | static_cast<int> (b));
 999 }
1000
1001 inline Route::PluginSetupOptions operator&= (Route::PluginSetupOptions& a, const Route::PluginSetupOptions& b) {
1002         return a = static_cast<Route::PluginSetupOptions> (static_cast <int>(a) & static_cast<int> (b));
1003 }
1004
1005 int
1006 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1007 {
1008         ProcessorList::iterator loc;
1009         boost::shared_ptr <PluginInsert> fanout;
1010
1011         if (g_atomic_int_get (&_pending_process_reorder)) {
1012                 /* we need to flush any pending re-order changes */
1013                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1014                 apply_processor_changes_rt ();
1015         }
1016
1017         if (before) {
1018                 loc = find(_processors.begin(), _processors.end(), before);
1019                 if (loc == _processors.end ()) {
1020                         return 1;
1021                 }
1022         } else {
1023                 /* nothing specified - at end */
1024                 loc = _processors.end ();
1025         }
1026
1027         if (others.empty()) {
1028                 return 0;
1029         }
1030
1031         ProcessorList to_skip;
1032
1033         // check if there's an instrument to replace or configure
1034         for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1035                 boost::shared_ptr<PluginInsert> pi;
1036                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) == 0) {
1037                         continue;
1038                 }
1039                 if (!pi->plugin ()->get_info ()->is_instrument ()) {
1040                         continue;
1041                 }
1042                 boost::shared_ptr<Processor> instrument = the_instrument ();
1043                 ChanCount in (DataType::MIDI, 1);
1044                 ChanCount out (DataType::AUDIO, 2); // XXX route's out?!
1045
1046                 PluginSetupOptions flags = None;
1047                 if (instrument) {
1048                         flags |= CanReplace;
1049                         in = instrument->input_streams ();
1050                         out = instrument->output_streams ();
1051                 }
1052                 if (pi->has_output_presets (in, out)) {
1053                         flags |= MultiOut;
1054                 }
1055
1056                 pi->set_strict_io (_strict_io);
1057
1058                 if (is_auditioner()) {
1059                         continue;
1060                 }
1061
1062                 PluginSetupOptions mask = None;
1063                 if (Config->get_ask_replace_instrument ()) {
1064                         mask |= CanReplace;
1065                 }
1066                 if (Config->get_ask_setup_instrument ()) {
1067                         mask |= MultiOut;
1068                 }
1069
1070                 flags &= mask;
1071
1072                 if (flags != None) {
1073                         boost::optional<int> rv = PluginSetup (boost::dynamic_pointer_cast<Route>(shared_from_this ()), pi, flags);  /* EMIT SIGNAL */
1074                         int mode = rv.get_value_or (0);
1075                         switch (mode & 3) {
1076                                 case 1:
1077                                         to_skip.push_back (*i); // don't add this one;
1078                                         break;
1079                                 case 2:
1080                                         replace_processor (instrument, *i, err);
1081                                         to_skip.push_back (*i);
1082                                         break;
1083                                 default:
1084                                         break;
1085                         }
1086                         if ((mode & 5) == 4) {
1087                                 fanout = pi;
1088                         }
1089                 }
1090         }
1091
1092         {
1093                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1094                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1095                 ProcessorState pstate (this);
1096
1097                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1098
1099                         if (*i == _meter) {
1100                                 continue;
1101                         }
1102                         ProcessorList::iterator check = find (to_skip.begin(), to_skip.end(), *i);
1103                         if (check != to_skip.end()) {
1104                                 continue;
1105                         }
1106
1107                         boost::shared_ptr<PluginInsert> pi;
1108
1109                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1110                                 pi->set_strict_io (_strict_io);
1111                         }
1112
1113                         if (*i == _amp) {
1114                                 /* Ensure that only one amp is in the list at any time */
1115                                 ProcessorList::iterator check = find (_processors.begin(), _processors.end(), *i);
1116                                 if (check != _processors.end()) {
1117                                         if (before == _amp) {
1118                                                 /* Already in position; all is well */
1119                                                 continue;
1120                                         } else {
1121                                                 _processors.erase (check);
1122                                         }
1123                                 }
1124                         }
1125
1126                         assert (find (_processors.begin(), _processors.end(), *i) == _processors.end ());
1127
1128                         _processors.insert (loc, *i);
1129                         (*i)->set_owner (this);
1130
1131                         {
1132                                 if (configure_processors_unlocked (err, &lm)) {
1133                                         pstate.restore ();
1134                                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
1135                                         return -1;
1136                                 }
1137                         }
1138
1139                         if (pi && pi->has_sidechain ()) {
1140                                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
1141                         }
1142
1143                         if ((*i)->active()) {
1144                                 // emit ActiveChanged() and latency_changed() if needed
1145                                 (*i)->activate ();
1146                         }
1147
1148                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1149
1150                         boost::shared_ptr<Send> send;
1151                         if ((send = boost::dynamic_pointer_cast<Send> (*i))) {
1152                                 send->SelfDestruct.connect_same_thread (*this,
1153                                                 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (*i)));
1154                         }
1155                 }
1156
1157                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1158                         boost::shared_ptr<PluginInsert> pi;
1159
1160                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1161                                 if (pi->has_no_inputs ()) {
1162                                         _have_internal_generator = true;
1163                                         break;
1164                                 }
1165                         }
1166                 }
1167         }
1168
1169         reset_instrument_info ();
1170         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1171         set_processor_positions ();
1172
1173         if (fanout && fanout->configured ()
1174                         && fanout->output_streams().n_audio() > 2
1175                         && boost::dynamic_pointer_cast<PluginInsert> (the_instrument ()) == fanout) {
1176                 fan_out (); /* EMIT SIGNAL */
1177         }
1178         return 0;
1179 }
1180
1181 void
1182 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1183 {
1184         if (p == PreFader) {
1185                 start = _processors.begin();
1186                 end = find(_processors.begin(), _processors.end(), _amp);
1187         } else {
1188                 start = find(_processors.begin(), _processors.end(), _amp);
1189                 ++start;
1190                 end = _processors.end();
1191         }
1192 }
1193
1194 /** Turn off all processors with a given placement
1195  * @param p Placement of processors to disable
1196  */
1197 void
1198 Route::disable_processors (Placement p)
1199 {
1200         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1201
1202         ProcessorList::iterator start, end;
1203         placement_range(p, start, end);
1204
1205         for (ProcessorList::iterator i = start; i != end; ++i) {
1206                 (*i)->enable (false);
1207         }
1208
1209         _session.set_dirty ();
1210 }
1211
1212 /** Turn off all redirects
1213  */
1214 void
1215 Route::disable_processors ()
1216 {
1217         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1218
1219         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1220                 (*i)->enable (false);
1221         }
1222
1223         _session.set_dirty ();
1224 }
1225
1226 /** Turn off all redirects with a given placement
1227  * @param p Placement of redirects to disable
1228  */
1229 void
1230 Route::disable_plugins (Placement p)
1231 {
1232         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1233
1234         ProcessorList::iterator start, end;
1235         placement_range(p, start, end);
1236
1237         for (ProcessorList::iterator i = start; i != end; ++i) {
1238                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1239                         (*i)->enable (false);
1240                 }
1241         }
1242
1243         _session.set_dirty ();
1244 }
1245
1246 /** Turn off all plugins
1247  */
1248 void
1249 Route::disable_plugins ()
1250 {
1251         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1252
1253         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1254                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1255                         (*i)->enable (false);
1256                 }
1257         }
1258
1259         _session.set_dirty ();
1260 }
1261
1262
1263 void
1264 Route::ab_plugins (bool forward)
1265 {
1266         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1267
1268         if (forward) {
1269
1270                 /* forward = turn off all active redirects, and mark them so that the next time
1271                    we go the other way, we will revert them
1272                 */
1273
1274                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1275                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1276                                 continue;
1277                         }
1278                         if (!(*i)->display_to_user ()) {
1279                                 continue;
1280                         }
1281 #ifdef MIXBUS
1282                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1283                                 continue;
1284                         }
1285 #endif
1286
1287                         if ((*i)->enabled ()) {
1288                                 (*i)->enable (false);
1289                                 (*i)->set_next_ab_is_active (true);
1290                         } else {
1291                                 (*i)->set_next_ab_is_active (false);
1292                         }
1293                 }
1294
1295         } else {
1296
1297                 /* backward = if the redirect was marked to go active on the next ab, do so */
1298
1299                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1300                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1301                                 continue;
1302                         }
1303                         if (!(*i)->display_to_user ()) {
1304                                 continue;
1305                         }
1306 #ifdef MIXBUS
1307                         if (boost::dynamic_pointer_cast<PluginInsert> (*i)->is_channelstrip()) {
1308                                 continue;
1309                         }
1310 #endif
1311
1312                         (*i)->enable ((*i)->get_next_ab_is_active ());
1313                 }
1314         }
1315
1316         _session.set_dirty ();
1317 }
1318
1319
1320 /** Remove processors with a given placement.
1321  * @param p Placement of processors to remove.
1322  */
1323 void
1324 Route::clear_processors (Placement p)
1325 {
1326         if (!_session.engine().running()) {
1327                 return;
1328         }
1329
1330         bool already_deleting = _session.deletion_in_progress();
1331         if (!already_deleting) {
1332                 _session.set_deletion_in_progress();
1333         }
1334
1335         ProcessorList old_list = _processors;
1336         {
1337                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1338                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1339                 ProcessorList new_list;
1340                 ProcessorStreams err;
1341                 bool seen_amp = false;
1342
1343                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1344
1345                         if (*i == _amp) {
1346                                 seen_amp = true;
1347                         }
1348
1349                         if (is_internal_processor (*i)) {
1350
1351                                 /* you can't remove these */
1352
1353                                 new_list.push_back (*i);
1354
1355                         } else {
1356                                 if (seen_amp) {
1357
1358                                         switch (p) {
1359                                         case PreFader:
1360                                                 new_list.push_back (*i);
1361                                                 break;
1362                                         case PostFader:
1363                                                 (*i)->drop_references ();
1364                                                 break;
1365                                         }
1366
1367                                 } else {
1368
1369                                         switch (p) {
1370                                         case PreFader:
1371                                                 (*i)->drop_references ();
1372                                                 break;
1373                                         case PostFader:
1374                                                 new_list.push_back (*i);
1375                                                 break;
1376                                         }
1377                                 }
1378                         }
1379                 }
1380
1381                 _processors = new_list;
1382                 configure_processors_unlocked (&err, &lm); // this can't fail
1383         }
1384         /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
1385         old_list.clear ();
1386
1387         processor_max_streams.reset();
1388         _have_internal_generator = false;
1389         reset_instrument_info ();
1390         set_processor_positions ();
1391
1392         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1393
1394         if (!already_deleting) {
1395                 _session.clear_deletion_in_progress();
1396         }
1397 }
1398
1399 bool
1400 Route::is_internal_processor (boost::shared_ptr<Processor> p) const
1401 {
1402         if (p == _amp || p == _meter || p == _main_outs || p == _delayline || p == _trim || p == _polarity) {
1403                 return true;
1404         }
1405 #ifdef MIXBUS
1406         if (p == _ch_pre || p == _ch_post || p == _ch_eq  || p == _ch_comp) {
1407                 return true;
1408         }
1409 #endif
1410         return false;
1411 }
1412
1413 int
1414 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1415 {
1416         // TODO once the export point can be configured properly, do something smarter here
1417         if (processor == _capturing_processor) {
1418                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1419                 if (need_process_lock) {
1420                         lx.acquire();
1421                 }
1422
1423                 _capturing_processor.reset();
1424
1425                 if (need_process_lock) {
1426                         lx.release();
1427                 }
1428         }
1429
1430         /* these can never be removed */
1431
1432         if (is_internal_processor (processor)) {
1433                 return 0;
1434         }
1435
1436         if (!_session.engine().running()) {
1437                 return 1;
1438         }
1439
1440         processor_max_streams.reset();
1441
1442         {
1443                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1444                 if (need_process_lock) {
1445                         lx.acquire();
1446                 }
1447
1448                 /* Caller must hold process lock */
1449                 assert (!AudioEngine::instance()->process_lock().trylock());
1450
1451                 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1452
1453                 ProcessorState pstate (this);
1454
1455                 ProcessorList::iterator i;
1456                 bool removed = false;
1457
1458                 for (i = _processors.begin(); i != _processors.end(); ) {
1459                         if (*i == processor) {
1460
1461                                 /* move along, see failure case for configure_processors()
1462                                    where we may need to reconfigure the processor.
1463                                 */
1464
1465                                 /* stop redirects that send signals to JACK ports
1466                                    from causing noise as a result of no longer being
1467                                    run.
1468                                 */
1469
1470                                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1471                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
1472
1473                                 if (pi != 0) {
1474                                         assert (iop == 0);
1475                                         iop = pi->sidechain();
1476                                 }
1477
1478                                 if (iop != 0) {
1479                                         iop->disconnect ();
1480                                 }
1481
1482                                 i = _processors.erase (i);
1483                                 removed = true;
1484                                 break;
1485
1486                         } else {
1487                                 ++i;
1488                         }
1489                 }
1490
1491                 if (!removed) {
1492                         /* what? */
1493                         return 1;
1494                 }
1495
1496                 if (configure_processors_unlocked (err, &lm)) {
1497                         pstate.restore ();
1498                         /* we know this will work, because it worked before :) */
1499                         configure_processors_unlocked (0, &lm);
1500                         return -1;
1501                 }
1502
1503                 _have_internal_generator = false;
1504
1505                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1506                         boost::shared_ptr<PluginInsert> pi;
1507
1508                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1509                                 if (pi->has_no_inputs ()) {
1510                                         _have_internal_generator = true;
1511                                         break;
1512                                 }
1513                         }
1514                 }
1515                 if (need_process_lock) {
1516                         lx.release();
1517                 }
1518         }
1519
1520         reset_instrument_info ();
1521         processor->drop_references ();
1522         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1523         set_processor_positions ();
1524
1525         return 0;
1526 }
1527
1528 int
1529 Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
1530 {
1531         /* these can never be removed */
1532         if (is_internal_processor (old)) {
1533                 return 1;
1534         }
1535         /* and can't be used as substitute, either */
1536         if (is_internal_processor (sub)) {
1537                 return 1;
1538         }
1539
1540         /* I/Os are out, too */
1541         if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
1542                 return 1;
1543         }
1544
1545         /* this function cannot be used to swap/reorder processors */
1546         if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
1547                 return 1;
1548         }
1549
1550         if (!AudioEngine::instance()->running() || !old || !sub) {
1551                 return 1;
1552         }
1553
1554         /* ensure that sub is not owned by another route */
1555         if (sub->owner ()) {
1556                 return 1;
1557         }
1558
1559         {
1560                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1561                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1562                 ProcessorState pstate (this);
1563
1564                 assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
1565
1566                 ProcessorList::iterator i;
1567                 bool replaced = false;
1568                 bool enable = old->enabled ();
1569
1570                 for (i = _processors.begin(); i != _processors.end(); ) {
1571                         if (*i == old) {
1572                                 i = _processors.erase (i);
1573                                 _processors.insert (i, sub);
1574                                 sub->set_owner (this);
1575                                 replaced = true;
1576                                 break;
1577                         } else {
1578                                 ++i;
1579                         }
1580                 }
1581
1582                 if (!replaced) {
1583                         return 1;
1584                 }
1585
1586                 if (_strict_io) {
1587                         boost::shared_ptr<PluginInsert> pi;
1588                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
1589                                 pi->set_strict_io (true);
1590                         }
1591                 }
1592
1593                 if (configure_processors_unlocked (err, &lm)) {
1594                         pstate.restore ();
1595                         configure_processors_unlocked (0, &lm);
1596                         return -1;
1597                 }
1598
1599                 _have_internal_generator = false;
1600
1601                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1602                         boost::shared_ptr<PluginInsert> pi;
1603                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1604                                 if (pi->has_no_inputs ()) {
1605                                         _have_internal_generator = true;
1606                                         break;
1607                                 }
1608                         }
1609                 }
1610
1611                 if (enable) {
1612                         sub->enable (true);
1613                 }
1614
1615                 sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1616         }
1617
1618         reset_instrument_info ();
1619         old->drop_references ();
1620         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1621         set_processor_positions ();
1622         return 0;
1623 }
1624
1625 int
1626 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1627 {
1628         ProcessorList deleted;
1629
1630         if (!_session.engine().running()) {
1631                 return 1;
1632         }
1633
1634         processor_max_streams.reset();
1635
1636         {
1637                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1638                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1639                 ProcessorState pstate (this);
1640
1641                 ProcessorList::iterator i;
1642                 boost::shared_ptr<Processor> processor;
1643
1644                 for (i = _processors.begin(); i != _processors.end(); ) {
1645
1646                         processor = *i;
1647
1648                         /* these can never be removed */
1649
1650                         if (is_internal_processor (processor)) {
1651                                 ++i;
1652                                 continue;
1653                         }
1654
1655                         /* see if its in the list of processors to delete */
1656
1657                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1658                                 ++i;
1659                                 continue;
1660                         }
1661
1662                         /* stop IOProcessors that send to JACK ports
1663                            from causing noise as a result of no longer being
1664                            run.
1665                         */
1666
1667                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(processor);
1668                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
1669                         if (pi != 0) {
1670                                 assert (iop == 0);
1671                                 iop = pi->sidechain();
1672                         }
1673
1674                         if (iop != 0) {
1675                                 iop->disconnect ();
1676                         }
1677
1678                         deleted.push_back (processor);
1679                         i = _processors.erase (i);
1680                 }
1681
1682                 if (deleted.empty()) {
1683                         /* none of those in the requested list were found */
1684                         return 0;
1685                 }
1686
1687                 if (configure_processors_unlocked (err, &lm)) {
1688                         pstate.restore ();
1689                         /* we know this will work, because it worked before :) */
1690                         configure_processors_unlocked (0, &lm);
1691                         return -1;
1692                 }
1693                 //lx.unlock();
1694
1695                 _have_internal_generator = false;
1696
1697                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1698                         boost::shared_ptr<PluginInsert> pi;
1699
1700                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1701                                 if (pi->has_no_inputs ()) {
1702                                         _have_internal_generator = true;
1703                                         break;
1704                                 }
1705                         }
1706                 }
1707         }
1708
1709         /* now try to do what we need to so that those that were removed will be deleted */
1710
1711         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1712                 (*i)->drop_references ();
1713         }
1714
1715         reset_instrument_info ();
1716         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1717         set_processor_positions ();
1718
1719         return 0;
1720 }
1721
1722 void
1723 Route::reset_instrument_info ()
1724 {
1725         boost::shared_ptr<Processor> instr = the_instrument();
1726         if (instr) {
1727                 _instrument_info.set_internal_instrument (instr);
1728         }
1729 }
1730
1731 /** Caller must hold process lock */
1732 int
1733 Route::configure_processors (ProcessorStreams* err)
1734 {
1735 #ifndef PLATFORM_WINDOWS
1736         assert (!AudioEngine::instance()->process_lock().trylock());
1737 #endif
1738
1739         if (!_in_configure_processors) {
1740                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1741                 return configure_processors_unlocked (err, &lm);
1742         }
1743
1744         return 0;
1745 }
1746
1747 ChanCount
1748 Route::input_streams () const
1749 {
1750         return _input->n_ports ();
1751 }
1752
1753 list<pair<ChanCount, ChanCount> >
1754 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1755 {
1756         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1757
1758         return try_configure_processors_unlocked (in, err);
1759 }
1760
1761 list<pair<ChanCount, ChanCount> >
1762 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1763 {
1764         // Check each processor in order to see if we can configure as requested
1765         ChanCount out;
1766         list<pair<ChanCount, ChanCount> > configuration;
1767         uint32_t index = 0;
1768
1769         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1770         DEBUG_TRACE (DEBUG::Processors, "{\n");
1771
1772         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1773
1774                 if ((*p)->can_support_io_configuration(in, out)) {
1775
1776                         if (boost::dynamic_pointer_cast<Delivery> (*p)
1777                                         && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main
1778                                         && !is_auditioner()
1779                                         && (is_monitor() || _strict_io || Profile->get_mixbus ())) {
1780                                 /* with strict I/O the panner + output are forced to
1781                                  * follow the last processor's output.
1782                                  *
1783                                  * Delivery::can_support_io_configuration() will only add ports,
1784                                  * but not remove excess ports.
1785                                  *
1786                                  * This works because the delivery only requires
1787                                  * as many outputs as there are inputs.
1788                                  * Delivery::configure_io() will do the actual removal
1789                                  * by calling _output->ensure_io()
1790                                  */
1791                                 if (!is_master() && _session.master_out () && in.n_audio() > 0) {
1792                                         /* ..but at least as many as there are master-inputs, if
1793                                          * the delivery is dealing with audio */
1794                                         // XXX this may need special-casing for mixbus (master-outputs)
1795                                         // and should maybe be a preference anyway ?!
1796                                         out = ChanCount::max (in, _session.master_out ()->n_inputs ());
1797                                 } else {
1798                                         out = in;
1799                                 }
1800                         }
1801
1802                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1803                         configuration.push_back(make_pair(in, out));
1804
1805                         if (is_monitor()) {
1806                                 // restriction for Monitor Section Processors
1807                                 if (in.n_audio() != out.n_audio() || out.n_midi() > 0) {
1808                                         /* Note: The Monitor follows the master-bus and has no panner.
1809                                          *
1810                                          * The general idea is to only allow plugins that retain the channel-count
1811                                          * and plugins with MIDI in (e.g VSTs with control that will remain unconnected).
1812                                          * Then again 5.1 in, monitor stereo is a valid use-case.
1813                                          *
1814                                          * and worse: we only refuse adding plugins *here*.
1815                                          *
1816                                          * 1) stereo-master, stereo-mon, add a stereo-plugin, OK
1817                                          * 2) change master-bus, add a channel
1818                                          * 2a) monitor-secion follows
1819                                          * 3) monitor processors fail to re-reconfigure (stereo plugin)
1820                                          * 4) re-load session, monitor-processor remains unconfigured, crash.
1821                                          */
1822                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: Channel configuration change.\n");
1823                                 }
1824                                 if (boost::dynamic_pointer_cast<InternalSend> (*p)) {
1825                                         // internal sends make no sense, only feedback
1826                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1827                                         return list<pair<ChanCount, ChanCount> > ();
1828                                 }
1829                                 if (boost::dynamic_pointer_cast<PortInsert> (*p)) {
1830                                         /* External Sends can be problematic. one can add/remove ports
1831                                          * there signal leaves the DAW to external monitors anyway, so there's
1832                                          * no real use for allowing them here anyway.
1833                                          */
1834                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No External Sends allowed.\n");
1835                                         return list<pair<ChanCount, ChanCount> > ();
1836                                 }
1837                                 if (boost::dynamic_pointer_cast<Send> (*p)) {
1838                                         // ditto
1839                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
1840                                         return list<pair<ChanCount, ChanCount> > ();
1841                                 }
1842                         }
1843                         in = out;
1844                 } else {
1845                         if (err) {
1846                                 err->index = index;
1847                                 err->count = in;
1848                         }
1849                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1850                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1851                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1852                         return list<pair<ChanCount, ChanCount> > ();
1853                 }
1854         }
1855
1856         DEBUG_TRACE (DEBUG::Processors, "}\n");
1857
1858         return configuration;
1859 }
1860
1861 /** Set the input/output configuration of each processor in the processors list.
1862  *  Caller must hold process lock.
1863  *  Return 0 on success, otherwise configuration is impossible.
1864  */
1865 int
1866 Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLock::WriterLock* lm)
1867 {
1868 #ifndef PLATFORM_WINDOWS
1869         assert (!AudioEngine::instance()->process_lock().trylock());
1870 #endif
1871
1872         if (_in_configure_processors) {
1873                 return 0;
1874         }
1875
1876         /* put invisible processors where they should be */
1877         setup_invisible_processors ();
1878
1879         _in_configure_processors = true;
1880
1881         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1882
1883         if (configuration.empty ()) {
1884                 _in_configure_processors = false;
1885                 return -1;
1886         }
1887
1888         ChanCount out;
1889         bool seen_mains_out = false;
1890         processor_out_streams = _input->n_ports();
1891         processor_max_streams.reset();
1892
1893         /* processor configure_io() may result in adding ports
1894          * e.g. Delivery::configure_io -> ARDOUR::IO::ensure_io ()
1895          *
1896          * with jack2 adding ports results in a graph-order callback,
1897          * which calls Session::resort_routes() and eventually
1898          * Route::direct_feeds_according_to_reality()
1899          * which takes a ReaderLock (_processor_lock).
1900          *
1901          * so we can't hold a WriterLock here until jack2 threading
1902          * is fixed.
1903          *
1904          * NB. we still hold the process lock
1905          *
1906          * (ardour's own engines do call graph-order from the
1907          * process-thread and hence do not have this issue; besides
1908          * merely adding ports won't trigger a graph-order, only
1909          * making connections does)
1910          */
1911         lm->release ();
1912
1913         // TODO check for a potential ReaderLock after ReaderLock ??
1914         Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
1915
1916         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1917         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1918
1919                 if (!(*p)->configure_io(c->first, c->second)) {
1920                         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
1921                         _in_configure_processors = false;
1922                         lr.release ();
1923                         lm->acquire ();
1924                         return -1;
1925                 }
1926
1927                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1928                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1929
1930                 boost::shared_ptr<IOProcessor> iop;
1931                 boost::shared_ptr<PluginInsert> pi;
1932                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
1933                         /* plugins connected via Split or Hide Match may have more channels.
1934                          * route/scratch buffers are needed for all of them
1935                          * The configuration may only be a subset (both input and output)
1936                          */
1937                         processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
1938                 }
1939                 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
1940                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
1941                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
1942                 }
1943                 out = c->second;
1944
1945                 if (boost::dynamic_pointer_cast<Delivery> (*p)
1946                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
1947                         /* main delivery will increase port count to match input.
1948                          * the Delivery::Main is usually the last processor - followed only by
1949                          * 'MeterOutput'.
1950                          */
1951                         seen_mains_out = true;
1952                 }
1953                 if (!seen_mains_out) {
1954                         processor_out_streams = out;
1955                 }
1956         }
1957
1958         lr.release ();
1959         lm->acquire ();
1960
1961
1962         if (_meter) {
1963                 _meter->set_max_channels (processor_max_streams);
1964         }
1965
1966         /* make sure we have sufficient scratch buffers to cope with the new processor
1967            configuration
1968         */
1969         _session.ensure_buffers (n_process_buffers ());
1970
1971         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1972
1973         _in_configure_processors = false;
1974         return 0;
1975 }
1976
1977 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1978  *  @param state New active state for those processors.
1979  */
1980 void
1981 Route::all_visible_processors_active (bool state)
1982 {
1983         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1984
1985         if (_processors.empty()) {
1986                 return;
1987         }
1988
1989         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1990                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1991                         continue;
1992                 }
1993 #ifdef MIXBUS
1994                 boost::shared_ptr<PluginInsert> pi;
1995                 if (0 != (pi = boost::dynamic_pointer_cast<PluginInsert>(*i))) {
1996                         if (pi->is_channelstrip ()) {
1997                                 continue;
1998                         }
1999                 }
2000 #endif
2001                 (*i)->enable (state);
2002         }
2003
2004         _session.set_dirty ();
2005 }
2006
2007 bool
2008 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
2009 {
2010         /* check if re-order requires re-configuration of any processors
2011          * -> compare channel configuration for all processors
2012          */
2013         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2014         ChanCount c = input_streams ();
2015
2016         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
2017                 bool found = false;
2018                 if (c != (*j)->input_streams()) {
2019                         return true;
2020                 }
2021                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2022                         if (*i == *j) {
2023                                 found = true;
2024                                 if ((*i)->input_streams() != c) {
2025                                         return true;
2026                                 }
2027                                 c = (*i)->output_streams();
2028                                 break;
2029                         }
2030                 }
2031                 if (!found) {
2032                         return true;
2033                 }
2034         }
2035         return false;
2036 }
2037
2038 #ifdef __clang__
2039 __attribute__((annotate("realtime")))
2040 #endif
2041 void
2042 Route::apply_processor_order (const ProcessorList& new_order)
2043 {
2044         /* need to hold processor_lock; either read or write lock
2045          * and the engine process_lock.
2046          * Due to r/w lock ambiguity we can only assert the latter
2047          */
2048         assert (!AudioEngine::instance()->process_lock().trylock());
2049
2050
2051         /* "new_order" is an ordered list of processors to be positioned according to "placement".
2052          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
2053          * processors in the current actual processor list that are hidden. Any visible processors
2054          *  in the current list but not in "new_order" will be assumed to be deleted.
2055          */
2056
2057         /* "as_it_will_be" and "_processors" are lists of shared pointers.
2058          * actual memory usage is small, but insert/erase is not actually rt-safe :(
2059          * (note though that  ::processors_reorder_needs_configure() ensured that
2060          * this function will only ever be called from the rt-thread if no processor were removed)
2061          *
2062          * either way, I can't proove it, but an x-run due to re-order here is less likley
2063          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
2064          */
2065
2066         ProcessorList as_it_will_be;
2067         ProcessorList::iterator oiter;
2068         ProcessorList::const_iterator niter;
2069
2070         oiter = _processors.begin();
2071         niter = new_order.begin();
2072
2073         while (niter !=  new_order.end()) {
2074
2075                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
2076                    then append it to the temp list.
2077
2078                    Otherwise, see if the next processor in the old list is in the new list. if not,
2079                    its been deleted. If its there, append it to the temp list.
2080                    */
2081
2082                 if (oiter == _processors.end()) {
2083
2084                         /* no more elements in the old list, so just stick the rest of
2085                            the new order onto the temp list.
2086                            */
2087
2088                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
2089                         while (niter != new_order.end()) {
2090                                 ++niter;
2091                         }
2092                         break;
2093
2094                 } else {
2095
2096                         if (!(*oiter)->display_to_user()) {
2097
2098                                 as_it_will_be.push_back (*oiter);
2099
2100                         } else {
2101
2102                                 /* visible processor: check that its in the new order */
2103
2104                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
2105                                         /* deleted: do nothing, shared_ptr<> will clean up */
2106                                 } else {
2107                                         /* ignore this one, and add the next item from the new order instead */
2108                                         as_it_will_be.push_back (*niter);
2109                                         ++niter;
2110                                 }
2111                         }
2112
2113                         /* now remove from old order - its taken care of no matter what */
2114                         oiter = _processors.erase (oiter);
2115                 }
2116
2117         }
2118         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2119
2120         /* If the meter is in a custom position, find it and make a rough note of its position */
2121         maybe_note_meter_position ();
2122 }
2123
2124 void
2125 Route::move_instrument_down (bool postfader)
2126 {
2127         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2128         ProcessorList new_order;
2129         boost::shared_ptr<Processor> instrument;
2130         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2131                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
2132                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
2133                         instrument = *i;
2134                 } else if (instrument && *i == _amp) {
2135                         if (postfader) {
2136                                 new_order.push_back (*i);
2137                                 new_order.push_back (instrument);
2138                         } else {
2139                                 new_order.push_back (instrument);
2140                                 new_order.push_back (*i);
2141                         }
2142                 } else {
2143                         new_order.push_back (*i);
2144                 }
2145         }
2146         if (!instrument) {
2147                 return;
2148         }
2149         lm.release ();
2150         reorder_processors (new_order, 0);
2151 }
2152
2153 int
2154 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2155 {
2156         // it a change is already queued, wait for it
2157         // (unless engine is stopped. apply immediately and proceed
2158         while (g_atomic_int_get (&_pending_process_reorder)) {
2159                 if (!AudioEngine::instance()->running()) {
2160                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2161                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2162
2163                         apply_processor_order(_pending_processor_order);
2164                         setup_invisible_processors ();
2165
2166                         g_atomic_int_set (&_pending_process_reorder, 0);
2167
2168                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2169                         set_processor_positions ();
2170                 } else {
2171                         // TODO rather use a semaphore or something.
2172                         // but since ::reorder_processors() is called
2173                         // from the GUI thread, this is fine..
2174                         Glib::usleep(500);
2175                 }
2176         }
2177
2178         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2179
2180                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2181                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2182                 ProcessorState pstate (this);
2183
2184                 apply_processor_order (new_order);
2185
2186                 if (configure_processors_unlocked (err, &lm)) {
2187                         pstate.restore ();
2188                         return -1;
2189                 }
2190
2191                 lm.release();
2192                 lx.release();
2193
2194                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2195                 set_processor_positions ();
2196
2197         } else {
2198                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2199                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2200
2201                 // _pending_processor_order is protected by _processor_lock
2202                 _pending_processor_order = new_order;
2203                 g_atomic_int_set (&_pending_process_reorder, 1);
2204         }
2205
2206         /* update processor input/output latency
2207          * (total signal_latency does not change)
2208          */
2209         update_signal_latency (true);
2210
2211         return 0;
2212 }
2213
2214 bool
2215 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2216 {
2217         if (_session.actively_recording ()) {
2218                 return false;
2219         }
2220
2221         boost::shared_ptr<PluginInsert> pi;
2222         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2223                 return false;
2224         }
2225
2226         if (pi->has_sidechain () == add) {
2227                 return true; // ?? call failed, but result is as expected.
2228         }
2229
2230         {
2231                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2232                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2233                 if (i == _processors.end ()) {
2234                         return false;
2235                 }
2236         }
2237
2238         {
2239                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2240                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2241                 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2242
2243                 lx.release (); // IO::add_port() and ~IO takes process lock  - XXX check if this is safe
2244                 if (add) {
2245                         if (!pi->add_sidechain ()) {
2246                                 return false;
2247                         }
2248                 } else {
2249                         if (!pi->del_sidechain ()) {
2250                                 return false;
2251                         }
2252                 }
2253
2254                 lx.acquire ();
2255                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2256                 lx.release ();
2257
2258                 if (c.empty()) {
2259                         if (add) {
2260                                 pi->del_sidechain ();
2261                         } else {
2262                                 pi->add_sidechain ();
2263                                 // TODO restore side-chain's state.
2264                         }
2265                         return false;
2266                 }
2267                 lx.acquire ();
2268                 configure_processors_unlocked (0, &lm);
2269         }
2270
2271         if (pi->has_sidechain ()) {
2272                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2273         }
2274
2275         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2276         _session.set_dirty ();
2277         return true;
2278 }
2279
2280 bool
2281 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2282 {
2283         if (_session.actively_recording ()) {
2284                 return false;
2285         }
2286
2287         boost::shared_ptr<PluginInsert> pi;
2288         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2289                 return false;
2290         }
2291
2292         {
2293                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2294                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2295                 if (i == _processors.end ()) {
2296                         return false;
2297                 }
2298         }
2299
2300         {
2301                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2302                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2303
2304                 const ChanCount& old (pi->preset_out ());
2305                 if (!pi->set_preset_out (outs)) {
2306                         return true; // no change, OK
2307                 }
2308
2309                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2310                 if (c.empty()) {
2311                         /* not possible */
2312                         pi->set_preset_out (old);
2313                         return false;
2314                 }
2315                 configure_processors_unlocked (0, &lm);
2316         }
2317
2318         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2319         _session.set_dirty ();
2320         return true;
2321 }
2322
2323 bool
2324 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2325 {
2326         ChanCount unused;
2327         return customize_plugin_insert (proc, 0, unused, unused);
2328 }
2329
2330 bool
2331 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
2332 {
2333         if (_session.actively_recording ()) {
2334                 return false;
2335         }
2336         boost::shared_ptr<PluginInsert> pi;
2337         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2338                 return false;
2339         }
2340
2341         {
2342                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2343                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2344                 if (i == _processors.end ()) {
2345                         return false;
2346                 }
2347         }
2348
2349         {
2350                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2351                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2352
2353                 bool      old_cust  = pi->custom_cfg ();
2354                 uint32_t  old_cnt   = pi->get_count ();
2355                 ChanCount old_chan  = pi->output_streams ();
2356                 ChanCount old_sinks = pi->natural_input_streams ();
2357
2358                 if (count == 0) {
2359                         pi->set_custom_cfg (false);
2360                 } else {
2361                         pi->set_custom_cfg (true);
2362                         pi->set_count (count);
2363                         pi->set_outputs (outs);
2364                         pi->set_sinks (sinks);
2365                 }
2366
2367                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2368                 if (c.empty()) {
2369                         /* not possible */
2370
2371                         pi->set_count (old_cnt);
2372                         pi->set_sinks (old_sinks);
2373                         pi->set_outputs (old_chan);
2374                         pi->set_custom_cfg (old_cust);
2375
2376                         return false;
2377                 }
2378                 configure_processors_unlocked (0, &lm);
2379         }
2380
2381         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2382         _session.set_dirty ();
2383         return true;
2384 }
2385
2386 bool
2387 Route::set_strict_io (const bool enable)
2388 {
2389         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2390
2391         if (_strict_io != enable) {
2392                 _strict_io = enable;
2393                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2394                 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2395                         boost::shared_ptr<PluginInsert> pi;
2396                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2397                                 pi->set_strict_io (_strict_io);
2398                         }
2399                 }
2400
2401                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2402
2403                 if (c.empty()) {
2404                         // not possible
2405                         _strict_io = !enable; // restore old value
2406                         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2407                                 boost::shared_ptr<PluginInsert> pi;
2408                                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2409                                         pi->set_strict_io (_strict_io);
2410                                 }
2411                         }
2412                         return false;
2413                 }
2414                 lm.release ();
2415
2416                 configure_processors (0);
2417                 lx.release ();
2418
2419                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2420                 _session.set_dirty ();
2421         }
2422         return true;
2423 }
2424
2425 XMLNode&
2426 Route::get_state()
2427 {
2428         return state (false);
2429 }
2430
2431 XMLNode&
2432 Route::get_template()
2433 {
2434         return state (true);
2435 }
2436
2437 XMLNode&
2438 Route::state (bool save_template)
2439 {
2440         if (!_session._template_state_dir.empty()) {
2441                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2442         }
2443
2444         XMLNode *node = new XMLNode("Route");
2445         ProcessorList::iterator i;
2446
2447         if(save_template) {
2448                 XMLNode* child = node->add_child("ProgramVersion");
2449                 child->set_property("created-with", _session.created_with);
2450
2451                 std::string modified_with = string_compose ("%1 %2", PROGRAM_NAME, revision);
2452                 child->set_property("modified-with", modified_with);
2453         }
2454
2455         node->set_property (X_("id"), id ());
2456         node->set_property (X_("name"), name());
2457         node->set_property (X_("default-type"), _default_type);
2458         node->set_property (X_("strict-io"), _strict_io);
2459
2460         node->add_child_nocopy (_presentation_info.get_state());
2461
2462         node->set_property (X_("active"), _active);
2463         node->set_property (X_("denormal-protection"), _denormal_protection);
2464         node->set_property (X_("meter-point"), _meter_point);
2465         node->set_property (X_("disk-io-point"), _disk_io_point);
2466
2467         node->set_property (X_("meter-type"), _meter->meter_type ());
2468
2469         if (_route_group) {
2470                 node->set_property (X_("route-group"), _route_group->name());
2471         }
2472
2473         node->add_child_nocopy (_solo_control->get_state ());
2474         node->add_child_nocopy (_solo_isolate_control->get_state ());
2475         node->add_child_nocopy (_solo_safe_control->get_state ());
2476
2477         node->add_child_nocopy (_input->get_state ());
2478         node->add_child_nocopy (_output->get_state ());
2479         node->add_child_nocopy (_mute_master->get_state ());
2480
2481         node->add_child_nocopy (_mute_control->get_state ());
2482         node->add_child_nocopy (_phase_control->get_state ());
2483
2484         if (!skip_saving_automation) {
2485                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2486         }
2487
2488         if (_comment.length()) {
2489                 XMLNode *cmt = node->add_child ("Comment");
2490                 cmt->add_content (_comment);
2491         }
2492
2493         if (_pannable) {
2494                 node->add_child_nocopy (_pannable->get_state ());
2495         }
2496
2497         {
2498                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2499                 for (i = _processors.begin(); i != _processors.end(); ++i) {
2500                         if (*i == _delayline) {
2501                                 continue;
2502                         }
2503                         if (save_template) {
2504                                 /* template save: do not include internal sends functioning as
2505                                          aux sends because the chance of the target ID
2506                                          in the session where this template is used
2507                                          is not very likely.
2508
2509                                          similarly, do not save listen sends which connect to
2510                                          the monitor section, because these will always be
2511                                          added if necessary.
2512                                          */
2513                                 boost::shared_ptr<InternalSend> is;
2514
2515                                 if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2516                                         if (is->role() == Delivery::Listen) {
2517                                                 continue;
2518                                         }
2519                                 }
2520                         }
2521                         node->add_child_nocopy((*i)->get_state ());
2522                 }
2523         }
2524
2525         if (_extra_xml) {
2526                 node->add_child_copy (*_extra_xml);
2527         }
2528
2529         if (_custom_meter_position_noted) {
2530                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2531                 if (after) {
2532                         node->set_property (X_("processor-after-last-custom-meter"), after->id());
2533                 }
2534         }
2535
2536         if (!_session._template_state_dir.empty()) {
2537                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2538         }
2539
2540         node->add_child_copy (Slavable::get_state());
2541
2542         return *node;
2543 }
2544
2545 int
2546 Route::set_state (const XMLNode& node, int version)
2547 {
2548         if (version < 3000) {
2549                 return set_state_2X (node, version);
2550         }
2551
2552         XMLNodeList nlist;
2553         XMLNodeConstIterator niter;
2554         XMLNode *child;
2555
2556         if (node.name() != "Route"){
2557                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2558                 return -1;
2559         }
2560
2561         std::string route_name;
2562         if (node.get_property (X_("name"), route_name)) {
2563                 Route::set_name (route_name);
2564         }
2565
2566         set_id (node);
2567         _initial_io_setup = true;
2568
2569         Stripable::set_state (node, version);
2570
2571         node.get_property (X_("strict-io"), _strict_io);
2572
2573         if (is_monitor()) {
2574                 /* monitor bus does not get a panner, but if (re)created
2575                    via XML, it will already have one by the time we
2576                    call ::set_state(). so ... remove it.
2577                 */
2578                 unpan ();
2579         }
2580
2581         /* add all processors (except amp, which is always present) */
2582
2583         nlist = node.children();
2584         XMLNode processor_state (X_("processor_state"));
2585
2586         Stateful::save_extra_xml (node);
2587
2588         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2589
2590                 child = *niter;
2591
2592                 if (child->name() == IO::state_node_name) {
2593                         std::string direction;
2594                         if (!child->get_property (X_("direction"), direction)) {
2595                                 continue;
2596                         }
2597
2598                         if (direction == "Input") {
2599                                 _input->set_state (*child, version);
2600                         } else if (direction == "Output") {
2601                                 _output->set_state (*child, version);
2602                         }
2603
2604                 } else if (child->name() == X_("Processor")) {
2605                         processor_state.add_child_copy (*child);
2606                 } else if (child->name() == X_("Pannable")) {
2607                         if (_pannable) {
2608                                 _pannable->set_state (*child, version);
2609                         } else {
2610                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2611                         }
2612                 } else if (child->name() == Slavable::xml_node_name) {
2613                         Slavable::set_state (*child, version);
2614                 }
2615         }
2616
2617         MeterPoint mp;
2618         if (node.get_property (X_("meter-point"), mp)) {
2619                 set_meter_point (mp, true);
2620                 if (_meter) {
2621                         _meter->set_display_to_user (_meter_point == MeterCustom);
2622                 }
2623         }
2624
2625         DiskIOPoint diop;
2626         if (node.get_property (X_("disk-io-point"), diop)) {
2627                 if (_disk_writer) {
2628                         _disk_writer->set_display_to_user (diop == DiskIOCustom);
2629                 }
2630                 if (_disk_reader) {
2631                         _disk_reader->set_display_to_user (diop == DiskIOCustom);
2632                 }
2633                 set_disk_io_point (diop);
2634         }
2635
2636         MeterType meter_type;
2637         if (node.get_property (X_("meter-type"), meter_type)) {
2638                 set_meter_type (meter_type);
2639         }
2640
2641         _initial_io_setup = false;
2642
2643         set_processor_state (processor_state);
2644
2645         // this looks up the internal instrument in processors
2646         reset_instrument_info();
2647
2648         bool denormal_protection;
2649         if (node.get_property (X_("denormal-protection"), denormal_protection)) {
2650                 set_denormal_protection (denormal_protection);
2651         }
2652
2653         /* convert old 3001 state */
2654         std::string phase_invert_str;
2655         if (node.get_property (X_("phase-invert"), phase_invert_str)) {
2656                 _phase_control->set_phase_invert (boost::dynamic_bitset<> (phase_invert_str));
2657         }
2658
2659         bool is_active;
2660         if (node.get_property (X_("active"), is_active)) {
2661                 set_active (is_active, this);
2662         }
2663
2664         std::string id_string;
2665         if (node.get_property (X_("processor-after-last-custom-meter"), id_string)) {
2666                 PBD::ID id (id_string);
2667                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2668                 ProcessorList::const_iterator i = _processors.begin ();
2669                 while (i != _processors.end() && (*i)->id() != id) {
2670                         ++i;
2671                 }
2672
2673                 if (i != _processors.end ()) {
2674                         _processor_after_last_custom_meter = *i;
2675                         _custom_meter_position_noted = true;
2676                 }
2677         }
2678
2679         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2680                 child = *niter;
2681
2682                 if (child->name() == X_("Comment")) {
2683
2684                         /* XXX this is a terrible API design in libxml++ */
2685
2686                         XMLNode *cmt = *(child->children().begin());
2687                         _comment = cmt->content();
2688
2689                 }  else if (child->name() == Controllable::xml_node_name) {
2690                         std::string control_name;
2691                         if (!child->get_property (X_("name"), control_name)) {
2692                                 continue;
2693                         }
2694
2695                         if (control_name == _solo_control->name()) {
2696                                 _solo_control->set_state (*child, version);
2697                         } else if (control_name == _solo_safe_control->name()) {
2698                                 _solo_safe_control->set_state (*child, version);
2699                         } else if (control_name == _solo_isolate_control->name()) {
2700                                 _solo_isolate_control->set_state (*child, version);
2701                         } else if (control_name == _mute_control->name()) {
2702                                 _mute_control->set_state (*child, version);
2703                         } else if (control_name == _phase_control->name()) {
2704                                 _phase_control->set_state (*child, version);
2705                         } else {
2706                                 Evoral::Parameter p = EventTypeMap::instance().from_symbol (control_name);
2707                                 if (p.type () >= MidiCCAutomation && p.type () < MidiSystemExclusiveAutomation) {
2708                                         boost::shared_ptr<AutomationControl> ac = automation_control (p, true);
2709                                         if (ac) {
2710                                                 ac->set_state (*child, version);
2711                                         }
2712                                 }
2713                         }
2714                 } else if (child->name() == MuteMaster::xml_node_name) {
2715                         _mute_master->set_state (*child, version);
2716
2717                 } else if (child->name() == Automatable::xml_node_name) {
2718                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
2719                 }
2720         }
2721
2722         if (_delayline) {
2723                 _delayline->set_name (name ());
2724         }
2725
2726         return 0;
2727 }
2728
2729 int
2730 Route::set_state_2X (const XMLNode& node, int version)
2731 {
2732         LocaleGuard lg;
2733         XMLNodeList nlist;
2734         XMLNodeConstIterator niter;
2735         XMLNode *child;
2736         XMLProperty const * prop;
2737
2738         /* 2X things which still remain to be handled:
2739          * default-type
2740          * automation
2741          * controlouts
2742          */
2743
2744         if (node.name() != "Route") {
2745                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2746                 return -1;
2747         }
2748
2749         Stripable::set_state (node, version);
2750
2751         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2752                 set_denormal_protection (string_to<bool> (prop->value()));
2753         }
2754
2755         if ((prop = node.property (X_("muted"))) != 0) {
2756
2757                 bool first = true;
2758                 bool muted = string_to<bool> (prop->value());
2759
2760                 if (muted) {
2761
2762                         string mute_point;
2763
2764                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2765
2766                                 if (string_to<bool> (prop->value())){
2767                                         mute_point = mute_point + "PreFader";
2768                                         first = false;
2769                                 }
2770                         }
2771
2772                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2773
2774                                 if (string_to<bool> (prop->value())){
2775
2776                                         if (!first) {
2777                                                 mute_point = mute_point + ",";
2778                                         }
2779
2780                                         mute_point = mute_point + "PostFader";
2781                                         first = false;
2782                                 }
2783                         }
2784
2785                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2786
2787                                 if (string_to<bool> (prop->value())){
2788
2789                                         if (!first) {
2790                                                 mute_point = mute_point + ",";
2791                                         }
2792
2793                                         mute_point = mute_point + "Listen";
2794                                         first = false;
2795                                 }
2796                         }
2797
2798                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2799
2800                                 if (string_to<bool> (prop->value())){
2801
2802                                         if (!first) {
2803                                                 mute_point = mute_point + ",";
2804                                         }
2805
2806                                         mute_point = mute_point + "Main";
2807                                 }
2808                         }
2809
2810                         _mute_master->set_mute_points (mute_point);
2811                         _mute_master->set_muted_by_self (true);
2812                 }
2813         }
2814
2815         if ((prop = node.property (X_("meter-point"))) != 0) {
2816                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2817         }
2818
2819         /* IOs */
2820
2821         nlist = node.children ();
2822         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2823
2824                 child = *niter;
2825
2826                 if (child->name() == IO::state_node_name) {
2827
2828                         /* there is a note in IO::set_state_2X() about why we have to call
2829                            this directly.
2830                            */
2831
2832                         _input->set_state_2X (*child, version, true);
2833                         _output->set_state_2X (*child, version, false);
2834
2835                         if ((prop = child->property (X_("name"))) != 0) {
2836                                 Route::set_name (prop->value ());
2837                         }
2838
2839                         set_id (*child);
2840
2841                         if ((prop = child->property (X_("active"))) != 0) {
2842                                 bool yn = string_to<bool> (prop->value());
2843                                 _active = !yn; // force switch
2844                                 set_active (yn, this);
2845                         }
2846
2847                         if ((prop = child->property (X_("gain"))) != 0) {
2848                                 gain_t val;
2849
2850                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2851                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
2852                                 }
2853                         }
2854
2855                         /* Set up Panners in the IO */
2856                         XMLNodeList io_nlist = child->children ();
2857
2858                         XMLNodeConstIterator io_niter;
2859                         XMLNode *io_child;
2860
2861                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2862
2863                                 io_child = *io_niter;
2864
2865                                 if (io_child->name() == X_("Panner")) {
2866                                         _main_outs->panner_shell()->set_state(*io_child, version);
2867                                 } else if (io_child->name() == X_("Automation")) {
2868                                         /* IO's automation is for the fader */
2869                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2870                                 }
2871                         }
2872                 }
2873         }
2874
2875         XMLNodeList redirect_nodes;
2876
2877         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2878
2879                 child = *niter;
2880
2881                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2882                         redirect_nodes.push_back(child);
2883                 }
2884
2885         }
2886
2887         set_processor_state_2X (redirect_nodes, version);
2888
2889         Stateful::save_extra_xml (node);
2890
2891         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2892                 child = *niter;
2893
2894                 if (child->name() == X_("Comment")) {
2895
2896                         /* XXX this is a terrible API design in libxml++ */
2897
2898                         XMLNode *cmt = *(child->children().begin());
2899                         _comment = cmt->content();
2900
2901                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2902                         if (prop->value() == X_("solo")) {
2903                                 _solo_control->set_state (*child, version);
2904                         } else if (prop->value() == X_("mute")) {
2905                                 _mute_control->set_state (*child, version);
2906                         }
2907
2908                 }
2909         }
2910
2911         return 0;
2912 }
2913
2914 XMLNode&
2915 Route::get_processor_state ()
2916 {
2917         XMLNode* root = new XMLNode (X_("redirects"));
2918         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2919                 root->add_child_nocopy ((*i)->get_state ());
2920         }
2921
2922         return *root;
2923 }
2924
2925 void
2926 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2927 {
2928         /* We don't bother removing existing processors not in nList, as this
2929            method will only be called when creating a Route from scratch, not
2930            for undo purposes.  Just put processors in at the appropriate place
2931            in the list.
2932         */
2933
2934         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2935                 add_processor_from_xml_2X (**i, version);
2936         }
2937 }
2938
2939 void
2940 Route::set_processor_state (const XMLNode& node)
2941 {
2942         const XMLNodeList &nlist = node.children();
2943         XMLNodeConstIterator niter;
2944         ProcessorList new_order;
2945         bool must_configure = false;
2946
2947         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2948
2949                 XMLProperty* prop = (*niter)->property ("type");
2950
2951                 if (prop->value() == "amp") {
2952                         _amp->set_state (**niter, Stateful::current_state_version);
2953                         new_order.push_back (_amp);
2954                 } else if (prop->value() == "trim") {
2955                         _trim->set_state (**niter, Stateful::current_state_version);
2956                         new_order.push_back (_trim);
2957                 } else if (prop->value() == "meter") {
2958                         _meter->set_state (**niter, Stateful::current_state_version);
2959                         new_order.push_back (_meter);
2960                 } else if (prop->value() == "polarity") {
2961                         _polarity->set_state (**niter, Stateful::current_state_version);
2962                         new_order.push_back (_polarity);
2963                 } else if (prop->value() == "delay") {
2964                         // skip -- internal
2965                 } else if (prop->value() == "main-outs") {
2966                         _main_outs->set_state (**niter, Stateful::current_state_version);
2967                 } else if (prop->value() == "intreturn") {
2968                         if (!_intreturn) {
2969                                 _intreturn.reset (new InternalReturn (_session));
2970                                 must_configure = true;
2971                         }
2972                         _intreturn->set_state (**niter, Stateful::current_state_version);
2973                 } else if (is_monitor() && prop->value() == "monitor") {
2974                         if (!_monitor_control) {
2975                                 _monitor_control.reset (new MonitorProcessor (_session));
2976                                 must_configure = true;
2977                         }
2978                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2979                 } else if (prop->value() == "capture") {
2980                         /* CapturingProcessor should never be restored, it's always
2981                            added explicitly when needed */
2982                 } else if (prop->value() == "diskreader" && _disk_reader) {
2983                         _disk_reader->set_state (**niter, Stateful::current_state_version);
2984                         new_order.push_back (_disk_reader);
2985                 } else if (prop->value() == "diskwriter" && _disk_writer) {
2986                         _disk_writer->set_state (**niter, Stateful::current_state_version);
2987                         new_order.push_back (_disk_writer);
2988                 } else {
2989                         set_processor_state (**niter, prop, new_order, must_configure);
2990                 }
2991         }
2992
2993         ProcessorList old_list = _processors; // keep a copy
2994         {
2995                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2996                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2997                 /* re-assign _processors w/o process-lock.
2998                  * if there's an IO-processor present in _processors but
2999                  * not in new_order, it will be deleted and ~IO takes
3000                  * a process lock.
3001                  */
3002                 _processors = new_order;
3003
3004                 /* When a required/existing internal processor is not in the list, it needs to
3005                  * be added via configure_processors() -> setup_invisible_processors()
3006                  */
3007                 if (_monitor_control) {
3008                         must_configure |= find (_processors.begin(), _processors.end(), _monitor_control) == _processors.end ();
3009                 }
3010                 if (_main_outs) {
3011                         must_configure |= find (_processors.begin(), _processors.end(), _main_outs) == _processors.end ();
3012                 }
3013                 if (_delayline) {
3014                         must_configure |= find (_processors.begin(), _processors.end(), _delayline) == _processors.end ();
3015                 }
3016                 if (_intreturn) {
3017                         must_configure |= find (_processors.begin(), _processors.end(), _intreturn) == _processors.end ();
3018                 }
3019
3020                 if (must_configure && !_session.loading()) {
3021                         configure_processors_unlocked (0, &lm);
3022                 }
3023
3024                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3025
3026                         (*i)->set_owner (this);
3027                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
3028
3029                         boost::shared_ptr<PluginInsert> pi;
3030
3031                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
3032                                 if (pi->has_no_inputs ()) {
3033                                         _have_internal_generator = true;
3034                                         break;
3035                                 }
3036                         }
3037                 }
3038         }
3039         /* drop references w/o process-lock (I/O procs may re-take it in ~IO() */
3040         old_list.clear ();
3041
3042         reset_instrument_info ();
3043         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3044         set_processor_positions ();
3045 }
3046
3047 bool
3048 Route::set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure)
3049 {
3050         ProcessorList::iterator o;
3051
3052         for (o = _processors.begin(); o != _processors.end(); ++o) {
3053                 XMLProperty const * id_prop = node.property(X_("id"));
3054                 if (id_prop && (*o)->id() == id_prop->value()) {
3055                         (*o)->set_state (node, Stateful::current_state_version);
3056                         new_order.push_back (*o);
3057                         break;
3058                 }
3059         }
3060
3061         // If the processor (node) is not on the route then create it
3062
3063         if (o == _processors.end()) {
3064
3065                 boost::shared_ptr<Processor> processor;
3066
3067                 if (prop->value() == "intsend") {
3068
3069                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
3070
3071                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
3072                            prop->value() == "lv2" ||
3073                            prop->value() == "windows-vst" ||
3074                            prop->value() == "mac-vst" ||
3075                            prop->value() == "lxvst" ||
3076                            prop->value() == "luaproc" ||
3077                            prop->value() == "audiounit") {
3078
3079                         if (_session.get_disable_all_loaded_plugins ()) {
3080                                 processor.reset (new UnknownProcessor (_session, node));
3081                         } else {
3082                                 processor.reset (new PluginInsert (_session));
3083                                 processor->set_owner (this);
3084                         }
3085                 } else if (prop->value() == "port") {
3086
3087                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
3088
3089                 } else if (prop->value() == "send") {
3090
3091                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
3092                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
3093                         send->SelfDestruct.connect_same_thread (*this,
3094                                                                 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
3095
3096                 } else {
3097                         warning << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
3098                         return false;
3099                 }
3100
3101                 if (processor->set_state (node, Stateful::current_state_version) != 0) {
3102                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
3103                         processor.reset (new UnknownProcessor (_session, node));
3104                 }
3105
3106                 /* set strict I/O only after loading plugin state, because
3107                  * individual plugins may override this */
3108                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
3109                 if (pi && _strict_io) {
3110                         pi->set_strict_io (true);
3111                 }
3112
3113                 /* subscribe to Sidechain IO changes */
3114                 if (pi && pi->has_sidechain ()) {
3115                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
3116                 }
3117
3118                 /* we have to note the monitor send here, otherwise a new one will be created
3119                    and the state of this one will be lost.
3120                 */
3121                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
3122                 if (isend && isend->role() == Delivery::Listen) {
3123                         _monitor_send = isend;
3124                 }
3125
3126                 /* it doesn't matter if invisible processors are added here, as they
3127                    will be sorted out by setup_invisible_processors () shortly.
3128                 */
3129
3130                 new_order.push_back (processor);
3131                 must_configure = true;
3132         }
3133         return true;
3134 }
3135
3136 void
3137 Route::silence (samplecnt_t nframes)
3138 {
3139         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3140         if (!lm.locked()) {
3141                 return;
3142         }
3143
3144         silence_unlocked (nframes);
3145 }
3146
3147 void
3148 Route::silence_unlocked (samplecnt_t nframes)
3149 {
3150         /* Must be called with the processor lock held */
3151
3152         const samplepos_t now = _session.transport_sample ();
3153
3154         _output->silence (nframes);
3155
3156         // update owned automated controllables
3157         automation_run (now, nframes);
3158         if (_pannable) {
3159                 _pannable->automation_run (now, nframes);
3160         }
3161
3162         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3163                 boost::shared_ptr<PluginInsert> pi;
3164
3165                 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
3166                         /* evaluate automated automation controls */
3167                         pi->automation_run (now, nframes);
3168                         /* skip plugins, they don't need anything when we're not active */
3169                         continue;
3170                 }
3171
3172                 (*i)->silence (nframes, now);
3173         }
3174 }
3175
3176 void
3177 Route::add_internal_return ()
3178 {
3179         if (!_intreturn) {
3180                 _intreturn.reset (new InternalReturn (_session));
3181                 add_processor (_intreturn, PreFader);
3182         }
3183 }
3184
3185 void
3186 Route::add_send_to_internal_return (InternalSend* send)
3187 {
3188         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3189
3190         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3191                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3192
3193                 if (d) {
3194                         return d->add_send (send);
3195                 }
3196         }
3197 }
3198
3199 void
3200 Route::remove_send_from_internal_return (InternalSend* send)
3201 {
3202         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3203
3204         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3205                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3206
3207                 if (d) {
3208                         return d->remove_send (send);
3209                 }
3210         }
3211 }
3212
3213 void
3214 Route::enable_monitor_send ()
3215 {
3216         /* Caller must hold process lock */
3217         assert (!AudioEngine::instance()->process_lock().trylock());
3218
3219         /* master never sends to monitor section via the normal mechanism */
3220         assert (!is_master ());
3221         assert (!is_monitor ());
3222
3223         /* make sure we have one */
3224         if (!_monitor_send) {
3225                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3226                 _monitor_send->set_display_to_user (false);
3227         }
3228
3229         /* set it up */
3230         configure_processors (0);
3231 }
3232
3233 /** Add an aux send to a route.
3234  *  @param route route to send to.
3235  *  @param before Processor to insert before, or 0 to insert at the end.
3236  */
3237 int
3238 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3239 {
3240         assert (route != _session.monitor_out ());
3241
3242         {
3243                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3244
3245                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3246
3247                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3248
3249                         if (d && d->target_route() == route) {
3250                                 /* already listening via the specified IO: do nothing */
3251                                 return 0;
3252                         }
3253                 }
3254         }
3255
3256         try {
3257
3258                 boost::shared_ptr<InternalSend> listener;
3259
3260                 {
3261                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3262                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3263                 }
3264
3265                 add_processor (listener, before);
3266
3267         } catch (failed_constructor& err) {
3268                 return -1;
3269         }
3270
3271         return 0;
3272 }
3273
3274 int
3275 Route::add_foldback_send (boost::shared_ptr<Route> route)
3276 {
3277         assert (route != _session.monitor_out ());
3278         boost::shared_ptr<Processor> before = before_processor_for_placement (PreFader);
3279
3280         {
3281                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3282
3283                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3284
3285                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3286
3287                         if (d && d->target_route() == route) {
3288                                 /* already listening via the specified IO: do nothing */
3289                                 return 0;
3290                         }
3291                 }
3292         }
3293
3294         try {
3295
3296                 boost::shared_ptr<InternalSend> listener;
3297
3298                 {
3299                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3300                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Foldback));
3301                 }
3302
3303                 listener->panner_shell()->set_linked_to_route (false);
3304                 add_processor (listener, before);
3305
3306         } catch (failed_constructor& err) {
3307                 return -1;
3308         }
3309         _session.FBSendsChanged ();
3310
3311         return 0;
3312 }
3313
3314 void
3315 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3316 {
3317         ProcessorStreams err;
3318         ProcessorList::iterator tmp;
3319         bool do_fb_signal = false;
3320
3321         {
3322                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3323
3324                 /* have to do this early because otherwise processor reconfig
3325                  * will put _monitor_send back in the list
3326                  */
3327
3328                 if (route == _session.monitor_out()) {
3329                         _monitor_send.reset ();
3330                 }
3331
3332           again:
3333                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3334
3335                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3336
3337                         if (d && d->target_route() == route) {
3338                                 boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send>(d);
3339                                 if (snd && snd->is_foldback()) {
3340                                         do_fb_signal = true;
3341                                 }
3342
3343                                 rl.release ();
3344                                 if (remove_processor (*x, &err, false) > 0) {
3345                                         rl.acquire ();
3346                                         continue;
3347                                 }
3348                                 rl.acquire ();
3349
3350                                 /* list could have been demolished while we dropped the lock
3351                                    so start over.
3352                                 */
3353                                 if (_session.engine().running()) {
3354                                         /* i/o processors cannot be removed if the engine is not running
3355                                          * so don't live-loop in case the engine is N/A or dies
3356                                          */
3357                                         goto again;
3358                                 }
3359                         }
3360                 }
3361         }
3362         if (do_fb_signal) {
3363                 _session.FBSendsChanged ();
3364         }
3365
3366 }
3367
3368 void
3369 Route::set_comment (string cmt, void *src)
3370 {
3371         _comment = cmt;
3372         comment_changed ();
3373         _session.set_dirty ();
3374 }
3375
3376 bool
3377 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3378 {
3379         FeedRecord fr (other, via_sends_only);
3380
3381         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3382
3383         if (!result.second) {
3384
3385                 /* already a record for "other" - make sure sends-only information is correct */
3386                 if (!via_sends_only && result.first->sends_only) {
3387                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3388                         frp->sends_only = false;
3389                 }
3390         }
3391
3392         return result.second;
3393 }
3394
3395 void
3396 Route::clear_fed_by ()
3397 {
3398         _fed_by.clear ();
3399 }
3400
3401 bool
3402 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3403 {
3404         const FedBy& fed_by (other->fed_by());
3405
3406         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3407                 boost::shared_ptr<Route> sr = f->r.lock();
3408
3409                 if (sr && (sr.get() == this)) {
3410
3411                         if (via_sends_only) {
3412                                 *via_sends_only = f->sends_only;
3413                         }
3414
3415                         return true;
3416                 }
3417         }
3418
3419         return false;
3420 }
3421
3422 IOVector
3423 Route::all_inputs () const
3424 {
3425         /* TODO, if this works as expected,
3426          * cache the IOVector and maintain it via
3427          * input_change_handler(), sidechain_change_handler() etc
3428          */
3429         IOVector ios;
3430         ios.push_back (_input);
3431
3432         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3433         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3434
3435                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3436                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3437                 if (pi != 0) {
3438                         assert (iop == 0);
3439                         iop = pi->sidechain();
3440                 }
3441
3442                 if (iop != 0 && iop->input()) {
3443                         ios.push_back (iop->input());
3444                 }
3445         }
3446         return ios;
3447 }
3448
3449 IOVector
3450 Route::all_outputs () const
3451 {
3452         IOVector ios;
3453         // _output is included via Delivery
3454         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3455         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3456                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3457                 if (iop != 0 && iop->output()) {
3458                         ios.push_back (iop->output());
3459                 }
3460         }
3461         return ios;
3462 }
3463
3464 bool
3465 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3466 {
3467         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds from %1 (-> %2)?\n", _name, other->name()));
3468         if (other->all_inputs().fed_by (_output)) {
3469                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS to %1\n", other->name()));
3470                 if (via_send_only) {
3471                         *via_send_only = false;
3472                 }
3473
3474                 return true;
3475         }
3476
3477         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3478
3479         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3480
3481                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3482                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3483                 if (pi != 0) {
3484                         assert (iop == 0);
3485                         iop = pi->sidechain();
3486                 }
3487
3488                 if (iop != 0) {
3489                         boost::shared_ptr<const IO> iop_out = iop->output();
3490                         if (other.get() == this && iop_out && iop->input() && iop_out->connected_to (iop->input())) {
3491                                 // TODO this needs a delaylines in the Insert to align connections (!)
3492                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed its own return (%2)\n", iop->name(), other->name()));
3493                                 continue;
3494                         }
3495                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3496                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3497                                 if (via_send_only) {
3498                                         *via_send_only = true;
3499                                 }
3500                                 return true;
3501                         } else {
3502                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3503                         }
3504                 }
3505         }
3506
3507         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3508         return false;
3509 }
3510
3511 bool
3512 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3513 {
3514         return _session._current_route_graph.has (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other, via_send_only);
3515 }
3516
3517 bool
3518 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3519 {
3520         return _session._current_route_graph.feeds (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other);
3521 }
3522
3523 /** Called from the (non-realtime) butler thread when the transport is stopped */
3524 void
3525 Route::non_realtime_transport_stop (samplepos_t now, bool flush)
3526 {
3527         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3528
3529         Automatable::non_realtime_transport_stop (now, flush);
3530
3531         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3532
3533                 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
3534                         (*i)->flush ();
3535                 }
3536
3537                 (*i)->non_realtime_transport_stop (now, flush);
3538         }
3539 }
3540
3541 void
3542 Route::realtime_handle_transport_stopped ()
3543 {
3544         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3545
3546         /* currently only by Plugin, queue note-off events */
3547         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3548                 (*i)->realtime_handle_transport_stopped ();
3549         }
3550 }
3551
3552
3553 void
3554 Route::input_change_handler (IOChange change, void * /*src*/)
3555 {
3556         if (_session.loading()) {
3557                 return;
3558         }
3559
3560         if ((change.type & IOChange::ConfigurationChanged)) {
3561                 /* This is called with the process lock held if change
3562                    contains ConfigurationChanged
3563                 */
3564                 configure_processors (0);
3565                 io_changed (); /* EMIT SIGNAL */
3566         }
3567
3568         if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3569                 int sbou = 0;
3570                 int ibou = 0;
3571                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3572                 if (_input->connected()) {
3573                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3574                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3575                                         continue;
3576                                 }
3577                                 bool sends_only;
3578                                 bool does_feed = (*i)->direct_feeds_according_to_reality (boost::dynamic_pointer_cast<Route> (shared_from_this()), &sends_only);
3579                                 if (does_feed && !sends_only) {
3580                                         if ((*i)->soloed()) {
3581                                                 ++sbou;
3582                                         }
3583                                         if ((*i)->solo_isolate_control()->solo_isolated()) {
3584                                                 ++ibou;
3585                                         }
3586                                 }
3587                         }
3588                 }
3589
3590                 int delta  = sbou - _solo_control->soloed_by_others_upstream();
3591                 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3592
3593                 if (idelta < -1) {
3594                         PBD::warning << string_compose (
3595                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3596                                         _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3597                                      << endmsg;
3598
3599                 }
3600
3601                 if (_solo_control->soloed_by_others_upstream()) {
3602                         // ignore new connections (they're not propagated)
3603                         if (delta <= 0) {
3604                                 _solo_control->mod_solo_by_others_upstream (delta);
3605                         }
3606                 }
3607
3608                 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3609                         // solo-isolate currently only propagates downstream
3610                         if (idelta < 0) {
3611                                 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3612                         }
3613                         //_solo_isolated_by_upstream = ibou;
3614                 }
3615
3616                 // Session::route_solo_changed  does not propagate indirect solo-changes
3617                 // propagate downstream to tracks
3618                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3619                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3620                                 continue;
3621                         }
3622                         bool sends_only;
3623                         bool does_feed = feeds (*i, &sends_only);
3624                         if (delta <= 0 && does_feed && !sends_only) {
3625                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3626                         }
3627
3628                         if (idelta < 0 && does_feed && !sends_only) {
3629                                 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3630                         }
3631                 }
3632         }
3633 }
3634
3635 void
3636 Route::output_change_handler (IOChange change, void * /*src*/)
3637 {
3638         if (_initial_io_setup) {
3639                 return;
3640         }
3641
3642         if ((change.type & IOChange::ConfigurationChanged)) {
3643                 /* This is called with the process lock held if change
3644                    contains ConfigurationChanged
3645                 */
3646                 configure_processors (0);
3647
3648                 if (is_master()) {
3649                         _session.reset_monitor_section();
3650                 }
3651
3652                 io_changed (); /* EMIT SIGNAL */
3653         }
3654
3655         if ((change.type & IOChange::ConnectionsChanged)) {
3656
3657                 /* do this ONLY if connections have changed. Configuration
3658                  * changes do not, by themselves alter solo upstream or
3659                  * downstream status.
3660                  */
3661
3662                 if (_solo_control->soloed_by_others_downstream()) {
3663                         int sbod = 0;
3664                         /* checking all all downstream routes for
3665                          * explicit of implict solo is a rather drastic measure,
3666                          * ideally the input_change_handler() of the other route
3667                          * would propagate the change to us.
3668                          */
3669                         boost::shared_ptr<RouteList> routes = _session.get_routes ();
3670                         if (_output->connected()) {
3671                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3672                                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3673                                                 continue;
3674                                         }
3675                                         bool sends_only;
3676                                         bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3677                                         if (does_feed && !sends_only) {
3678                                                 if ((*i)->soloed()) {
3679                                                         ++sbod;
3680                                                         break;
3681                                                 }
3682                                         }
3683                                 }
3684                         }
3685
3686                         int delta = sbod - _solo_control->soloed_by_others_downstream();
3687                         if (delta <= 0) {
3688                                 // do not allow new connections to change implicit solo (no propagation)
3689                                 _solo_control->mod_solo_by_others_downstream (delta);
3690                                 // Session::route_solo_changed() does not propagate indirect solo-changes
3691                                 // propagate upstream to tracks
3692                                 boost::shared_ptr<Route> shared_this = boost::dynamic_pointer_cast<Route> (shared_from_this());
3693                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3694                                         if ((*i).get() == this || !can_solo()) {
3695                                                 continue;
3696                                         }
3697                                         bool sends_only;
3698                                         bool does_feed = (*i)->feeds (shared_this, &sends_only);
3699                                         if (delta != 0 && does_feed && !sends_only) {
3700                                                 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3701                                         }
3702                                 }
3703
3704                         }
3705                 }
3706         }
3707 }
3708
3709 void
3710 Route::sidechain_change_handler (IOChange change, void* src)
3711 {
3712         if (_initial_io_setup || _in_sidechain_setup) {
3713                 return;
3714         }
3715
3716         input_change_handler (change, src);
3717 }
3718
3719 uint32_t
3720 Route::pans_required () const
3721 {
3722         if (n_outputs().n_audio() < 2) {
3723                 return 0;
3724         }
3725
3726         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3727 }
3728
3729 void
3730 Route::flush_processor_buffers_locked (samplecnt_t nframes)
3731 {
3732         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3733                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
3734                 if (d) {
3735                         d->flush_buffers (nframes);
3736                 } else {
3737                         boost::shared_ptr<PortInsert> p = boost::dynamic_pointer_cast<PortInsert> (*i);
3738                         if (p) {
3739                                 p->flush_buffers (nframes);
3740                         }
3741                 }
3742         }
3743 }
3744
3745 void
3746 Route::flush_processors ()
3747 {
3748         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3749
3750         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3751                 (*i)->flush ();
3752         }
3753 }
3754
3755 samplecnt_t
3756 Route::playback_latency (bool incl_downstream) const
3757 {
3758         samplecnt_t rv;
3759         if (_disk_reader) {
3760                 rv = _disk_reader->output_latency ();
3761         } else {
3762                 rv = _signal_latency;
3763         }
3764         if (incl_downstream) {
3765                 rv += _output->connected_latency (true);
3766         } else {
3767                 rv += _output->latency ();
3768         }
3769         return rv;
3770 }
3771
3772 pframes_t
3773 Route::latency_preroll (pframes_t nframes, samplepos_t& start_sample, samplepos_t& end_sample)
3774 {
3775         samplecnt_t latency_preroll = _session.remaining_latency_preroll ();
3776         if (latency_preroll == 0) {
3777                 return nframes;
3778         }
3779         if (!_disk_reader) {
3780                 start_sample -= latency_preroll;
3781                 end_sample   -= latency_preroll;
3782                 return nframes;
3783         }
3784
3785         if (latency_preroll > playback_latency ()) {
3786                 no_roll_unlocked (nframes, start_sample - latency_preroll, end_sample - latency_preroll, false);
3787                 return 0;
3788         }
3789
3790         start_sample -= latency_preroll;
3791         end_sample -= latency_preroll;
3792         return nframes;
3793 }
3794
3795 int
3796 Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool& need_butler)
3797 {
3798         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3799
3800         if (!lm.locked()) {
3801                 return 0;
3802         }
3803
3804         if (!_active) {
3805                 silence_unlocked (nframes);
3806                 _meter->reset();
3807                 return 0;
3808         }
3809
3810         if ((nframes = latency_preroll (nframes, start_sample, end_sample)) == 0) {
3811                 return 0;
3812         }
3813
3814         run_route (start_sample, end_sample, nframes, (!_disk_writer || !_disk_writer->record_enabled()) && _session.transport_rolling(), true);
3815
3816         if ((_disk_reader && _disk_reader->need_butler()) || (_disk_writer && _disk_writer->need_butler())) {
3817                 need_butler = true;
3818         }
3819         return 0;
3820 }
3821
3822 int
3823 Route::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
3824 {
3825         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3826
3827         if (!lm.locked()) {
3828                 return 0;
3829         }
3830
3831         return no_roll_unlocked (nframes, start_sample, end_sample, session_state_changing);
3832 }
3833
3834 int
3835 Route::no_roll_unlocked (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
3836 {
3837         /* Must be called with the processor lock held */
3838
3839         if (!_active) {
3840                 silence_unlocked (nframes);
3841                 _meter->reset();
3842                 return 0;
3843         }
3844
3845         if (session_state_changing) {
3846                 if (_session.transport_speed() != 0.0f) {
3847                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3848                            so we cannot use them. Be silent till this is over.
3849
3850                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3851                         */
3852                         silence_unlocked (nframes);
3853                         _meter->reset();
3854                         return 0;
3855                 }
3856                 /* we're really not rolling, so we're either delivery silence or actually
3857                    monitoring, both of which are safe to do while session_state_changing is true.
3858                 */
3859         }
3860
3861         run_route (start_sample, end_sample, nframes, false, false);
3862         return 0;
3863 }
3864
3865 int
3866 Route::silent_roll (pframes_t nframes, samplepos_t /*start_sample*/, samplepos_t /*end_sample*/, bool& /* need_butler */)
3867 {
3868         silence (nframes);
3869         flush_processor_buffers_locked (nframes);
3870         return 0;
3871 }
3872
3873 #ifdef __clang__
3874 __attribute__((annotate("realtime")))
3875 #endif
3876 bool
3877 Route::apply_processor_changes_rt ()
3878 {
3879         int emissions = EmitNone;
3880
3881         if (_pending_meter_point != _meter_point) {
3882                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3883                 if (pwl.locked()) {
3884                         /* meters always have buffers for 'processor_max_streams'
3885                          * they can be re-positioned without re-allocation */
3886                         if (set_meter_point_unlocked()) {
3887                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3888                         } else {
3889                                 emissions |= EmitMeterChanged;
3890                         }
3891                 }
3892         }
3893
3894         bool changed = false;
3895
3896         if (g_atomic_int_get (&_pending_process_reorder)) {
3897                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3898                 if (pwl.locked()) {
3899                         apply_processor_order (_pending_processor_order);
3900                         setup_invisible_processors ();
3901                         changed = true;
3902                         g_atomic_int_set (&_pending_process_reorder, 0);
3903                         emissions |= EmitRtProcessorChange;
3904                 }
3905         }
3906         if (changed) {
3907                 set_processor_positions ();
3908                 /* update processor input/output latency
3909                  * (total signal_latency does not change)
3910                  */
3911                 update_signal_latency (true);
3912         }
3913         if (emissions != 0) {
3914                 g_atomic_int_set (&_pending_signals, emissions);
3915                 return true;
3916         }
3917         return (!selfdestruct_sequence.empty ());
3918 }
3919
3920 void
3921 Route::emit_pending_signals ()
3922 {
3923         int sig = g_atomic_int_and (&_pending_signals, 0);
3924         if (sig & EmitMeterChanged) {
3925                 _meter->emit_configuration_changed();
3926                 meter_change (); /* EMIT SIGNAL */
3927                 if (sig & EmitMeterVisibilityChange) {
3928                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3929                 } else {
3930                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3931                 }
3932         }
3933         if (sig & EmitRtProcessorChange) {
3934                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3935         }
3936
3937         /* this would be a job for the butler.
3938          * Conceptually we should not take processe/processor locks here.
3939          * OTOH its more efficient (less overhead for summoning the butler and
3940          * telling her what do do) and signal emission is called
3941          * directly after the process callback, which decreases the chance
3942          * of x-runs when taking the locks.
3943          */
3944         while (!selfdestruct_sequence.empty ()) {
3945                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3946                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3947                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3948                 selfdestruct_sequence.pop_back ();
3949                 lx.release ();
3950                 if (proc) {
3951                         remove_processor (proc);
3952                 }
3953         }
3954 }
3955
3956 void
3957 Route::set_meter_point (MeterPoint p, bool force)
3958 {
3959         if (_pending_meter_point == p && !force) {
3960                 return;
3961         }
3962
3963         if (force || !AudioEngine::instance()->running()) {
3964                 bool meter_visibly_changed = false;
3965                 {
3966                         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3967                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3968                         _pending_meter_point = p;
3969                         if (set_meter_point_unlocked ()) {
3970                                 meter_visibly_changed = true;
3971                         }
3972                 }
3973                 _meter->emit_configuration_changed();
3974                 meter_change (); /* EMIT SIGNAL */
3975                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3976         } else {
3977                 _pending_meter_point = p;
3978         }
3979 }
3980
3981
3982 #ifdef __clang__
3983 __attribute__((annotate("realtime")))
3984 #endif
3985 bool
3986 Route::set_meter_point_unlocked ()
3987 {
3988 #ifndef NDEBUG
3989         /* Caller must hold process and processor write lock */
3990         assert (!AudioEngine::instance()->process_lock().trylock());
3991         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3992         assert (!lm.locked ());
3993 #endif
3994
3995         _meter_point = _pending_meter_point;
3996
3997         bool meter_was_visible_to_user = _meter->display_to_user ();
3998
3999         if (!_custom_meter_position_noted) {
4000                 maybe_note_meter_position ();
4001         }
4002
4003         if (_meter_point != MeterCustom) {
4004
4005                 _meter->set_display_to_user (false);
4006
4007                 setup_invisible_processors ();
4008
4009         } else {
4010                 _meter->set_display_to_user (true);
4011
4012                 /* If we have a previous position for the custom meter, try to put it there */
4013                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
4014                 if (after) {
4015                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
4016                         if (i != _processors.end ()) {
4017                                 _processors.remove (_meter);
4018                                 _processors.insert (i, _meter);
4019                         }
4020                 } else {// at end, right before the mains_out/panner
4021                         _processors.remove (_meter);
4022                         ProcessorList::iterator main = _processors.end();
4023                         _processors.insert (--main, _meter);
4024                 }
4025         }
4026
4027         /* Set up the meter for its new position */
4028
4029         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
4030
4031         ChanCount m_in;
4032
4033         if (loc == _processors.begin()) {
4034                 m_in = _input->n_ports();
4035         } else {
4036                 ProcessorList::iterator before = loc;
4037                 --before;
4038                 m_in = (*before)->output_streams ();
4039         }
4040
4041         _meter->reflect_inputs (m_in);
4042
4043         /* we do not need to reconfigure the processors, because the meter
4044            (a) is always ready to handle processor_max_streams
4045            (b) is always an N-in/N-out processor, and thus moving
4046            it doesn't require any changes to the other processors.
4047         */
4048
4049         /* these should really be done after releasing the lock
4050          * but all those signals are subscribed to with gui_thread()
4051          * so we're safe.
4052          */
4053          return (_meter->display_to_user() != meter_was_visible_to_user);
4054 }
4055
4056 void
4057 Route::listen_position_changed ()
4058 {
4059         {
4060                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4061                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4062                 ProcessorState pstate (this);
4063
4064                 if (configure_processors_unlocked (0, &lm)) {
4065                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
4066                         pstate.restore ();
4067                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
4068                         return;
4069                 }
4070         }
4071
4072         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
4073         _session.set_dirty ();
4074 }
4075
4076 boost::shared_ptr<CapturingProcessor>
4077 Route::add_export_point()
4078 {
4079         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4080         if (!_capturing_processor) {
4081                 lm.release();
4082                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4083                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
4084
4085                 /* Align all tracks for stem-export w/o processing.
4086                  * Compensate for all plugins between the this route's disk-reader
4087                  * and the common final downstream output (ie alignment point for playback).
4088                  */
4089                 _capturing_processor.reset (new CapturingProcessor (_session, playback_latency (true)));
4090                 configure_processors_unlocked (0, &lw);
4091                 _capturing_processor->activate ();
4092         }
4093
4094         return _capturing_processor;
4095 }
4096
4097 samplecnt_t
4098 Route::update_signal_latency (bool apply_to_delayline)
4099 {
4100         // TODO: bail out if !active() and set/assume _signal_latency = 0,
4101         // here or in Session::* ? -> also zero send latencies,
4102         // and make sure that re-enabling a route updates things again...
4103
4104         samplecnt_t capt_lat_in = _input->connected_latency (false);
4105         samplecnt_t play_lat_out = _output->connected_latency (true);
4106
4107         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4108
4109         samplecnt_t l_in  = 0;
4110         samplecnt_t l_out = 0;
4111         for (ProcessorList::reverse_iterator i = _processors.rbegin(); i != _processors.rend(); ++i) {
4112                 if (boost::shared_ptr<LatentSend> snd = boost::dynamic_pointer_cast<LatentSend> (*i)) {
4113                         snd->set_delay_in (l_out + _output->latency());
4114                 }
4115
4116                 if (boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4117                         if (boost::shared_ptr<IO> pio = pi->sidechain_input ()) {
4118                                 samplecnt_t lat = l_out + _output->latency();
4119                                 pio->set_private_port_latencies (lat, true);
4120                                 pio->set_public_port_latencies (lat, true);
4121                         }
4122                 }
4123                 (*i)->set_output_latency (l_out);
4124                 if ((*i)->active ()) { // XXX
4125                         l_out += (*i)->effective_latency ();
4126                 }
4127         }
4128
4129         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l_out));
4130
4131         _signal_latency = l_out;
4132
4133         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4134
4135                 /* set sidechain, send and insert port latencies */
4136                 if (boost::shared_ptr<PortInsert> pi = boost::dynamic_pointer_cast<PortInsert> (*i)) {
4137                         if (pi->input ()) {
4138                                 /* propagate playback latency from output to input */
4139                                 pi->input ()->set_private_port_latencies (play_lat_out + l_in, true);
4140                         }
4141                         if (pi->output ()) {
4142                                 /* propagate capture latency from input to output */
4143                                 pi->output ()->set_private_port_latencies (capt_lat_in + l_in, false);
4144                         }
4145
4146                 } else if (boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send> (*i)) {
4147                         if (snd->output ()) {
4148                                 /* set capture latency */
4149                                 snd->output ()->set_private_port_latencies (capt_lat_in + l_in, false);
4150                                 /* take send-target's playback latency into account */
4151                                 snd->set_delay_out (snd->output ()->connected_latency (true));
4152                                 /* InternalReturn::set_playback_offset() below, also calls set_delay_out() */
4153                         }
4154                 }
4155
4156                 (*i)->set_input_latency (l_in);
4157                 (*i)->set_playback_offset (_signal_latency + _output->latency ());
4158                 (*i)->set_capture_offset (_input->latency ());
4159                 if ((*i)->active ()) {
4160                         l_in += (*i)->effective_latency ();
4161                 }
4162         }
4163
4164         lm.release ();
4165
4166         if (apply_to_delayline) {
4167                 /* see also Session::post_playback_latency() */
4168                 apply_latency_compensation ();
4169         }
4170
4171         if (_signal_latency != l_out) {
4172                 signal_latency_changed (); /* EMIT SIGNAL */
4173         }
4174
4175         return _signal_latency;
4176 }
4177
4178 void
4179 Route::apply_latency_compensation ()
4180 {
4181         if (_delayline) {
4182                 samplecnt_t old = _delayline->delay ();
4183
4184                 samplecnt_t play_lat_in = _input->connected_latency (true);
4185                 samplecnt_t play_lat_out = _output->connected_latency (true);
4186                 samplecnt_t latcomp = play_lat_in - play_lat_out - _signal_latency;
4187
4188 #if 0 // DEBUG
4189                 samplecnt_t capt_lat_in = _input->connected_latency (false);
4190                 samplecnt_t capt_lat_out = _output->connected_latency (false);
4191                 samplecnt_t latcomp_capt = capt_lat_out - capt_lat_in - _signal_latency;
4192
4193                 cout << "ROUTE " << name() << " delay for " << latcomp << " (c: " << latcomp_capt << ")" << endl;
4194 #endif
4195
4196                 _delayline->set_delay (latcomp > 0 ? latcomp : 0);
4197
4198                 if (old !=  _delayline->delay ()) {
4199                         signal_latency_updated (); /* EMIT SIGNAL */
4200                 }
4201         }
4202 }
4203
4204 void
4205 Route::set_block_size (pframes_t nframes)
4206 {
4207         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4208                 (*i)->set_block_size (nframes);
4209         }
4210
4211         _session.ensure_buffers (n_process_buffers ());
4212 }
4213
4214 void
4215 Route::protect_automation ()
4216 {
4217         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
4218                 (*i)->protect_automation();
4219 }
4220
4221 /** Shift automation forwards from a particular place, thereby inserting time.
4222  *  Adds undo commands for any shifts that are performed.
4223  *
4224  * @param pos Position to start shifting from.
4225  * @param samples Amount to shift forwards by.
4226  */
4227
4228 void
4229 Route::shift (samplepos_t pos, samplecnt_t samples)
4230 {
4231         /* pan automation */
4232         if (_pannable) {
4233                 ControlSet::Controls& c (_pannable->controls());
4234
4235                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
4236                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
4237                         if (pc) {
4238                                 boost::shared_ptr<AutomationList> al = pc->alist();
4239                                 XMLNode& before = al->get_state ();
4240                                 al->shift (pos, samples);
4241                                 XMLNode& after = al->get_state ();
4242                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4243                         }
4244                 }
4245         }
4246
4247         /* TODO mute automation, MuteControl */
4248
4249         /* processor automation (incl. gain, trim,..) */
4250         {
4251                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4252                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
4253
4254                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
4255
4256                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
4257                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
4258                                 if (ac) {
4259                                         boost::shared_ptr<AutomationList> al = ac->alist();
4260                                         if (al->empty ()) {
4261                                                 continue;
4262                                         }
4263                                         XMLNode &before = al->get_state ();
4264                                         al->shift (pos, samples);
4265                                         XMLNode &after = al->get_state ();
4266                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4267                                 }
4268                         }
4269                 }
4270         }
4271 }
4272
4273 void
4274 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4275 {
4276         boost::shared_ptr<Processor> processor (p.lock ());
4277         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4278         if (!pi) {
4279                 return;
4280         }
4281         pi->set_state_dir (d);
4282 }
4283
4284 int
4285 Route::save_as_template (const string& path, const string& name, const string& description)
4286 {
4287         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4288         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4289
4290         XMLNode& node (state (true));
4291         node.set_property (X_("name"), name);
4292
4293         node.remove_nodes (X_("description"));
4294         if (!description.empty()) {
4295                 XMLNode* desc = new XMLNode(X_("description"));
4296                 XMLNode* desc_cont = new XMLNode(X_("content"), description);
4297                 desc->add_child_nocopy (*desc_cont);
4298
4299                 node.add_child_nocopy (*desc);
4300         }
4301
4302         XMLTree tree;
4303
4304         IO::set_name_in_state (*node.children().front(), name);
4305
4306         tree.set_root (&node);
4307
4308         /* return zero on success, non-zero otherwise */
4309         return !tree.write (path.c_str());
4310 }
4311
4312
4313 bool
4314 Route::set_name (const string& str)
4315 {
4316         if (str.empty ()) {
4317                 return false;
4318         }
4319
4320         if (str == name()) {
4321                 return true;
4322         }
4323
4324         string newname = Route::ensure_track_or_route_name (str);
4325
4326         if (newname == name()) {
4327                 return true;
4328         }
4329
4330         SessionObject::set_name (newname);
4331
4332         for (uint32_t n = 0 ; ; ++n) {
4333                 boost::shared_ptr<PluginInsert> pi = boost::static_pointer_cast<PluginInsert> (nth_plugin (n));
4334                 if (!pi) {
4335                         break;
4336                 }
4337                 pi->update_sidechain_name ();
4338         }
4339
4340         bool ret = (_input->set_name(newname) && _output->set_name(newname));
4341
4342         if (ret) {
4343                 /* rename the main outs. Leave other IO processors
4344                  * with whatever name they already have, because its
4345                  * just fine as it is (it will not contain the route
4346                  * name if its a port insert, port send or port return).
4347                  */
4348
4349                 if (_main_outs) {
4350                         if (_main_outs->set_name (newname)) {
4351                                 /* XXX returning false here is stupid because
4352                                    we already changed the route name.
4353                                 */
4354                                 return false;
4355                         }
4356                 }
4357         }
4358
4359         return ret;
4360 }
4361
4362 /** Set the name of a route in an XML description.
4363  *  @param node XML <Route> node to set the name in.
4364  *  @param name New name.
4365  */
4366 void
4367 Route::set_name_in_state (XMLNode& node, string const & name)
4368 {
4369         node.set_property (X_("name"), name);
4370
4371         XMLNodeList children = node.children();
4372         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4373
4374                 if ((*i)->name() == X_("IO")) {
4375
4376                         IO::set_name_in_state (**i, name);
4377
4378                 } else if ((*i)->name() == X_("Processor")) {
4379
4380                         std::string str;
4381                         if ((*i)->get_property (X_("role"), str) && str == X_("Main")) {
4382                                 (*i)->set_property (X_("name"), name);
4383                         }
4384                 }
4385         }
4386 }
4387
4388 boost::shared_ptr<Send>
4389 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4390 {
4391         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4392
4393         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4394                 boost::shared_ptr<InternalSend> send;
4395
4396                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4397                         if (send->target_route() == target) {
4398                                 return send;
4399                         }
4400                 }
4401         }
4402
4403         return boost::shared_ptr<Send>();
4404 }
4405
4406 void
4407 Route::set_denormal_protection (bool yn)
4408 {
4409         if (_denormal_protection != yn) {
4410                 _denormal_protection = yn;
4411                 denormal_protection_changed (); /* EMIT SIGNAL */
4412         }
4413 }
4414
4415 bool
4416 Route::denormal_protection () const
4417 {
4418         return _denormal_protection;
4419 }
4420
4421 void
4422 Route::set_active (bool yn, void* src)
4423 {
4424         if (_session.transport_rolling()) {
4425                 return;
4426         }
4427
4428         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4429                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4430                 return;
4431         }
4432
4433         if (_active != yn) {
4434                 _active = yn;
4435                 _input->set_active (yn);
4436                 _output->set_active (yn);
4437                 flush_processors ();
4438                 active_changed (); // EMIT SIGNAL
4439                 _session.set_dirty ();
4440         }
4441 }
4442
4443 boost::shared_ptr<Pannable>
4444 Route::pannable() const
4445 {
4446         return _pannable;
4447 }
4448
4449 boost::shared_ptr<Panner>
4450 Route::panner() const
4451 {
4452         /* may be null ! */
4453         return _main_outs->panner_shell()->panner();
4454 }
4455
4456 boost::shared_ptr<PannerShell>
4457 Route::panner_shell() const
4458 {
4459         return _main_outs->panner_shell();
4460 }
4461
4462 boost::shared_ptr<GainControl>
4463 Route::gain_control() const
4464 {
4465         return _gain_control;
4466 }
4467
4468 boost::shared_ptr<GainControl>
4469 Route::trim_control() const
4470 {
4471         return _trim_control;
4472 }
4473
4474 boost::shared_ptr<PhaseControl>
4475 Route::phase_control() const
4476 {
4477         return _phase_control;
4478 }
4479
4480 boost::shared_ptr<AutomationControl>
4481 Route::get_control (const Evoral::Parameter& param)
4482 {
4483         /* either we own the control or .... */
4484
4485         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4486
4487         if (!c) {
4488
4489                 /* maybe one of our processors does or ... */
4490
4491                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4492                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4493                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4494                                 break;
4495                         }
4496                 }
4497         }
4498
4499         if (!c) {
4500
4501                 /* nobody does so we'll make a new one */
4502
4503                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4504                 add_control(c);
4505         }
4506
4507         return c;
4508 }
4509
4510 boost::shared_ptr<Processor>
4511 Route::nth_plugin (uint32_t n) const
4512 {
4513         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4514         ProcessorList::const_iterator i;
4515
4516         for (i = _processors.begin(); i != _processors.end(); ++i) {
4517                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4518                         if (n-- == 0) {
4519                                 return *i;
4520                         }
4521                 }
4522         }
4523
4524         return boost::shared_ptr<Processor> ();
4525 }
4526
4527 boost::shared_ptr<Processor>
4528 Route::nth_send (uint32_t n) const
4529 {
4530         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4531         ProcessorList::const_iterator i;
4532
4533         for (i = _processors.begin(); i != _processors.end(); ++i) {
4534                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4535
4536                         if ((*i) == _monitor_send) {
4537                                 /* send to monitor section is not considered
4538                                  * to be an accessible send.
4539                                  */
4540                                 continue;
4541                         }
4542
4543                         if (n-- == 0) {
4544                                 return *i;
4545                         }
4546                 }
4547         }
4548
4549         return boost::shared_ptr<Processor> ();
4550 }
4551
4552 bool
4553 Route::has_io_processor_named (const string& name)
4554 {
4555         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4556         ProcessorList::iterator i;
4557
4558         for (i = _processors.begin(); i != _processors.end(); ++i) {
4559                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4560                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4561                         if ((*i)->name() == name) {
4562                                 return true;
4563                         }
4564                 }
4565         }
4566
4567         return false;
4568 }
4569
4570 void
4571 Route::set_processor_positions ()
4572 {
4573         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4574
4575         bool had_amp = false;
4576         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4577                 (*i)->set_pre_fader (!had_amp);
4578                 if (*i == _amp) {
4579                         had_amp = true;
4580                 }
4581         }
4582 }
4583
4584 /** Called when there is a proposed change to the input port count */
4585 bool
4586 Route::input_port_count_changing (ChanCount to)
4587 {
4588         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4589         if (c.empty()) {
4590                 /* The processors cannot be configured with the new input arrangement, so
4591                    block the change.
4592                 */
4593                 return true;
4594         }
4595
4596         /* The change is ok */
4597         return false;
4598 }
4599
4600 /** Called when there is a proposed change to the output port count */
4601 bool
4602 Route::output_port_count_changing (ChanCount to)
4603 {
4604         if (_strict_io && !_in_configure_processors) {
4605                 return true;
4606         }
4607         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4608                 if (processor_out_streams.get(*t) > to.get(*t)) {
4609                         return true;
4610                 }
4611         }
4612         /* The change is ok */
4613         return false;
4614 }
4615
4616 list<string>
4617 Route::unknown_processors () const
4618 {
4619         list<string> p;
4620
4621         if (_session.get_disable_all_loaded_plugins ()) {
4622                 // Do not list "missing plugins" if they are explicitly disabled
4623                 return p;
4624         }
4625
4626         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4627         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4628                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4629                         p.push_back ((*i)->name ());
4630                 }
4631         }
4632
4633         return p;
4634 }
4635
4636
4637 samplecnt_t
4638 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, samplecnt_t our_latency) const
4639 {
4640         /* we assume that all our input ports feed all our output ports. its not
4641            universally true, but the alternative is way too corner-case to worry about.
4642         */
4643
4644         LatencyRange all_connections;
4645
4646         if (from.empty()) {
4647                 all_connections.min = 0;
4648                 all_connections.max = 0;
4649         } else {
4650                 all_connections.min = ~((pframes_t) 0);
4651                 all_connections.max = 0;
4652
4653                 /* iterate over all "from" ports and determine the latency range for all of their
4654                    connections to the "outside" (outside of this Route).
4655                 */
4656
4657                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4658
4659                         LatencyRange range;
4660
4661                         p->get_connected_latency_range (range, playback);
4662
4663                         all_connections.min = min (all_connections.min, range.min);
4664                         all_connections.max = max (all_connections.max, range.max);
4665                 }
4666         }
4667
4668         /* set the "from" port latencies to the max/min range of all their connections */
4669
4670         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4671                 p->set_private_latency_range (all_connections, playback);
4672         }
4673
4674         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4675
4676         all_connections.min += our_latency;
4677         all_connections.max += our_latency;
4678
4679         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4680                 p->set_private_latency_range (all_connections, playback);
4681         }
4682
4683         return all_connections.max;
4684 }
4685
4686 samplecnt_t
4687 Route::set_private_port_latencies (bool playback) const
4688 {
4689         samplecnt_t own_latency = 0;
4690
4691         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4692            OR LATENCY CALLBACK.
4693
4694            This is called (early) from the latency callback. It computes the REAL
4695            latency associated with each port and stores the result as the "private"
4696            latency of the port. A later call to Route::set_public_port_latencies()
4697            sets all ports to the same value to reflect the fact that we do latency
4698            compensation and so all signals are delayed by the same amount as they
4699            flow through ardour.
4700         */
4701
4702         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4703
4704                 if ((*i)->active ()) {
4705                         own_latency += (*i)->effective_latency ();
4706                 }
4707         }
4708
4709         if (playback) {
4710                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4711                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4712         } else {
4713                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4714                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4715         }
4716 }
4717
4718 void
4719 Route::set_public_port_latencies (samplecnt_t value, bool playback) const
4720 {
4721         /* publish private latencies */
4722         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4723         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4724                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*i);
4725                 if (!iop) {
4726                         continue;
4727                 }
4728                 if (iop->input ()) {
4729                         iop->input ()->set_public_port_latencies (iop->input()->latency(), true);
4730                 }
4731                 if (iop->output ()) {
4732                         iop->output ()->set_public_port_latencies (iop->output()->latency(), false);
4733                 }
4734         }
4735
4736         /* this is called to set the JACK-visible port latencies, which take
4737          * latency compensation into account.
4738          */
4739         _input->set_public_port_latencies (value, playback);
4740         _output->set_public_port_latencies (value, playback);
4741 }
4742
4743 /** Put the invisible processors in the right place in _processors.
4744  *  Must be called with a writer lock on _processor_lock held.
4745  */
4746 #ifdef __clang__
4747 __attribute__((annotate("realtime")))
4748 #endif
4749 void
4750 Route::setup_invisible_processors ()
4751 {
4752 #ifndef NDEBUG
4753         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4754         assert (!lm.locked ());
4755 #endif
4756
4757         if (!_main_outs) {
4758                 /* too early to be doing this stuff */
4759                 return;
4760         }
4761
4762         /* we'll build this new list here and then use it
4763          *
4764          * TODO put the ProcessorList is on the stack for RT-safety.
4765          */
4766
4767         ProcessorList new_processors;
4768         ProcessorList foldback_sends;
4769         ProcessorList::iterator dr;
4770         ProcessorList::iterator dw;
4771
4772         /* find visible processors */
4773
4774         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4775                 boost::shared_ptr<Send> auxsnd = boost::dynamic_pointer_cast<Send> ((*i));
4776                 if ((*i)->display_to_user ()) {
4777                         new_processors.push_back (*i);
4778                 }
4779                 else if (auxsnd && auxsnd->is_foldback ()) {
4780                         foldback_sends.push_back (*i);
4781                 }
4782         }
4783
4784         /* find the amp */
4785
4786         ProcessorList::iterator amp = find (new_processors.begin(), new_processors.end(), _amp);
4787
4788         if (amp == new_processors.end ()) {
4789                 error << string_compose (_("Amp/Fader on Route '%1' went AWOL. Re-added."), name()) << endmsg;
4790                 new_processors.push_front (_amp);
4791                 amp = find (new_processors.begin(), new_processors.end(), _amp);
4792         }
4793
4794         /* and the processor after the amp */
4795
4796         ProcessorList::iterator after_amp = amp;
4797         ++after_amp;
4798
4799         /* Pre-fader METER */
4800
4801         if (_meter && _meter_point == MeterPreFader) {
4802                 /* add meter just before the fader */
4803                 assert (!_meter->display_to_user ());
4804                 new_processors.insert (amp, _meter);
4805         }
4806
4807         /* MAIN OUTS */
4808
4809         assert (_main_outs);
4810         assert (!_main_outs->display_to_user ());
4811         new_processors.push_back (_main_outs);
4812
4813         /* iterator for the main outs */
4814
4815         ProcessorList::iterator main = new_processors.end();
4816         --main;
4817
4818         /* OUTPUT METERING */
4819
4820         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4821                 assert (!_meter->display_to_user ());
4822
4823                 /* add the processor just before or just after the main outs */
4824
4825                 ProcessorList::iterator meter_point = main;
4826
4827                 if (_meter_point == MeterOutput) {
4828                         ++meter_point;
4829                 }
4830                 new_processors.insert (meter_point, _meter);
4831         }
4832
4833         /* Foldback Sends */
4834
4835         for (ProcessorList::iterator i = foldback_sends.begin(); i != foldback_sends.end(); ++i) {
4836                 new_processors.insert (amp, (*i));
4837         }
4838
4839         /* MONITOR SEND */
4840
4841         if (_monitor_send && !is_monitor ()) {
4842                 assert (!_monitor_send->display_to_user ());
4843                 switch (Config->get_listen_position ()) {
4844                 case PreFaderListen:
4845                         switch (Config->get_pfl_position ()) {
4846                         case PFLFromBeforeProcessors:
4847                                 new_processors.push_front (_monitor_send);
4848                                 break;
4849                         case PFLFromAfterProcessors:
4850                                 new_processors.insert (amp, _monitor_send);
4851                                 break;
4852                         }
4853                         _monitor_send->set_can_pan (false);
4854                         break;
4855                 case AfterFaderListen:
4856                         switch (Config->get_afl_position ()) {
4857                         case AFLFromBeforeProcessors:
4858                                 new_processors.insert (after_amp, _monitor_send);
4859                                 break;
4860                         case AFLFromAfterProcessors:
4861                                 new_processors.insert (new_processors.end(), _monitor_send);
4862                                 break;
4863                         }
4864                         _monitor_send->set_can_pan (true);
4865                         break;
4866                 }
4867         }
4868
4869         /* MONITOR CONTROL */
4870
4871         if (_monitor_control && is_monitor ()) {
4872                 assert (!_monitor_control->display_to_user ());
4873                 new_processors.insert (amp, _monitor_control);
4874         }
4875
4876         /* TRIM CONTROL */
4877
4878         ProcessorList::iterator trim = new_processors.end();
4879
4880         if (_trim->active()) {
4881                 assert (!_trim->display_to_user ());
4882                 new_processors.push_front (_trim);
4883                 trim = new_processors.begin();
4884         }
4885
4886         /* INTERNAL RETURN */
4887
4888         /* doing this here means that any monitor control will come after
4889            the return and trim.
4890         */
4891
4892         if (_intreturn) {
4893                 assert (!_intreturn->display_to_user ());
4894                 new_processors.push_front (_intreturn);
4895         }
4896
4897         /* DISK READER & WRITER (for Track objects) */
4898
4899         if (_disk_reader || _disk_writer) {
4900                 switch (_disk_io_point) {
4901                 case DiskIOPreFader:
4902                         if (trim != new_processors.end()) {
4903                                 /* insert BEFORE TRIM */
4904                                 if (_disk_writer) {
4905                                         new_processors.insert (trim, _disk_writer);
4906                                 }
4907                                 if (_disk_reader) {
4908                                         new_processors.insert (trim, _disk_reader);
4909                                 }
4910                         } else {
4911                                 if (_disk_writer) {
4912                                         new_processors.push_front (_disk_writer);
4913                                 }
4914                                 if (_disk_reader) {
4915                                         new_processors.push_front (_disk_reader);
4916                                 }
4917                         }
4918                         break;
4919                 case DiskIOPostFader:
4920                         /* insert BEFORE main outs */
4921                         if (_disk_writer) {
4922                                 new_processors.insert (main, _disk_writer);
4923                         }
4924                         if (_disk_reader) {
4925                                 new_processors.insert (main, _disk_reader);
4926                         }
4927                         break;
4928                 case DiskIOCustom:
4929                         /* reader and writer are visible under this condition, so they
4930                          * are not invisible and thus not handled here.
4931                          */
4932                         break;
4933                 }
4934         }
4935
4936         /* ensure dist-writer is before disk-reader */
4937         if (_disk_reader && _disk_writer) {
4938                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
4939                 ProcessorList::iterator writer_pos = find (new_processors.begin(), new_processors.end(), _disk_writer);
4940                 assert (reader_pos != new_processors.end ());
4941                 assert (writer_pos != new_processors.end ());
4942                 if (std::distance (new_processors.begin(), reader_pos) < std::distance (new_processors.begin(), writer_pos)) {
4943                         new_processors.erase (reader_pos);
4944                         assert (writer_pos == find (new_processors.begin(), new_processors.end(), _disk_writer));
4945                         new_processors.insert (++writer_pos, _disk_reader);
4946                 }
4947         }
4948
4949         /* EXPORT PROCESSOR */
4950         if (_capturing_processor) {
4951                 assert (!_capturing_processor->display_to_user ());
4952                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
4953                 if (reader_pos != new_processors.end()) {
4954                         /* insert after disk-reader */
4955                         new_processors.insert (++reader_pos, _capturing_processor);
4956                 } else {
4957                         ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
4958                         /* insert after return */
4959                         if (return_pos != new_processors.end()) {
4960                                 new_processors.insert (++return_pos, _capturing_processor);
4961                         } else {
4962                                 new_processors.push_front (_capturing_processor);
4963                         }
4964                 }
4965         }
4966
4967         /* Polarity Invert */
4968         if (_polarity) {
4969                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
4970                 if (reader_pos != new_processors.end()) {
4971                         /* insert after disk-reader */
4972                         new_processors.insert (++reader_pos, _polarity);
4973                 } else {
4974                         ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
4975                         /* insert after return */
4976                         if (return_pos != new_processors.end()) {
4977                                 new_processors.insert (++return_pos, _polarity);
4978                         } else {
4979                                 new_processors.push_front (_polarity);
4980                         }
4981                 }
4982         }
4983
4984         /* Input meter */
4985         if (_meter && _meter_point == MeterInput) {
4986                 /* add meter just before the disk-writer (if any)
4987                  * otherwise at the top, but after the latency delayline
4988                  * (perhaps it should also be after intreturn on busses ??)
4989                  */
4990                 assert (!_meter->display_to_user ());
4991                 ProcessorList::iterator writer_pos = find (new_processors.begin(), new_processors.end(), _disk_writer);
4992                 if (writer_pos != new_processors.end()) {
4993                         /* insert before disk-writer */
4994                         new_processors.insert (writer_pos, _meter);
4995                 } else {
4996                         ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
4997                         /* insert after return */
4998                         if (return_pos != new_processors.end()) {
4999                                 new_processors.insert (++return_pos, _meter);
5000                         } else {
5001                                 new_processors.push_front (_meter);
5002                         }
5003                 }
5004         }
5005
5006         if (!is_master() && !is_monitor() && !is_auditioner()) {
5007                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
5008                 if (reader_pos != new_processors.end()) {
5009                         /* insert before disk-reader */
5010                         new_processors.insert (reader_pos, _delayline);
5011                 } else {
5012                         new_processors.push_front (_delayline);
5013                 }
5014         }
5015
5016         _processors = new_processors;
5017
5018         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5019                 if (!(*i)->display_to_user () && !(*i)->enabled () && (*i) != _monitor_send) {
5020                         (*i)->enable (true);
5021                 }
5022         }
5023
5024         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
5025         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5026                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
5027         }
5028 }
5029
5030 void
5031 Route::unpan ()
5032 {
5033         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
5034         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
5035
5036         _pannable.reset ();
5037
5038         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5039                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
5040                 if (d) {
5041                         d->unpan ();
5042                 }
5043         }
5044 }
5045
5046 /** If the meter point is `Custom', make a note of where the meter is.
5047  *  This is so that if the meter point is subsequently set to something else,
5048  *  and then back to custom, we can put the meter back where it was last time
5049  *  custom was enabled.
5050  *
5051  *  Must be called with the _processor_lock held.
5052  */
5053 void
5054 Route::maybe_note_meter_position ()
5055 {
5056         if (_meter_point != MeterCustom) {
5057                 return;
5058         }
5059
5060         _custom_meter_position_noted = true;
5061         /* custom meter points range from after trim to before panner/main_outs
5062          * this is a limitation by the current processor UI
5063          */
5064         bool seen_trim = false;
5065         _processor_after_last_custom_meter.reset();
5066         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5067                 if ((*i) == _trim) {
5068                         seen_trim = true;
5069                 }
5070                 if ((*i) == _main_outs) {
5071                         _processor_after_last_custom_meter = *i;
5072                         break;
5073                 }
5074                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
5075                         if (!seen_trim) {
5076                                 _processor_after_last_custom_meter = _trim;
5077                         } else {
5078                                 ProcessorList::iterator j = i;
5079                                 ++j;
5080                                 assert(j != _processors.end ()); // main_outs should be before
5081                                 _processor_after_last_custom_meter = *j;
5082                         }
5083                         break;
5084                 }
5085         }
5086         assert(_processor_after_last_custom_meter.lock());
5087 }
5088
5089 boost::shared_ptr<Processor>
5090 Route::processor_by_id (PBD::ID id) const
5091 {
5092         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5093         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5094                 if ((*i)->id() == id) {
5095                         return *i;
5096                 }
5097         }
5098
5099         return boost::shared_ptr<Processor> ();
5100 }
5101
5102 /** @return what we should be metering; either the data coming from the input
5103  *  IO or the data that is flowing through the route.
5104  */
5105 MeterState
5106 Route::metering_state () const
5107 {
5108         return MeteringRoute;
5109 }
5110
5111 bool
5112 Route::has_external_redirects () const
5113 {
5114         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5115
5116                 /* ignore inactive processors and obviously ignore the main
5117                  * outs since everything has them and we don't care.
5118                  */
5119
5120                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
5121                         return true;;
5122                 }
5123         }
5124
5125         return false;
5126 }
5127
5128 boost::shared_ptr<Processor>
5129 Route::the_instrument () const
5130 {
5131         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5132         return the_instrument_unlocked ();
5133 }
5134
5135 boost::shared_ptr<Processor>
5136 Route::the_instrument_unlocked () const
5137 {
5138         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5139                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
5140                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
5141                         return (*i);
5142                 }
5143         }
5144         return boost::shared_ptr<Processor>();
5145 }
5146
5147 bool
5148 Route::is_track()
5149 {
5150         return dynamic_cast<Track*>(this) != 0;
5151 }
5152
5153 void
5154 Route::non_realtime_locate (samplepos_t pos)
5155 {
5156         Automatable::non_realtime_locate (pos);
5157
5158         if (_pannable) {
5159                 _pannable->non_realtime_locate (pos);
5160         }
5161
5162 #if 0 // XXX mayhaps clear delayline here (and at stop?)
5163         if (_delayline) {
5164                 _delayline->flush ();
5165         }
5166 #endif
5167
5168         {
5169                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
5170                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5171
5172                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5173                         (*i)->non_realtime_locate (pos);
5174                 }
5175         }
5176 }
5177
5178 void
5179 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
5180 {
5181         size_t n_buffers;
5182         size_t i;
5183
5184         /* MIDI
5185          *
5186          * We don't currently mix MIDI input together, so we don't need the
5187          * complex logic of the audio case.
5188          */
5189
5190         n_buffers = bufs.count().n_midi ();
5191
5192         for (i = 0; i < n_buffers; ++i) {
5193
5194                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
5195                 MidiBuffer& buf (bufs.get_midi (i));
5196
5197                 if (source_port) {
5198                         buf.copy (source_port->get_midi_buffer(nframes));
5199                 } else {
5200                         buf.silence (nframes);
5201                 }
5202         }
5203
5204         /* AUDIO */
5205
5206         n_buffers = bufs.count().n_audio();
5207
5208         size_t n_ports = io->n_ports().n_audio();
5209         float scaling = 1.0f;
5210
5211         if (n_ports > n_buffers) {
5212                 scaling = ((float) n_buffers) / n_ports;
5213         }
5214
5215         for (i = 0; i < n_ports; ++i) {
5216
5217                 /* if there are more ports than buffers, map them onto buffers
5218                  * in a round-robin fashion
5219                  */
5220
5221                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
5222                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
5223
5224                 if (i < n_buffers) {
5225
5226                         /* first time through just copy a channel into
5227                            the output buffer.
5228                         */
5229
5230                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
5231
5232                         if (scaling != 1.0f) {
5233                                 buf.apply_gain (scaling, nframes);
5234                         }
5235
5236                 } else {
5237
5238                         /* on subsequent times around, merge data from
5239                          * the port with what is already there
5240                          */
5241
5242                         if (scaling != 1.0f) {
5243                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
5244                         } else {
5245                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
5246                         }
5247                 }
5248         }
5249
5250         /* silence any remaining buffers */
5251
5252         for (; i < n_buffers; ++i) {
5253                 AudioBuffer& buf (bufs.get_audio (i));
5254                 buf.silence (nframes);
5255         }
5256
5257         /* establish the initial setup of the buffer set, reflecting what was
5258            copied into it. unless, of course, we are the auditioner, in which
5259            case nothing was fed into it from the inputs at all.
5260         */
5261
5262         if (!is_auditioner()) {
5263                 bufs.set_count (io->n_ports());
5264         }
5265 }
5266
5267 boost::shared_ptr<AutomationControl>
5268 Route::pan_azimuth_control() const
5269 {
5270 #ifdef MIXBUS
5271         if (_mixbus_send) {
5272                 return _mixbus_send->master_pan_ctrl ();
5273         }
5274         return boost::shared_ptr<AutomationControl>();
5275 #else
5276         if (!_pannable || !panner()) {
5277                 return boost::shared_ptr<AutomationControl>();
5278         }
5279         return _pannable->pan_azimuth_control;
5280 #endif
5281 }
5282
5283 boost::shared_ptr<AutomationControl>
5284 Route::pan_elevation_control() const
5285 {
5286         if (Profile->get_mixbus() || !_pannable || !panner()) {
5287                 return boost::shared_ptr<AutomationControl>();
5288         }
5289
5290         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5291
5292         if (c.find (PanElevationAutomation) != c.end()) {
5293                 return _pannable->pan_elevation_control;
5294         } else {
5295                 return boost::shared_ptr<AutomationControl>();
5296         }
5297 }
5298 boost::shared_ptr<AutomationControl>
5299 Route::pan_width_control() const
5300 {
5301 #ifdef MIXBUS
5302         if (mixbus() && _ch_pre) {
5303                 //mono blend
5304                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 1)));
5305         }
5306 #endif
5307         if (Profile->get_mixbus() || !_pannable || !panner()) {
5308                 return boost::shared_ptr<AutomationControl>();
5309         }
5310
5311         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5312
5313         if (c.find (PanWidthAutomation) != c.end()) {
5314                 return _pannable->pan_width_control;
5315         } else {
5316                 return boost::shared_ptr<AutomationControl>();
5317         }
5318 }
5319 boost::shared_ptr<AutomationControl>
5320 Route::pan_frontback_control() const
5321 {
5322         if (Profile->get_mixbus() || !_pannable || !panner()) {
5323                 return boost::shared_ptr<AutomationControl>();
5324         }
5325
5326         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5327
5328         if (c.find (PanFrontBackAutomation) != c.end()) {
5329                 return _pannable->pan_frontback_control;
5330         } else {
5331                 return boost::shared_ptr<AutomationControl>();
5332         }
5333 }
5334 boost::shared_ptr<AutomationControl>
5335 Route::pan_lfe_control() const
5336 {
5337         if (Profile->get_mixbus() || !_pannable || !panner()) {
5338                 return boost::shared_ptr<AutomationControl>();
5339         }
5340
5341         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5342
5343         if (c.find (PanLFEAutomation) != c.end()) {
5344                 return _pannable->pan_lfe_control;
5345         } else {
5346                 return boost::shared_ptr<AutomationControl>();
5347         }
5348 }
5349
5350 uint32_t
5351 Route::eq_band_cnt () const
5352 {
5353         if (Profile->get_mixbus()) {
5354 #ifdef MIXBUS32C
5355                 if (is_master() || mixbus()) {
5356                         return 3;
5357                 } else {
5358                         return 4;
5359                 }
5360 #else
5361                 return 3;
5362 #endif
5363         } else {
5364                 /* Ardour has no well-known EQ object */
5365                 return 0;
5366         }
5367 }
5368
5369 boost::shared_ptr<AutomationControl>
5370 Route::eq_gain_controllable (uint32_t band) const
5371 {
5372 #ifdef MIXBUS
5373         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5374
5375         if (!eq) {
5376                 return boost::shared_ptr<AutomationControl>();
5377         }
5378
5379         uint32_t port_number;
5380         if (is_master() || mixbus()) {
5381                 switch (band) {
5382                         case 0: port_number = 4; break;
5383                         case 1: port_number = 3; break;
5384                         case 2: port_number = 2; break;
5385                         default:
5386                                 return boost::shared_ptr<AutomationControl>();
5387                 }
5388         } else {
5389 #ifdef MIXBUS32C
5390                 switch (band) {
5391                         case 0: port_number = 14; break;
5392                         case 1: port_number = 12; break;
5393                         case 2: port_number = 10; break;
5394                         case 3: port_number =  8; break;
5395                         default:
5396                                 return boost::shared_ptr<AutomationControl>();
5397                 }
5398 #else
5399                 switch (band) {
5400                         case 0: port_number = 8; break;
5401                         case 1: port_number = 6; break;
5402                         case 2: port_number = 4; break;
5403                         default:
5404                                 return boost::shared_ptr<AutomationControl>();
5405                 }
5406 #endif
5407         }
5408
5409         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5410 #else
5411         return boost::shared_ptr<AutomationControl>();
5412 #endif
5413 }
5414 boost::shared_ptr<AutomationControl>
5415 Route::eq_freq_controllable (uint32_t band) const
5416 {
5417 #ifdef MIXBUS
5418         if (mixbus() || is_master()) {
5419                 /* no frequency controls for mixbusses or master */
5420                 return boost::shared_ptr<AutomationControl>();
5421         }
5422
5423         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5424
5425         if (!eq) {
5426                 return boost::shared_ptr<AutomationControl>();
5427         }
5428
5429         uint32_t port_number;
5430 #ifdef MIXBUS32C
5431         switch (band) {
5432                 case 0: port_number = 13; break; // lo
5433                 case 1: port_number = 11; break; // lo mid
5434                 case 2: port_number = 9; break; // hi mid
5435                 case 3: port_number = 7; break; // hi
5436                 default:
5437                         return boost::shared_ptr<AutomationControl>();
5438         }
5439 #else
5440         switch (band) {
5441                 case 0: port_number = 7; break;
5442                 case 1: port_number = 5; break;
5443                 case 2: port_number = 3; break;
5444                 default:
5445                         return boost::shared_ptr<AutomationControl>();
5446         }
5447 #endif
5448
5449         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5450 #else
5451         return boost::shared_ptr<AutomationControl>();
5452 #endif
5453 }
5454
5455 boost::shared_ptr<AutomationControl>
5456 Route::eq_q_controllable (uint32_t band) const
5457 {
5458         return boost::shared_ptr<AutomationControl>();
5459 }
5460
5461 boost::shared_ptr<AutomationControl>
5462 Route::eq_shape_controllable (uint32_t band) const
5463 {
5464 #ifdef MIXBUS32C
5465         if (is_master() || mixbus() || !eq) {
5466                 return boost::shared_ptr<AutomationControl>();
5467         }
5468         switch (band) {
5469                 case 0:
5470                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4))); // lo bell
5471                         break;
5472                 case 3:
5473                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3))); // hi bell
5474                         break;
5475                 default:
5476                         break;
5477         }
5478 #endif
5479         return boost::shared_ptr<AutomationControl>();
5480 }
5481
5482 boost::shared_ptr<AutomationControl>
5483 Route::eq_enable_controllable () const
5484 {
5485 #ifdef MIXBUS
5486         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5487
5488         if (!eq) {
5489                 return boost::shared_ptr<AutomationControl>();
5490         }
5491
5492         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5493 #else
5494         return boost::shared_ptr<AutomationControl>();
5495 #endif
5496 }
5497
5498 boost::shared_ptr<AutomationControl>
5499 Route::filter_freq_controllable (bool hpf) const
5500 {
5501 #ifdef MIXBUS
5502         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5503
5504         if (is_master() || mixbus() || !eq) {
5505                 return boost::shared_ptr<AutomationControl>();
5506         }
5507         if (hpf) {
5508 #ifdef MIXBUS32C
5509                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5))); // HPF freq
5510 #else
5511                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5512 #endif
5513         } else {
5514 #ifdef MIXBUS32C
5515                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6))); // LPF freq
5516 #else
5517                 return boost::shared_ptr<AutomationControl>();
5518 #endif
5519         }
5520
5521 #else
5522         return boost::shared_ptr<AutomationControl>();
5523 #endif
5524 }
5525
5526 boost::shared_ptr<AutomationControl>
5527 Route::filter_slope_controllable (bool) const
5528 {
5529         return boost::shared_ptr<AutomationControl>();
5530 }
5531
5532 boost::shared_ptr<AutomationControl>
5533 Route::filter_enable_controllable (bool) const
5534 {
5535 #ifdef MIXBUS32C
5536         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5537
5538         if (is_master() || mixbus() || !eq) {
5539                 return boost::shared_ptr<AutomationControl>();
5540         }
5541
5542         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5543 #else
5544         return boost::shared_ptr<AutomationControl>();
5545 #endif
5546 }
5547
5548 boost::shared_ptr<AutomationControl>
5549 Route::tape_drive_controllable () const
5550 {
5551 #ifdef MIXBUS
5552         if (_ch_pre) {
5553                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_pre->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 0)));
5554         }
5555 #endif
5556         return boost::shared_ptr<AutomationControl>();
5557 }
5558
5559 boost::shared_ptr<ReadOnlyControl>
5560 Route::tape_drive_mtr_controllable () const
5561 {
5562 #ifdef MIXBUS
5563         if (_ch_pre) {
5564                 return _ch_pre->control_output (is_master() ? 1 : 2);
5565         }
5566 #endif
5567         return boost::shared_ptr<ReadOnlyControl>();
5568 }
5569
5570 boost::shared_ptr<ReadOnlyControl>
5571 Route::master_correlation_mtr_controllable (bool mm) const
5572 {
5573 #ifdef MIXBUS
5574         if (is_master() && _ch_post) {
5575                 return _ch_post->control_output (mm ? 4 : 3);
5576         }
5577 #endif
5578         return boost::shared_ptr<ReadOnlyControl>();
5579 }
5580
5581 boost::shared_ptr<AutomationControl>
5582 Route::master_limiter_enable_controllable () const
5583 {
5584 #ifdef MIXBUS
5585         if (is_master() && _ch_post) {
5586                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_post->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5587         }
5588 #endif
5589         return boost::shared_ptr<AutomationControl>();
5590 }
5591
5592 boost::shared_ptr<ReadOnlyControl>
5593 Route::master_limiter_mtr_controllable () const
5594 {
5595 #ifdef MIXBUS
5596         if (is_master() && _ch_post) {
5597                 return _ch_post->control_output (2);
5598         }
5599 #endif
5600         return boost::shared_ptr<ReadOnlyControl>();
5601 }
5602
5603 boost::shared_ptr<ReadOnlyControl>
5604 Route::master_k_mtr_controllable () const
5605 {
5606 #ifdef MIXBUS
5607         if (is_master() && _ch_post) {
5608                 return _ch_post->control_output (5);
5609         }
5610 #endif
5611         return boost::shared_ptr<ReadOnlyControl>();
5612 }
5613
5614 string
5615 Route::eq_band_name (uint32_t band) const
5616 {
5617 #ifdef MIXBUS32C
5618         if (is_master() || mixbus()) {
5619 #endif
5620         if (Profile->get_mixbus()) {
5621                 switch (band) {
5622                         case 0: return _("lo");
5623                         case 1: return _("mid");
5624                         case 2: return _("hi");
5625                         default: return string();
5626                 }
5627         } else {
5628                 return string ();
5629         }
5630 #ifdef MIXBUS32C
5631         } else {
5632                 switch (band) {
5633                         case 0: return _("lo");
5634                         case 1: return _("lm");
5635                         case 2: return _("hm");
5636                         case 3: return _("hi");
5637                         default: return string();
5638                 }
5639         }
5640 #endif
5641 }
5642
5643 boost::shared_ptr<AutomationControl>
5644 Route::comp_enable_controllable () const
5645 {
5646 #ifdef MIXBUS
5647         if (_ch_comp) {
5648                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5649         }
5650 #endif
5651         return boost::shared_ptr<AutomationControl>();
5652 }
5653 boost::shared_ptr<AutomationControl>
5654 Route::comp_threshold_controllable () const
5655 {
5656 #ifdef MIXBUS
5657         if (_ch_comp) {
5658                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5659         }
5660 #endif
5661         return boost::shared_ptr<AutomationControl>();
5662 }
5663 boost::shared_ptr<AutomationControl>
5664 Route::comp_speed_controllable () const
5665 {
5666 #ifdef MIXBUS
5667         if (_ch_comp) {
5668                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5669         }
5670 #endif
5671         return boost::shared_ptr<AutomationControl>();
5672 }
5673 boost::shared_ptr<AutomationControl>
5674 Route::comp_mode_controllable () const
5675 {
5676 #ifdef MIXBUS
5677         if (_ch_comp) {
5678                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5679         }
5680 #endif
5681         return boost::shared_ptr<AutomationControl>();
5682 }
5683 boost::shared_ptr<AutomationControl>
5684 Route::comp_makeup_controllable () const
5685 {
5686 #ifdef MIXBUS
5687         if (_ch_comp) {
5688                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5689         }
5690 #endif
5691         return boost::shared_ptr<AutomationControl>();
5692 }
5693 boost::shared_ptr<ReadOnlyControl>
5694 Route::comp_redux_controllable () const
5695 {
5696 #ifdef MIXBUS
5697         if (_ch_comp) {
5698                 return _ch_comp->control_output (6);
5699         }
5700 #endif
5701         return boost::shared_ptr<ReadOnlyControl>();
5702 }
5703
5704 string
5705 Route::comp_mode_name (uint32_t mode) const
5706 {
5707 #ifdef MIXBUS
5708         switch (mode) {
5709         case 0:
5710                 return _("Leveler");
5711         case 1:
5712                 return _("Compressor");
5713         case 2:
5714                 return _("Limiter");
5715         case 3:
5716                 return mixbus() ? _("Sidechain") : _("Limiter");
5717         }
5718
5719         return _("???");
5720 #else
5721         return _("???");
5722 #endif
5723 }
5724
5725 string
5726 Route::comp_speed_name (uint32_t mode) const
5727 {
5728 #ifdef MIXBUS
5729         switch (mode) {
5730         case 0:
5731                 return _("Attk");
5732         case 1:
5733                 return _("Ratio");
5734         case 2:
5735         case 3:
5736                 return _("Rels");
5737         }
5738         return _("???");
5739 #else
5740         return _("???");
5741 #endif
5742 }
5743
5744 boost::shared_ptr<AutomationControl>
5745 Route::send_pan_azimuth_controllable (uint32_t n) const
5746 {
5747 #ifdef  MIXBUS
5748         if (_mixbus_send) {
5749                 if (n < _mixbus_send->n_busses ()) {
5750                         return _mixbus_send->send_pan_ctrl (n + 1);
5751                 }
5752         }
5753 #endif
5754         return boost::shared_ptr<AutomationControl>();
5755 }
5756
5757 boost::shared_ptr<AutomationControl>
5758 Route::send_level_controllable (uint32_t n) const
5759 {
5760 #ifdef  MIXBUS
5761         if (_mixbus_send) {
5762                 if (n < _mixbus_send->n_busses ()) {
5763                         return _mixbus_send->send_gain_ctrl (n + 1);
5764                 }
5765                 n -= _mixbus_send->n_busses ();
5766         }
5767 #endif
5768         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5769         if (s) {
5770                 return s->gain_control ();
5771         }
5772         return boost::shared_ptr<AutomationControl>();
5773 }
5774
5775 boost::shared_ptr<AutomationControl>
5776 Route::send_enable_controllable (uint32_t n) const
5777 {
5778 #ifdef  MIXBUS
5779         if (_mixbus_send) {
5780                 if (n < _mixbus_send->n_busses ()) {
5781                         return _mixbus_send->send_enable_ctrl (n + 1);
5782                 }
5783         }
5784 #endif
5785         /* although Ardour sends have enable/disable as part of the Processor
5786          * API, it is not exposed as a controllable.
5787          *
5788          * XXX: we should fix this (make it click-free, automatable enable-control)
5789          */
5790         return boost::shared_ptr<AutomationControl>();
5791 }
5792
5793 boost::shared_ptr<AutomationControl>
5794 Route::send_pan_azimuth_enable_controllable (uint32_t n) const
5795 {
5796 #ifdef  MIXBUS
5797         if (_mixbus_send) {
5798                 if (n < _mixbus_send->n_busses ()) {
5799                         return _mixbus_send->send_pan_enable_ctrl (n + 1);
5800                 }
5801         }
5802 #endif
5803         return boost::shared_ptr<AutomationControl>();
5804 }
5805
5806 string
5807 Route::send_name (uint32_t n) const
5808 {
5809 #ifdef  MIXBUS
5810         if (_mixbus_send) {
5811                 if (n < _mixbus_send->n_busses ()) {
5812                         return _session.get_mixbus (n)->name();
5813                 }
5814                 n -= _mixbus_send->n_busses ();
5815         }
5816 #endif
5817         boost::shared_ptr<Processor> p = nth_send (n);
5818         if (p) {
5819                 return p->name();
5820         }
5821         return string();
5822 }
5823
5824 boost::shared_ptr<AutomationControl>
5825 Route::master_send_enable_controllable () const
5826 {
5827 #ifdef  MIXBUS
5828         if (is_master() || is_monitor() || is_auditioner()) {
5829                 return boost::shared_ptr<AutomationControl>();
5830         }
5831
5832         if (_mixbus_send) {
5833                 return _mixbus_send->master_send_enable_ctrl ();
5834         }
5835
5836 #endif
5837         return boost::shared_ptr<AutomationControl>();
5838 }
5839
5840 bool
5841 Route::slaved () const
5842 {
5843         if (!_gain_control) {
5844                 return false;
5845         }
5846         /* just test one particular control, not all of them */
5847         return _gain_control->slaved ();
5848 }
5849
5850 bool
5851 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5852 {
5853         if (!vca || !_gain_control) {
5854                 return false;
5855         }
5856
5857         /* just test one particular control, not all of them */
5858
5859         return _gain_control->slaved_to (vca->gain_control());
5860 }
5861
5862 bool
5863 Route::muted_by_others_soloing () const
5864 {
5865         if (!can_be_muted_by_others ()) {
5866                 return false;
5867         }
5868
5869         return  _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5870 }
5871
5872 void
5873 Route::clear_all_solo_state ()
5874 {
5875         _solo_control->clear_all_solo_state ();
5876 }
5877
5878 boost::shared_ptr<AutomationControl>
5879 Route::automation_control_recurse (PBD::ID const & id) const
5880 {
5881         boost::shared_ptr<AutomationControl> ac = Automatable::automation_control (id);
5882
5883         if (ac) {
5884                 return ac;
5885         }
5886
5887         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5888
5889         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5890                 if ((ac = (*i)->automation_control (id))) {
5891                         return ac;
5892                 }
5893         }
5894
5895         return boost::shared_ptr<AutomationControl> ();
5896 }
5897
5898 SlavableControlList
5899 Route::slavables () const
5900 {
5901         SlavableControlList rv;
5902         rv.push_back (_gain_control);
5903         rv.push_back (_mute_control);
5904         rv.push_back (_solo_control);
5905         return rv;
5906 }
5907
5908 void
5909 Route::set_meter_type (MeterType t)
5910 {
5911         _meter->set_meter_type (t);
5912 }
5913
5914 MeterType
5915 Route::meter_type () const
5916 {
5917         return _meter->meter_type ();
5918 }
5919
5920 void
5921 Route::set_disk_io_point (DiskIOPoint diop)
5922 {
5923         bool display = false;
5924
5925         cerr << "set disk io to " << enum_2_string (diop) << endl;
5926
5927         switch (diop) {
5928         case DiskIOCustom:
5929                 display = true;
5930                 break;
5931         default:
5932                 display = false;
5933         }
5934
5935         if (_disk_writer) {
5936                 _disk_writer->set_display_to_user (display);
5937         }
5938
5939         if (_disk_reader) {
5940                 _disk_reader->set_display_to_user (display);
5941         }
5942
5943         const bool changed = (diop != _disk_io_point);
5944
5945         _disk_io_point = diop;
5946
5947         if (changed) {
5948                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
5949                 configure_processors (0);
5950         }
5951
5952         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
5953 }
5954
5955 void
5956 Route::set_loop (Location* l)
5957 {
5958         _loop_location = l;
5959         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5960         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5961                 (*i)->set_loop (l);
5962         }
5963 }
5964
5965 MonitorState
5966 Route::monitoring_state () const
5967 {
5968         if (!_disk_reader) {
5969                 return MonitoringInput;
5970         }
5971
5972         /* Explicit requests */
5973         MonitorChoice m (_monitoring_control->monitoring_choice());
5974
5975         if (m != MonitorAuto) {
5976
5977                 MonitorState ms ((MonitorState) 0);
5978
5979                 if (m & MonitorInput) {
5980                         ms = MonitoringInput;
5981                 }
5982
5983                 if (m & MonitorDisk) {
5984                         ms = MonitorState (ms | MonitoringDisk);
5985                 }
5986
5987                 return ms;
5988         }
5989
5990         switch (_session.config.get_session_monitoring ()) {
5991                 case MonitorDisk:
5992                         return MonitoringDisk;
5993                         break;
5994                 case MonitorInput:
5995                         return MonitoringInput;
5996                         break;
5997                 default:
5998                         break;
5999         }
6000
6001         return get_auto_monitoring_state();
6002 }