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                                 if (_strict_io) {
3085                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
3086                                         pi->set_strict_io (true);
3087                                 }
3088
3089                         }
3090                 } else if (prop->value() == "port") {
3091
3092                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
3093
3094                 } else if (prop->value() == "send") {
3095
3096                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
3097                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
3098                         send->SelfDestruct.connect_same_thread (*this,
3099                                                                 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
3100
3101                 } else {
3102                         warning << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
3103                         return false;
3104                 }
3105
3106                 if (processor->set_state (node, Stateful::current_state_version) != 0) {
3107                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
3108                         processor.reset (new UnknownProcessor (_session, node));
3109                 }
3110
3111                 /* subscribe to Sidechain IO changes */
3112                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
3113                 if (pi && pi->has_sidechain ()) {
3114                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
3115                 }
3116
3117                 /* we have to note the monitor send here, otherwise a new one will be created
3118                    and the state of this one will be lost.
3119                 */
3120                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
3121                 if (isend && isend->role() == Delivery::Listen) {
3122                         _monitor_send = isend;
3123                 }
3124
3125                 /* it doesn't matter if invisible processors are added here, as they
3126                    will be sorted out by setup_invisible_processors () shortly.
3127                 */
3128
3129                 new_order.push_back (processor);
3130                 must_configure = true;
3131         }
3132         return true;
3133 }
3134
3135 void
3136 Route::silence (samplecnt_t nframes)
3137 {
3138         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3139         if (!lm.locked()) {
3140                 return;
3141         }
3142
3143         silence_unlocked (nframes);
3144 }
3145
3146 void
3147 Route::silence_unlocked (samplecnt_t nframes)
3148 {
3149         /* Must be called with the processor lock held */
3150
3151         const samplepos_t now = _session.transport_sample ();
3152
3153         _output->silence (nframes);
3154
3155         // update owned automated controllables
3156         automation_run (now, nframes);
3157         if (_pannable) {
3158                 _pannable->automation_run (now, nframes);
3159         }
3160
3161         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3162                 boost::shared_ptr<PluginInsert> pi;
3163
3164                 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
3165                         /* evaluate automated automation controls */
3166                         pi->automation_run (now, nframes);
3167                         /* skip plugins, they don't need anything when we're not active */
3168                         continue;
3169                 }
3170
3171                 (*i)->silence (nframes, now);
3172         }
3173 }
3174
3175 void
3176 Route::add_internal_return ()
3177 {
3178         if (!_intreturn) {
3179                 _intreturn.reset (new InternalReturn (_session));
3180                 add_processor (_intreturn, PreFader);
3181         }
3182 }
3183
3184 void
3185 Route::add_send_to_internal_return (InternalSend* send)
3186 {
3187         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3188
3189         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3190                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3191
3192                 if (d) {
3193                         return d->add_send (send);
3194                 }
3195         }
3196 }
3197
3198 void
3199 Route::remove_send_from_internal_return (InternalSend* send)
3200 {
3201         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3202
3203         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3204                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3205
3206                 if (d) {
3207                         return d->remove_send (send);
3208                 }
3209         }
3210 }
3211
3212 void
3213 Route::enable_monitor_send ()
3214 {
3215         /* Caller must hold process lock */
3216         assert (!AudioEngine::instance()->process_lock().trylock());
3217
3218         /* master never sends to monitor section via the normal mechanism */
3219         assert (!is_master ());
3220         assert (!is_monitor ());
3221
3222         /* make sure we have one */
3223         if (!_monitor_send) {
3224                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3225                 _monitor_send->set_display_to_user (false);
3226         }
3227
3228         /* set it up */
3229         configure_processors (0);
3230 }
3231
3232 /** Add an aux send to a route.
3233  *  @param route route to send to.
3234  *  @param before Processor to insert before, or 0 to insert at the end.
3235  */
3236 int
3237 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3238 {
3239         assert (route != _session.monitor_out ());
3240
3241         {
3242                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3243
3244                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3245
3246                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3247
3248                         if (d && d->target_route() == route) {
3249                                 /* already listening via the specified IO: do nothing */
3250                                 return 0;
3251                         }
3252                 }
3253         }
3254
3255         try {
3256
3257                 boost::shared_ptr<InternalSend> listener;
3258
3259                 {
3260                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3261                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3262                 }
3263
3264                 add_processor (listener, before);
3265
3266         } catch (failed_constructor& err) {
3267                 return -1;
3268         }
3269
3270         return 0;
3271 }
3272
3273 int
3274 Route::add_foldback_send (boost::shared_ptr<Route> route)
3275 {
3276         assert (route != _session.monitor_out ());
3277         boost::shared_ptr<Processor> before = before_processor_for_placement (PreFader);
3278
3279         {
3280                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3281
3282                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3283
3284                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3285
3286                         if (d && d->target_route() == route) {
3287                                 /* already listening via the specified IO: do nothing */
3288                                 return 0;
3289                         }
3290                 }
3291         }
3292
3293         try {
3294
3295                 boost::shared_ptr<InternalSend> listener;
3296
3297                 {
3298                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3299                         listener.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Foldback));
3300                 }
3301
3302                 listener->panner_shell()->set_linked_to_route (false);
3303                 add_processor (listener, before);
3304
3305         } catch (failed_constructor& err) {
3306                 return -1;
3307         }
3308         _session.FBSendsChanged ();
3309
3310         return 0;
3311 }
3312
3313 void
3314 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3315 {
3316         ProcessorStreams err;
3317         ProcessorList::iterator tmp;
3318         bool do_fb_signal = false;
3319
3320         {
3321                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3322
3323                 /* have to do this early because otherwise processor reconfig
3324                  * will put _monitor_send back in the list
3325                  */
3326
3327                 if (route == _session.monitor_out()) {
3328                         _monitor_send.reset ();
3329                 }
3330
3331           again:
3332                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3333
3334                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3335
3336                         if (d && d->target_route() == route) {
3337                                 boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send>(d);
3338                                 if (snd && snd->is_foldback()) {
3339                                         do_fb_signal = true;
3340                                 }
3341
3342                                 rl.release ();
3343                                 if (remove_processor (*x, &err, false) > 0) {
3344                                         rl.acquire ();
3345                                         continue;
3346                                 }
3347                                 rl.acquire ();
3348
3349                                 /* list could have been demolished while we dropped the lock
3350                                    so start over.
3351                                 */
3352                                 if (_session.engine().running()) {
3353                                         /* i/o processors cannot be removed if the engine is not running
3354                                          * so don't live-loop in case the engine is N/A or dies
3355                                          */
3356                                         goto again;
3357                                 }
3358                         }
3359                 }
3360         }
3361         if (do_fb_signal) {
3362                 _session.FBSendsChanged ();
3363         }
3364
3365 }
3366
3367 void
3368 Route::set_comment (string cmt, void *src)
3369 {
3370         _comment = cmt;
3371         comment_changed ();
3372         _session.set_dirty ();
3373 }
3374
3375 bool
3376 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3377 {
3378         FeedRecord fr (other, via_sends_only);
3379
3380         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3381
3382         if (!result.second) {
3383
3384                 /* already a record for "other" - make sure sends-only information is correct */
3385                 if (!via_sends_only && result.first->sends_only) {
3386                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3387                         frp->sends_only = false;
3388                 }
3389         }
3390
3391         return result.second;
3392 }
3393
3394 void
3395 Route::clear_fed_by ()
3396 {
3397         _fed_by.clear ();
3398 }
3399
3400 bool
3401 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3402 {
3403         const FedBy& fed_by (other->fed_by());
3404
3405         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3406                 boost::shared_ptr<Route> sr = f->r.lock();
3407
3408                 if (sr && (sr.get() == this)) {
3409
3410                         if (via_sends_only) {
3411                                 *via_sends_only = f->sends_only;
3412                         }
3413
3414                         return true;
3415                 }
3416         }
3417
3418         return false;
3419 }
3420
3421 IOVector
3422 Route::all_inputs () const
3423 {
3424         /* TODO, if this works as expected,
3425          * cache the IOVector and maintain it via
3426          * input_change_handler(), sidechain_change_handler() etc
3427          */
3428         IOVector ios;
3429         ios.push_back (_input);
3430
3431         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3432         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3433
3434                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3435                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3436                 if (pi != 0) {
3437                         assert (iop == 0);
3438                         iop = pi->sidechain();
3439                 }
3440
3441                 if (iop != 0 && iop->input()) {
3442                         ios.push_back (iop->input());
3443                 }
3444         }
3445         return ios;
3446 }
3447
3448 IOVector
3449 Route::all_outputs () const
3450 {
3451         IOVector ios;
3452         // _output is included via Delivery
3453         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3454         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3455                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3456                 if (iop != 0 && iop->output()) {
3457                         ios.push_back (iop->output());
3458                 }
3459         }
3460         return ios;
3461 }
3462
3463 bool
3464 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3465 {
3466         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds from %1 (-> %2)?\n", _name, other->name()));
3467         if (other->all_inputs().fed_by (_output)) {
3468                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS to %1\n", other->name()));
3469                 if (via_send_only) {
3470                         *via_send_only = false;
3471                 }
3472
3473                 return true;
3474         }
3475
3476         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3477
3478         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3479
3480                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3481                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3482                 if (pi != 0) {
3483                         assert (iop == 0);
3484                         iop = pi->sidechain();
3485                 }
3486
3487                 if (iop != 0) {
3488                         boost::shared_ptr<const IO> iop_out = iop->output();
3489                         if (other.get() == this && iop_out && iop->input() && iop_out->connected_to (iop->input())) {
3490                                 // TODO this needs a delaylines in the Insert to align connections (!)
3491                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed its own return (%2)\n", iop->name(), other->name()));
3492                                 continue;
3493                         }
3494                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3495                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3496                                 if (via_send_only) {
3497                                         *via_send_only = true;
3498                                 }
3499                                 return true;
3500                         } else {
3501                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3502                         }
3503                 }
3504         }
3505
3506         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3507         return false;
3508 }
3509
3510 bool
3511 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3512 {
3513         return _session._current_route_graph.has (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other, via_send_only);
3514 }
3515
3516 bool
3517 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3518 {
3519         return _session._current_route_graph.feeds (boost::dynamic_pointer_cast<Route> (shared_from_this ()), other);
3520 }
3521
3522 /** Called from the (non-realtime) butler thread when the transport is stopped */
3523 void
3524 Route::non_realtime_transport_stop (samplepos_t now, bool flush)
3525 {
3526         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3527
3528         Automatable::non_realtime_transport_stop (now, flush);
3529
3530         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3531
3532                 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && flush)) {
3533                         (*i)->flush ();
3534                 }
3535
3536                 (*i)->non_realtime_transport_stop (now, flush);
3537         }
3538 }
3539
3540 void
3541 Route::realtime_handle_transport_stopped ()
3542 {
3543         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3544
3545         /* currently only by Plugin, queue note-off events */
3546         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3547                 (*i)->realtime_handle_transport_stopped ();
3548         }
3549 }
3550
3551
3552 void
3553 Route::input_change_handler (IOChange change, void * /*src*/)
3554 {
3555         if (_session.loading()) {
3556                 return;
3557         }
3558
3559         if ((change.type & IOChange::ConfigurationChanged)) {
3560                 /* This is called with the process lock held if change
3561                    contains ConfigurationChanged
3562                 */
3563                 configure_processors (0);
3564                 io_changed (); /* EMIT SIGNAL */
3565         }
3566
3567         if (_solo_control->soloed_by_others_upstream() || _solo_isolate_control->solo_isolated_by_upstream()) {
3568                 int sbou = 0;
3569                 int ibou = 0;
3570                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3571                 if (_input->connected()) {
3572                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3573                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3574                                         continue;
3575                                 }
3576                                 bool sends_only;
3577                                 bool does_feed = (*i)->direct_feeds_according_to_reality (boost::dynamic_pointer_cast<Route> (shared_from_this()), &sends_only);
3578                                 if (does_feed && !sends_only) {
3579                                         if ((*i)->soloed()) {
3580                                                 ++sbou;
3581                                         }
3582                                         if ((*i)->solo_isolate_control()->solo_isolated()) {
3583                                                 ++ibou;
3584                                         }
3585                                 }
3586                         }
3587                 }
3588
3589                 int delta  = sbou - _solo_control->soloed_by_others_upstream();
3590                 int idelta = ibou - _solo_isolate_control->solo_isolated_by_upstream();
3591
3592                 if (idelta < -1) {
3593                         PBD::warning << string_compose (
3594                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3595                                         _name, ibou, _solo_isolate_control->solo_isolated_by_upstream(), idelta)
3596                                      << endmsg;
3597
3598                 }
3599
3600                 if (_solo_control->soloed_by_others_upstream()) {
3601                         // ignore new connections (they're not propagated)
3602                         if (delta <= 0) {
3603                                 _solo_control->mod_solo_by_others_upstream (delta);
3604                         }
3605                 }
3606
3607                 if (_solo_isolate_control->solo_isolated_by_upstream()) {
3608                         // solo-isolate currently only propagates downstream
3609                         if (idelta < 0) {
3610                                 _solo_isolate_control->mod_solo_isolated_by_upstream (1);
3611                         }
3612                         //_solo_isolated_by_upstream = ibou;
3613                 }
3614
3615                 // Session::route_solo_changed  does not propagate indirect solo-changes
3616                 // propagate downstream to tracks
3617                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3618                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3619                                 continue;
3620                         }
3621                         bool sends_only;
3622                         bool does_feed = feeds (*i, &sends_only);
3623                         if (delta <= 0 && does_feed && !sends_only) {
3624                                 (*i)->solo_control()->mod_solo_by_others_upstream (delta);
3625                         }
3626
3627                         if (idelta < 0 && does_feed && !sends_only) {
3628                                 (*i)->solo_isolate_control()->mod_solo_isolated_by_upstream (-1);
3629                         }
3630                 }
3631         }
3632 }
3633
3634 void
3635 Route::output_change_handler (IOChange change, void * /*src*/)
3636 {
3637         if (_initial_io_setup) {
3638                 return;
3639         }
3640
3641         if ((change.type & IOChange::ConfigurationChanged)) {
3642                 /* This is called with the process lock held if change
3643                    contains ConfigurationChanged
3644                 */
3645                 configure_processors (0);
3646
3647                 if (is_master()) {
3648                         _session.reset_monitor_section();
3649                 }
3650
3651                 io_changed (); /* EMIT SIGNAL */
3652         }
3653
3654         if ((change.type & IOChange::ConnectionsChanged)) {
3655
3656                 /* do this ONLY if connections have changed. Configuration
3657                  * changes do not, by themselves alter solo upstream or
3658                  * downstream status.
3659                  */
3660
3661                 if (_solo_control->soloed_by_others_downstream()) {
3662                         int sbod = 0;
3663                         /* checking all all downstream routes for
3664                          * explicit of implict solo is a rather drastic measure,
3665                          * ideally the input_change_handler() of the other route
3666                          * would propagate the change to us.
3667                          */
3668                         boost::shared_ptr<RouteList> routes = _session.get_routes ();
3669                         if (_output->connected()) {
3670                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3671                                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3672                                                 continue;
3673                                         }
3674                                         bool sends_only;
3675                                         bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3676                                         if (does_feed && !sends_only) {
3677                                                 if ((*i)->soloed()) {
3678                                                         ++sbod;
3679                                                         break;
3680                                                 }
3681                                         }
3682                                 }
3683                         }
3684
3685                         int delta = sbod - _solo_control->soloed_by_others_downstream();
3686                         if (delta <= 0) {
3687                                 // do not allow new connections to change implicit solo (no propagation)
3688                                 _solo_control->mod_solo_by_others_downstream (delta);
3689                                 // Session::route_solo_changed() does not propagate indirect solo-changes
3690                                 // propagate upstream to tracks
3691                                 boost::shared_ptr<Route> shared_this = boost::dynamic_pointer_cast<Route> (shared_from_this());
3692                                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3693                                         if ((*i).get() == this || !can_solo()) {
3694                                                 continue;
3695                                         }
3696                                         bool sends_only;
3697                                         bool does_feed = (*i)->feeds (shared_this, &sends_only);
3698                                         if (delta != 0 && does_feed && !sends_only) {
3699                                                 (*i)->solo_control()->mod_solo_by_others_downstream (delta);
3700                                         }
3701                                 }
3702
3703                         }
3704                 }
3705         }
3706 }
3707
3708 void
3709 Route::sidechain_change_handler (IOChange change, void* src)
3710 {
3711         if (_initial_io_setup || _in_sidechain_setup) {
3712                 return;
3713         }
3714
3715         input_change_handler (change, src);
3716 }
3717
3718 uint32_t
3719 Route::pans_required () const
3720 {
3721         if (n_outputs().n_audio() < 2) {
3722                 return 0;
3723         }
3724
3725         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
3726 }
3727
3728 void
3729 Route::flush_processor_buffers_locked (samplecnt_t nframes)
3730 {
3731         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3732                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
3733                 if (d) {
3734                         d->flush_buffers (nframes);
3735                 } else {
3736                         boost::shared_ptr<PortInsert> p = boost::dynamic_pointer_cast<PortInsert> (*i);
3737                         if (p) {
3738                                 p->flush_buffers (nframes);
3739                         }
3740                 }
3741         }
3742 }
3743
3744 void
3745 Route::flush_processors ()
3746 {
3747         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3748
3749         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3750                 (*i)->flush ();
3751         }
3752 }
3753
3754 samplecnt_t
3755 Route::playback_latency (bool incl_downstream) const
3756 {
3757         samplecnt_t rv;
3758         if (_disk_reader) {
3759                 rv = _disk_reader->output_latency ();
3760         } else {
3761                 rv = _signal_latency;
3762         }
3763         if (incl_downstream) {
3764                 rv += _output->connected_latency (true);
3765         } else {
3766                 rv += _output->latency ();
3767         }
3768         return rv;
3769 }
3770
3771 pframes_t
3772 Route::latency_preroll (pframes_t nframes, samplepos_t& start_sample, samplepos_t& end_sample)
3773 {
3774         samplecnt_t latency_preroll = _session.remaining_latency_preroll ();
3775         if (latency_preroll == 0) {
3776                 return nframes;
3777         }
3778         if (!_disk_reader) {
3779                 start_sample -= latency_preroll;
3780                 end_sample   -= latency_preroll;
3781                 return nframes;
3782         }
3783
3784         if (latency_preroll > playback_latency ()) {
3785                 no_roll_unlocked (nframes, start_sample - latency_preroll, end_sample - latency_preroll, false);
3786                 return 0;
3787         }
3788
3789         start_sample -= latency_preroll;
3790         end_sample -= latency_preroll;
3791         return nframes;
3792 }
3793
3794 int
3795 Route::roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool& need_butler)
3796 {
3797         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3798
3799         if (!lm.locked()) {
3800                 return 0;
3801         }
3802
3803         if (!_active) {
3804                 silence_unlocked (nframes);
3805                 _meter->reset();
3806                 return 0;
3807         }
3808
3809         if ((nframes = latency_preroll (nframes, start_sample, end_sample)) == 0) {
3810                 return 0;
3811         }
3812
3813         run_route (start_sample, end_sample, nframes, (!_disk_writer || !_disk_writer->record_enabled()) && _session.transport_rolling(), true);
3814
3815         if ((_disk_reader && _disk_reader->need_butler()) || (_disk_writer && _disk_writer->need_butler())) {
3816                 need_butler = true;
3817         }
3818         return 0;
3819 }
3820
3821 int
3822 Route::no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
3823 {
3824         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3825
3826         if (!lm.locked()) {
3827                 return 0;
3828         }
3829
3830         return no_roll_unlocked (nframes, start_sample, end_sample, session_state_changing);
3831 }
3832
3833 int
3834 Route::no_roll_unlocked (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
3835 {
3836         /* Must be called with the processor lock held */
3837
3838         if (!_active) {
3839                 silence_unlocked (nframes);
3840                 _meter->reset();
3841                 return 0;
3842         }
3843
3844         if (session_state_changing) {
3845                 if (_session.transport_speed() != 0.0f) {
3846                         /* we're rolling but some state is changing (e.g. our diskstream contents)
3847                            so we cannot use them. Be silent till this is over.
3848
3849                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
3850                         */
3851                         silence_unlocked (nframes);
3852                         _meter->reset();
3853                         return 0;
3854                 }
3855                 /* we're really not rolling, so we're either delivery silence or actually
3856                    monitoring, both of which are safe to do while session_state_changing is true.
3857                 */
3858         }
3859
3860         run_route (start_sample, end_sample, nframes, false, false);
3861         return 0;
3862 }
3863
3864 int
3865 Route::silent_roll (pframes_t nframes, samplepos_t /*start_sample*/, samplepos_t /*end_sample*/, bool& /* need_butler */)
3866 {
3867         silence (nframes);
3868         flush_processor_buffers_locked (nframes);
3869         return 0;
3870 }
3871
3872 #ifdef __clang__
3873 __attribute__((annotate("realtime")))
3874 #endif
3875 bool
3876 Route::apply_processor_changes_rt ()
3877 {
3878         int emissions = EmitNone;
3879
3880         if (_pending_meter_point != _meter_point) {
3881                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3882                 if (pwl.locked()) {
3883                         /* meters always have buffers for 'processor_max_streams'
3884                          * they can be re-positioned without re-allocation */
3885                         if (set_meter_point_unlocked()) {
3886                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
3887                         } else {
3888                                 emissions |= EmitMeterChanged;
3889                         }
3890                 }
3891         }
3892
3893         bool changed = false;
3894
3895         if (g_atomic_int_get (&_pending_process_reorder)) {
3896                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
3897                 if (pwl.locked()) {
3898                         apply_processor_order (_pending_processor_order);
3899                         setup_invisible_processors ();
3900                         changed = true;
3901                         g_atomic_int_set (&_pending_process_reorder, 0);
3902                         emissions |= EmitRtProcessorChange;
3903                 }
3904         }
3905         if (changed) {
3906                 set_processor_positions ();
3907                 /* update processor input/output latency
3908                  * (total signal_latency does not change)
3909                  */
3910                 update_signal_latency (true);
3911         }
3912         if (emissions != 0) {
3913                 g_atomic_int_set (&_pending_signals, emissions);
3914                 return true;
3915         }
3916         return (!selfdestruct_sequence.empty ());
3917 }
3918
3919 void
3920 Route::emit_pending_signals ()
3921 {
3922         int sig = g_atomic_int_and (&_pending_signals, 0);
3923         if (sig & EmitMeterChanged) {
3924                 _meter->emit_configuration_changed();
3925                 meter_change (); /* EMIT SIGNAL */
3926                 if (sig & EmitMeterVisibilityChange) {
3927                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
3928                 } else {
3929                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
3930                 }
3931         }
3932         if (sig & EmitRtProcessorChange) {
3933                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
3934         }
3935
3936         /* this would be a job for the butler.
3937          * Conceptually we should not take processe/processor locks here.
3938          * OTOH its more efficient (less overhead for summoning the butler and
3939          * telling her what do do) and signal emission is called
3940          * directly after the process callback, which decreases the chance
3941          * of x-runs when taking the locks.
3942          */
3943         while (!selfdestruct_sequence.empty ()) {
3944                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
3945                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
3946                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
3947                 selfdestruct_sequence.pop_back ();
3948                 lx.release ();
3949                 if (proc) {
3950                         remove_processor (proc);
3951                 }
3952         }
3953 }
3954
3955 void
3956 Route::set_meter_point (MeterPoint p, bool force)
3957 {
3958         if (_pending_meter_point == p && !force) {
3959                 return;
3960         }
3961
3962         if (force || !AudioEngine::instance()->running()) {
3963                 bool meter_visibly_changed = false;
3964                 {
3965                         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3966                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3967                         _pending_meter_point = p;
3968                         if (set_meter_point_unlocked ()) {
3969                                 meter_visibly_changed = true;
3970                         }
3971                 }
3972                 _meter->emit_configuration_changed();
3973                 meter_change (); /* EMIT SIGNAL */
3974                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3975         } else {
3976                 _pending_meter_point = p;
3977         }
3978 }
3979
3980
3981 #ifdef __clang__
3982 __attribute__((annotate("realtime")))
3983 #endif
3984 bool
3985 Route::set_meter_point_unlocked ()
3986 {
3987 #ifndef NDEBUG
3988         /* Caller must hold process and processor write lock */
3989         assert (!AudioEngine::instance()->process_lock().trylock());
3990         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3991         assert (!lm.locked ());
3992 #endif
3993
3994         _meter_point = _pending_meter_point;
3995
3996         bool meter_was_visible_to_user = _meter->display_to_user ();
3997
3998         if (!_custom_meter_position_noted) {
3999                 maybe_note_meter_position ();
4000         }
4001
4002         if (_meter_point != MeterCustom) {
4003
4004                 _meter->set_display_to_user (false);
4005
4006                 setup_invisible_processors ();
4007
4008         } else {
4009                 _meter->set_display_to_user (true);
4010
4011                 /* If we have a previous position for the custom meter, try to put it there */
4012                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
4013                 if (after) {
4014                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
4015                         if (i != _processors.end ()) {
4016                                 _processors.remove (_meter);
4017                                 _processors.insert (i, _meter);
4018                         }
4019                 } else {// at end, right before the mains_out/panner
4020                         _processors.remove (_meter);
4021                         ProcessorList::iterator main = _processors.end();
4022                         _processors.insert (--main, _meter);
4023                 }
4024         }
4025
4026         /* Set up the meter for its new position */
4027
4028         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
4029
4030         ChanCount m_in;
4031
4032         if (loc == _processors.begin()) {
4033                 m_in = _input->n_ports();
4034         } else {
4035                 ProcessorList::iterator before = loc;
4036                 --before;
4037                 m_in = (*before)->output_streams ();
4038         }
4039
4040         _meter->reflect_inputs (m_in);
4041
4042         /* we do not need to reconfigure the processors, because the meter
4043            (a) is always ready to handle processor_max_streams
4044            (b) is always an N-in/N-out processor, and thus moving
4045            it doesn't require any changes to the other processors.
4046         */
4047
4048         /* these should really be done after releasing the lock
4049          * but all those signals are subscribed to with gui_thread()
4050          * so we're safe.
4051          */
4052          return (_meter->display_to_user() != meter_was_visible_to_user);
4053 }
4054
4055 void
4056 Route::listen_position_changed ()
4057 {
4058         {
4059                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4060                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4061                 ProcessorState pstate (this);
4062
4063                 if (configure_processors_unlocked (0, &lm)) {
4064                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
4065                         pstate.restore ();
4066                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
4067                         return;
4068                 }
4069         }
4070
4071         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
4072         _session.set_dirty ();
4073 }
4074
4075 boost::shared_ptr<CapturingProcessor>
4076 Route::add_export_point()
4077 {
4078         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4079         if (!_capturing_processor) {
4080                 lm.release();
4081                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4082                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
4083
4084                 /* Align all tracks for stem-export w/o processing.
4085                  * Compensate for all plugins between the this route's disk-reader
4086                  * and the common final downstream output (ie alignment point for playback).
4087                  */
4088                 _capturing_processor.reset (new CapturingProcessor (_session, playback_latency (true)));
4089                 configure_processors_unlocked (0, &lw);
4090                 _capturing_processor->activate ();
4091         }
4092
4093         return _capturing_processor;
4094 }
4095
4096 samplecnt_t
4097 Route::update_signal_latency (bool apply_to_delayline)
4098 {
4099         // TODO: bail out if !active() and set/assume _signal_latency = 0,
4100         // here or in Session::* ? -> also zero send latencies,
4101         // and make sure that re-enabling a route updates things again...
4102
4103         samplecnt_t capt_lat_in = _input->connected_latency (false);
4104         samplecnt_t play_lat_out = _output->connected_latency (true);
4105
4106         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4107
4108         samplecnt_t l_in  = 0;
4109         samplecnt_t l_out = 0;
4110         for (ProcessorList::reverse_iterator i = _processors.rbegin(); i != _processors.rend(); ++i) {
4111                 if (boost::shared_ptr<LatentSend> snd = boost::dynamic_pointer_cast<LatentSend> (*i)) {
4112                         snd->set_delay_in (l_out + _output->latency());
4113                 }
4114
4115                 if (boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4116                         if (boost::shared_ptr<IO> pio = pi->sidechain_input ()) {
4117                                 samplecnt_t lat = l_out + _output->latency();
4118                                 pio->set_private_port_latencies (lat, true);
4119                                 pio->set_public_port_latencies (lat, true);
4120                         }
4121                 }
4122                 (*i)->set_output_latency (l_out);
4123                 if ((*i)->active ()) { // XXX
4124                         l_out += (*i)->effective_latency ();
4125                 }
4126         }
4127
4128         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l_out));
4129
4130         _signal_latency = l_out;
4131
4132         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4133
4134                 /* set sidechain, send and insert port latencies */
4135                 if (boost::shared_ptr<PortInsert> pi = boost::dynamic_pointer_cast<PortInsert> (*i)) {
4136                         if (pi->input ()) {
4137                                 /* propagate playback latency from output to input */
4138                                 pi->input ()->set_private_port_latencies (play_lat_out + l_in, true);
4139                         }
4140                         if (pi->output ()) {
4141                                 /* propagate capture latency from input to output */
4142                                 pi->output ()->set_private_port_latencies (capt_lat_in + l_in, false);
4143                         }
4144
4145                 } else if (boost::shared_ptr<Send> snd = boost::dynamic_pointer_cast<Send> (*i)) {
4146                         if (snd->output ()) {
4147                                 /* set capture latency */
4148                                 snd->output ()->set_private_port_latencies (capt_lat_in + l_in, false);
4149                                 /* take send-target's playback latency into account */
4150                                 snd->set_delay_out (snd->output ()->connected_latency (true));
4151                                 /* InternalReturn::set_playback_offset() below, also calls set_delay_out() */
4152                         }
4153                 }
4154
4155                 (*i)->set_input_latency (l_in);
4156                 (*i)->set_playback_offset (_signal_latency + _output->latency ());
4157                 (*i)->set_capture_offset (_input->latency ());
4158                 if ((*i)->active ()) {
4159                         l_in += (*i)->effective_latency ();
4160                 }
4161         }
4162
4163         lm.release ();
4164
4165         if (apply_to_delayline) {
4166                 /* see also Session::post_playback_latency() */
4167                 apply_latency_compensation ();
4168         }
4169
4170         if (_signal_latency != l_out) {
4171                 signal_latency_changed (); /* EMIT SIGNAL */
4172         }
4173
4174         return _signal_latency;
4175 }
4176
4177 void
4178 Route::apply_latency_compensation ()
4179 {
4180         if (_delayline) {
4181                 samplecnt_t old = _delayline->delay ();
4182
4183                 samplecnt_t play_lat_in = _input->connected_latency (true);
4184                 samplecnt_t play_lat_out = _output->connected_latency (true);
4185                 samplecnt_t latcomp = play_lat_in - play_lat_out - _signal_latency;
4186
4187 #if 0 // DEBUG
4188                 samplecnt_t capt_lat_in = _input->connected_latency (false);
4189                 samplecnt_t capt_lat_out = _output->connected_latency (false);
4190                 samplecnt_t latcomp_capt = capt_lat_out - capt_lat_in - _signal_latency;
4191
4192                 cout << "ROUTE " << name() << " delay for " << latcomp << " (c: " << latcomp_capt << ")" << endl;
4193 #endif
4194
4195                 _delayline->set_delay (latcomp > 0 ? latcomp : 0);
4196
4197                 if (old !=  _delayline->delay ()) {
4198                         signal_latency_updated (); /* EMIT SIGNAL */
4199                 }
4200         }
4201 }
4202
4203 void
4204 Route::set_block_size (pframes_t nframes)
4205 {
4206         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4207                 (*i)->set_block_size (nframes);
4208         }
4209
4210         _session.ensure_buffers (n_process_buffers ());
4211 }
4212
4213 void
4214 Route::protect_automation ()
4215 {
4216         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
4217                 (*i)->protect_automation();
4218 }
4219
4220 /** Shift automation forwards from a particular place, thereby inserting time.
4221  *  Adds undo commands for any shifts that are performed.
4222  *
4223  * @param pos Position to start shifting from.
4224  * @param samples Amount to shift forwards by.
4225  */
4226
4227 void
4228 Route::shift (samplepos_t pos, samplecnt_t samples)
4229 {
4230         /* pan automation */
4231         if (_pannable) {
4232                 ControlSet::Controls& c (_pannable->controls());
4233
4234                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
4235                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
4236                         if (pc) {
4237                                 boost::shared_ptr<AutomationList> al = pc->alist();
4238                                 XMLNode& before = al->get_state ();
4239                                 al->shift (pos, samples);
4240                                 XMLNode& after = al->get_state ();
4241                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4242                         }
4243                 }
4244         }
4245
4246         /* TODO mute automation, MuteControl */
4247
4248         /* processor automation (incl. gain, trim,..) */
4249         {
4250                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4251                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
4252
4253                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
4254
4255                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
4256                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
4257                                 if (ac) {
4258                                         boost::shared_ptr<AutomationList> al = ac->alist();
4259                                         if (al->empty ()) {
4260                                                 continue;
4261                                         }
4262                                         XMLNode &before = al->get_state ();
4263                                         al->shift (pos, samples);
4264                                         XMLNode &after = al->get_state ();
4265                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4266                                 }
4267                         }
4268                 }
4269         }
4270 }
4271
4272 void
4273 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4274 {
4275         boost::shared_ptr<Processor> processor (p.lock ());
4276         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4277         if (!pi) {
4278                 return;
4279         }
4280         pi->set_state_dir (d);
4281 }
4282
4283 int
4284 Route::save_as_template (const string& path, const string& name, const string& description)
4285 {
4286         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4287         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4288
4289         XMLNode& node (state (true));
4290         node.set_property (X_("name"), name);
4291
4292         node.remove_nodes (X_("description"));
4293         if (!description.empty()) {
4294                 XMLNode* desc = new XMLNode(X_("description"));
4295                 XMLNode* desc_cont = new XMLNode(X_("content"), description);
4296                 desc->add_child_nocopy (*desc_cont);
4297
4298                 node.add_child_nocopy (*desc);
4299         }
4300
4301         XMLTree tree;
4302
4303         IO::set_name_in_state (*node.children().front(), name);
4304
4305         tree.set_root (&node);
4306
4307         /* return zero on success, non-zero otherwise */
4308         return !tree.write (path.c_str());
4309 }
4310
4311
4312 bool
4313 Route::set_name (const string& str)
4314 {
4315         if (str.empty ()) {
4316                 return false;
4317         }
4318
4319         if (str == name()) {
4320                 return true;
4321         }
4322
4323         string newname = Route::ensure_track_or_route_name (str);
4324
4325         if (newname == name()) {
4326                 return true;
4327         }
4328
4329         SessionObject::set_name (newname);
4330
4331         for (uint32_t n = 0 ; ; ++n) {
4332                 boost::shared_ptr<PluginInsert> pi = boost::static_pointer_cast<PluginInsert> (nth_plugin (n));
4333                 if (!pi) {
4334                         break;
4335                 }
4336                 pi->update_sidechain_name ();
4337         }
4338
4339         bool ret = (_input->set_name(newname) && _output->set_name(newname));
4340
4341         if (ret) {
4342                 /* rename the main outs. Leave other IO processors
4343                  * with whatever name they already have, because its
4344                  * just fine as it is (it will not contain the route
4345                  * name if its a port insert, port send or port return).
4346                  */
4347
4348                 if (_main_outs) {
4349                         if (_main_outs->set_name (newname)) {
4350                                 /* XXX returning false here is stupid because
4351                                    we already changed the route name.
4352                                 */
4353                                 return false;
4354                         }
4355                 }
4356         }
4357
4358         return ret;
4359 }
4360
4361 /** Set the name of a route in an XML description.
4362  *  @param node XML <Route> node to set the name in.
4363  *  @param name New name.
4364  */
4365 void
4366 Route::set_name_in_state (XMLNode& node, string const & name)
4367 {
4368         node.set_property (X_("name"), name);
4369
4370         XMLNodeList children = node.children();
4371         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4372
4373                 if ((*i)->name() == X_("IO")) {
4374
4375                         IO::set_name_in_state (**i, name);
4376
4377                 } else if ((*i)->name() == X_("Processor")) {
4378
4379                         std::string str;
4380                         if ((*i)->get_property (X_("role"), str) && str == X_("Main")) {
4381                                 (*i)->set_property (X_("name"), name);
4382                         }
4383                 }
4384         }
4385 }
4386
4387 boost::shared_ptr<Send>
4388 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4389 {
4390         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4391
4392         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4393                 boost::shared_ptr<InternalSend> send;
4394
4395                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4396                         if (send->target_route() == target) {
4397                                 return send;
4398                         }
4399                 }
4400         }
4401
4402         return boost::shared_ptr<Send>();
4403 }
4404
4405 void
4406 Route::set_denormal_protection (bool yn)
4407 {
4408         if (_denormal_protection != yn) {
4409                 _denormal_protection = yn;
4410                 denormal_protection_changed (); /* EMIT SIGNAL */
4411         }
4412 }
4413
4414 bool
4415 Route::denormal_protection () const
4416 {
4417         return _denormal_protection;
4418 }
4419
4420 void
4421 Route::set_active (bool yn, void* src)
4422 {
4423         if (_session.transport_rolling()) {
4424                 return;
4425         }
4426
4427         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4428                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4429                 return;
4430         }
4431
4432         if (_active != yn) {
4433                 _active = yn;
4434                 _input->set_active (yn);
4435                 _output->set_active (yn);
4436                 flush_processors ();
4437                 active_changed (); // EMIT SIGNAL
4438                 _session.set_dirty ();
4439         }
4440 }
4441
4442 boost::shared_ptr<Pannable>
4443 Route::pannable() const
4444 {
4445         return _pannable;
4446 }
4447
4448 boost::shared_ptr<Panner>
4449 Route::panner() const
4450 {
4451         /* may be null ! */
4452         return _main_outs->panner_shell()->panner();
4453 }
4454
4455 boost::shared_ptr<PannerShell>
4456 Route::panner_shell() const
4457 {
4458         return _main_outs->panner_shell();
4459 }
4460
4461 boost::shared_ptr<GainControl>
4462 Route::gain_control() const
4463 {
4464         return _gain_control;
4465 }
4466
4467 boost::shared_ptr<GainControl>
4468 Route::trim_control() const
4469 {
4470         return _trim_control;
4471 }
4472
4473 boost::shared_ptr<PhaseControl>
4474 Route::phase_control() const
4475 {
4476         return _phase_control;
4477 }
4478
4479 boost::shared_ptr<AutomationControl>
4480 Route::get_control (const Evoral::Parameter& param)
4481 {
4482         /* either we own the control or .... */
4483
4484         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4485
4486         if (!c) {
4487
4488                 /* maybe one of our processors does or ... */
4489
4490                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4491                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4492                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4493                                 break;
4494                         }
4495                 }
4496         }
4497
4498         if (!c) {
4499
4500                 /* nobody does so we'll make a new one */
4501
4502                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4503                 add_control(c);
4504         }
4505
4506         return c;
4507 }
4508
4509 boost::shared_ptr<Processor>
4510 Route::nth_plugin (uint32_t n) const
4511 {
4512         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4513         ProcessorList::const_iterator i;
4514
4515         for (i = _processors.begin(); i != _processors.end(); ++i) {
4516                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4517                         if (n-- == 0) {
4518                                 return *i;
4519                         }
4520                 }
4521         }
4522
4523         return boost::shared_ptr<Processor> ();
4524 }
4525
4526 boost::shared_ptr<Processor>
4527 Route::nth_send (uint32_t n) const
4528 {
4529         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4530         ProcessorList::const_iterator i;
4531
4532         for (i = _processors.begin(); i != _processors.end(); ++i) {
4533                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4534
4535                         if ((*i) == _monitor_send) {
4536                                 /* send to monitor section is not considered
4537                                  * to be an accessible send.
4538                                  */
4539                                 continue;
4540                         }
4541
4542                         if (n-- == 0) {
4543                                 return *i;
4544                         }
4545                 }
4546         }
4547
4548         return boost::shared_ptr<Processor> ();
4549 }
4550
4551 bool
4552 Route::has_io_processor_named (const string& name)
4553 {
4554         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4555         ProcessorList::iterator i;
4556
4557         for (i = _processors.begin(); i != _processors.end(); ++i) {
4558                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4559                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4560                         if ((*i)->name() == name) {
4561                                 return true;
4562                         }
4563                 }
4564         }
4565
4566         return false;
4567 }
4568
4569 void
4570 Route::set_processor_positions ()
4571 {
4572         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4573
4574         bool had_amp = false;
4575         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4576                 (*i)->set_pre_fader (!had_amp);
4577                 if (*i == _amp) {
4578                         had_amp = true;
4579                 }
4580         }
4581 }
4582
4583 /** Called when there is a proposed change to the input port count */
4584 bool
4585 Route::input_port_count_changing (ChanCount to)
4586 {
4587         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4588         if (c.empty()) {
4589                 /* The processors cannot be configured with the new input arrangement, so
4590                    block the change.
4591                 */
4592                 return true;
4593         }
4594
4595         /* The change is ok */
4596         return false;
4597 }
4598
4599 /** Called when there is a proposed change to the output port count */
4600 bool
4601 Route::output_port_count_changing (ChanCount to)
4602 {
4603         if (_strict_io && !_in_configure_processors) {
4604                 return true;
4605         }
4606         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4607                 if (processor_out_streams.get(*t) > to.get(*t)) {
4608                         return true;
4609                 }
4610         }
4611         /* The change is ok */
4612         return false;
4613 }
4614
4615 list<string>
4616 Route::unknown_processors () const
4617 {
4618         list<string> p;
4619
4620         if (_session.get_disable_all_loaded_plugins ()) {
4621                 // Do not list "missing plugins" if they are explicitly disabled
4622                 return p;
4623         }
4624
4625         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4626         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4627                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4628                         p.push_back ((*i)->name ());
4629                 }
4630         }
4631
4632         return p;
4633 }
4634
4635
4636 samplecnt_t
4637 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, samplecnt_t our_latency) const
4638 {
4639         /* we assume that all our input ports feed all our output ports. its not
4640            universally true, but the alternative is way too corner-case to worry about.
4641         */
4642
4643         LatencyRange all_connections;
4644
4645         if (from.empty()) {
4646                 all_connections.min = 0;
4647                 all_connections.max = 0;
4648         } else {
4649                 all_connections.min = ~((pframes_t) 0);
4650                 all_connections.max = 0;
4651
4652                 /* iterate over all "from" ports and determine the latency range for all of their
4653                    connections to the "outside" (outside of this Route).
4654                 */
4655
4656                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4657
4658                         LatencyRange range;
4659
4660                         p->get_connected_latency_range (range, playback);
4661
4662                         all_connections.min = min (all_connections.min, range.min);
4663                         all_connections.max = max (all_connections.max, range.max);
4664                 }
4665         }
4666
4667         /* set the "from" port latencies to the max/min range of all their connections */
4668
4669         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4670                 p->set_private_latency_range (all_connections, playback);
4671         }
4672
4673         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4674
4675         all_connections.min += our_latency;
4676         all_connections.max += our_latency;
4677
4678         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4679                 p->set_private_latency_range (all_connections, playback);
4680         }
4681
4682         return all_connections.max;
4683 }
4684
4685 samplecnt_t
4686 Route::set_private_port_latencies (bool playback) const
4687 {
4688         samplecnt_t own_latency = 0;
4689
4690         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4691            OR LATENCY CALLBACK.
4692
4693            This is called (early) from the latency callback. It computes the REAL
4694            latency associated with each port and stores the result as the "private"
4695            latency of the port. A later call to Route::set_public_port_latencies()
4696            sets all ports to the same value to reflect the fact that we do latency
4697            compensation and so all signals are delayed by the same amount as they
4698            flow through ardour.
4699         */
4700
4701         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4702
4703                 if ((*i)->active ()) {
4704                         own_latency += (*i)->effective_latency ();
4705                 }
4706         }
4707
4708         if (playback) {
4709                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4710                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4711         } else {
4712                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4713                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4714         }
4715 }
4716
4717 void
4718 Route::set_public_port_latencies (samplecnt_t value, bool playback) const
4719 {
4720         /* publish private latencies */
4721         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4722         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4723                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*i);
4724                 if (!iop) {
4725                         continue;
4726                 }
4727                 if (iop->input ()) {
4728                         iop->input ()->set_public_port_latencies (iop->input()->latency(), true);
4729                 }
4730                 if (iop->output ()) {
4731                         iop->output ()->set_public_port_latencies (iop->output()->latency(), false);
4732                 }
4733         }
4734
4735         /* this is called to set the JACK-visible port latencies, which take
4736          * latency compensation into account.
4737          */
4738         _input->set_public_port_latencies (value, playback);
4739         _output->set_public_port_latencies (value, playback);
4740 }
4741
4742 /** Put the invisible processors in the right place in _processors.
4743  *  Must be called with a writer lock on _processor_lock held.
4744  */
4745 #ifdef __clang__
4746 __attribute__((annotate("realtime")))
4747 #endif
4748 void
4749 Route::setup_invisible_processors ()
4750 {
4751 #ifndef NDEBUG
4752         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4753         assert (!lm.locked ());
4754 #endif
4755
4756         if (!_main_outs) {
4757                 /* too early to be doing this stuff */
4758                 return;
4759         }
4760
4761         /* we'll build this new list here and then use it
4762          *
4763          * TODO put the ProcessorList is on the stack for RT-safety.
4764          */
4765
4766         ProcessorList new_processors;
4767         ProcessorList foldback_sends;
4768         ProcessorList::iterator dr;
4769         ProcessorList::iterator dw;
4770
4771         /* find visible processors */
4772
4773         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4774                 boost::shared_ptr<Send> auxsnd = boost::dynamic_pointer_cast<Send> ((*i));
4775                 if ((*i)->display_to_user ()) {
4776                         new_processors.push_back (*i);
4777                 }
4778                 else if (auxsnd && auxsnd->is_foldback ()) {
4779                         foldback_sends.push_back (*i);
4780                 }
4781         }
4782
4783         /* find the amp */
4784
4785         ProcessorList::iterator amp = find (new_processors.begin(), new_processors.end(), _amp);
4786
4787         if (amp == new_processors.end ()) {
4788                 error << string_compose (_("Amp/Fader on Route '%1' went AWOL. Re-added."), name()) << endmsg;
4789                 new_processors.push_front (_amp);
4790                 amp = find (new_processors.begin(), new_processors.end(), _amp);
4791         }
4792
4793         /* and the processor after the amp */
4794
4795         ProcessorList::iterator after_amp = amp;
4796         ++after_amp;
4797
4798         /* Pre-fader METER */
4799
4800         if (_meter && _meter_point == MeterPreFader) {
4801                 /* add meter just before the fader */
4802                 assert (!_meter->display_to_user ());
4803                 new_processors.insert (amp, _meter);
4804         }
4805
4806         /* MAIN OUTS */
4807
4808         assert (_main_outs);
4809         assert (!_main_outs->display_to_user ());
4810         new_processors.push_back (_main_outs);
4811
4812         /* iterator for the main outs */
4813
4814         ProcessorList::iterator main = new_processors.end();
4815         --main;
4816
4817         /* OUTPUT METERING */
4818
4819         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
4820                 assert (!_meter->display_to_user ());
4821
4822                 /* add the processor just before or just after the main outs */
4823
4824                 ProcessorList::iterator meter_point = main;
4825
4826                 if (_meter_point == MeterOutput) {
4827                         ++meter_point;
4828                 }
4829                 new_processors.insert (meter_point, _meter);
4830         }
4831
4832         /* Foldback Sends */
4833
4834         for (ProcessorList::iterator i = foldback_sends.begin(); i != foldback_sends.end(); ++i) {
4835                 new_processors.insert (amp, (*i));
4836         }
4837
4838         /* MONITOR SEND */
4839
4840         if (_monitor_send && !is_monitor ()) {
4841                 assert (!_monitor_send->display_to_user ());
4842                 switch (Config->get_listen_position ()) {
4843                 case PreFaderListen:
4844                         switch (Config->get_pfl_position ()) {
4845                         case PFLFromBeforeProcessors:
4846                                 new_processors.push_front (_monitor_send);
4847                                 break;
4848                         case PFLFromAfterProcessors:
4849                                 new_processors.insert (amp, _monitor_send);
4850                                 break;
4851                         }
4852                         _monitor_send->set_can_pan (false);
4853                         break;
4854                 case AfterFaderListen:
4855                         switch (Config->get_afl_position ()) {
4856                         case AFLFromBeforeProcessors:
4857                                 new_processors.insert (after_amp, _monitor_send);
4858                                 break;
4859                         case AFLFromAfterProcessors:
4860                                 new_processors.insert (new_processors.end(), _monitor_send);
4861                                 break;
4862                         }
4863                         _monitor_send->set_can_pan (true);
4864                         break;
4865                 }
4866         }
4867
4868         /* MONITOR CONTROL */
4869
4870         if (_monitor_control && is_monitor ()) {
4871                 assert (!_monitor_control->display_to_user ());
4872                 new_processors.insert (amp, _monitor_control);
4873         }
4874
4875         /* TRIM CONTROL */
4876
4877         ProcessorList::iterator trim = new_processors.end();
4878
4879         if (_trim->active()) {
4880                 assert (!_trim->display_to_user ());
4881                 new_processors.push_front (_trim);
4882                 trim = new_processors.begin();
4883         }
4884
4885         /* INTERNAL RETURN */
4886
4887         /* doing this here means that any monitor control will come after
4888            the return and trim.
4889         */
4890
4891         if (_intreturn) {
4892                 assert (!_intreturn->display_to_user ());
4893                 new_processors.push_front (_intreturn);
4894         }
4895
4896         /* DISK READER & WRITER (for Track objects) */
4897
4898         if (_disk_reader || _disk_writer) {
4899                 switch (_disk_io_point) {
4900                 case DiskIOPreFader:
4901                         if (trim != new_processors.end()) {
4902                                 /* insert BEFORE TRIM */
4903                                 if (_disk_writer) {
4904                                         new_processors.insert (trim, _disk_writer);
4905                                 }
4906                                 if (_disk_reader) {
4907                                         new_processors.insert (trim, _disk_reader);
4908                                 }
4909                         } else {
4910                                 if (_disk_writer) {
4911                                         new_processors.push_front (_disk_writer);
4912                                 }
4913                                 if (_disk_reader) {
4914                                         new_processors.push_front (_disk_reader);
4915                                 }
4916                         }
4917                         break;
4918                 case DiskIOPostFader:
4919                         /* insert BEFORE main outs */
4920                         if (_disk_writer) {
4921                                 new_processors.insert (main, _disk_writer);
4922                         }
4923                         if (_disk_reader) {
4924                                 new_processors.insert (main, _disk_reader);
4925                         }
4926                         break;
4927                 case DiskIOCustom:
4928                         /* reader and writer are visible under this condition, so they
4929                          * are not invisible and thus not handled here.
4930                          */
4931                         break;
4932                 }
4933         }
4934
4935         /* ensure dist-writer is before disk-reader */
4936         if (_disk_reader && _disk_writer) {
4937                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
4938                 ProcessorList::iterator writer_pos = find (new_processors.begin(), new_processors.end(), _disk_writer);
4939                 assert (reader_pos != new_processors.end ());
4940                 assert (writer_pos != new_processors.end ());
4941                 if (std::distance (new_processors.begin(), reader_pos) < std::distance (new_processors.begin(), writer_pos)) {
4942                         new_processors.erase (reader_pos);
4943                         assert (writer_pos == find (new_processors.begin(), new_processors.end(), _disk_writer));
4944                         new_processors.insert (++writer_pos, _disk_reader);
4945                 }
4946         }
4947
4948         /* EXPORT PROCESSOR */
4949         if (_capturing_processor) {
4950                 assert (!_capturing_processor->display_to_user ());
4951                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
4952                 if (reader_pos != new_processors.end()) {
4953                         /* insert after disk-reader */
4954                         new_processors.insert (++reader_pos, _capturing_processor);
4955                 } else {
4956                         ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
4957                         /* insert after return */
4958                         if (return_pos != new_processors.end()) {
4959                                 new_processors.insert (++return_pos, _capturing_processor);
4960                         } else {
4961                                 new_processors.push_front (_capturing_processor);
4962                         }
4963                 }
4964         }
4965
4966         /* Polarity Invert */
4967         if (_polarity) {
4968                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
4969                 if (reader_pos != new_processors.end()) {
4970                         /* insert after disk-reader */
4971                         new_processors.insert (++reader_pos, _polarity);
4972                 } else {
4973                         ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
4974                         /* insert after return */
4975                         if (return_pos != new_processors.end()) {
4976                                 new_processors.insert (++return_pos, _polarity);
4977                         } else {
4978                                 new_processors.push_front (_polarity);
4979                         }
4980                 }
4981         }
4982
4983         /* Input meter */
4984         if (_meter && _meter_point == MeterInput) {
4985                 /* add meter just before the disk-writer (if any)
4986                  * otherwise at the top, but after the latency delayline
4987                  * (perhaps it should also be after intreturn on busses ??)
4988                  */
4989                 assert (!_meter->display_to_user ());
4990                 ProcessorList::iterator writer_pos = find (new_processors.begin(), new_processors.end(), _disk_writer);
4991                 if (writer_pos != new_processors.end()) {
4992                         /* insert before disk-writer */
4993                         new_processors.insert (writer_pos, _meter);
4994                 } else {
4995                         ProcessorList::iterator return_pos = find (new_processors.begin(), new_processors.end(), _intreturn);
4996                         /* insert after return */
4997                         if (return_pos != new_processors.end()) {
4998                                 new_processors.insert (++return_pos, _meter);
4999                         } else {
5000                                 new_processors.push_front (_meter);
5001                         }
5002                 }
5003         }
5004
5005         if (!is_master() && !is_monitor() && !is_auditioner()) {
5006                 ProcessorList::iterator reader_pos = find (new_processors.begin(), new_processors.end(), _disk_reader);
5007                 if (reader_pos != new_processors.end()) {
5008                         /* insert before disk-reader */
5009                         new_processors.insert (reader_pos, _delayline);
5010                 } else {
5011                         new_processors.push_front (_delayline);
5012                 }
5013         }
5014
5015         _processors = new_processors;
5016
5017         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5018                 if (!(*i)->display_to_user () && !(*i)->enabled () && (*i) != _monitor_send) {
5019                         (*i)->enable (true);
5020                 }
5021         }
5022
5023         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
5024         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5025                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
5026         }
5027 }
5028
5029 void
5030 Route::unpan ()
5031 {
5032         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
5033         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
5034
5035         _pannable.reset ();
5036
5037         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5038                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
5039                 if (d) {
5040                         d->unpan ();
5041                 }
5042         }
5043 }
5044
5045 /** If the meter point is `Custom', make a note of where the meter is.
5046  *  This is so that if the meter point is subsequently set to something else,
5047  *  and then back to custom, we can put the meter back where it was last time
5048  *  custom was enabled.
5049  *
5050  *  Must be called with the _processor_lock held.
5051  */
5052 void
5053 Route::maybe_note_meter_position ()
5054 {
5055         if (_meter_point != MeterCustom) {
5056                 return;
5057         }
5058
5059         _custom_meter_position_noted = true;
5060         /* custom meter points range from after trim to before panner/main_outs
5061          * this is a limitation by the current processor UI
5062          */
5063         bool seen_trim = false;
5064         _processor_after_last_custom_meter.reset();
5065         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5066                 if ((*i) == _trim) {
5067                         seen_trim = true;
5068                 }
5069                 if ((*i) == _main_outs) {
5070                         _processor_after_last_custom_meter = *i;
5071                         break;
5072                 }
5073                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
5074                         if (!seen_trim) {
5075                                 _processor_after_last_custom_meter = _trim;
5076                         } else {
5077                                 ProcessorList::iterator j = i;
5078                                 ++j;
5079                                 assert(j != _processors.end ()); // main_outs should be before
5080                                 _processor_after_last_custom_meter = *j;
5081                         }
5082                         break;
5083                 }
5084         }
5085         assert(_processor_after_last_custom_meter.lock());
5086 }
5087
5088 boost::shared_ptr<Processor>
5089 Route::processor_by_id (PBD::ID id) const
5090 {
5091         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5092         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5093                 if ((*i)->id() == id) {
5094                         return *i;
5095                 }
5096         }
5097
5098         return boost::shared_ptr<Processor> ();
5099 }
5100
5101 /** @return what we should be metering; either the data coming from the input
5102  *  IO or the data that is flowing through the route.
5103  */
5104 MeterState
5105 Route::metering_state () const
5106 {
5107         return MeteringRoute;
5108 }
5109
5110 bool
5111 Route::has_external_redirects () const
5112 {
5113         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5114
5115                 /* ignore inactive processors and obviously ignore the main
5116                  * outs since everything has them and we don't care.
5117                  */
5118
5119                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
5120                         return true;;
5121                 }
5122         }
5123
5124         return false;
5125 }
5126
5127 boost::shared_ptr<Processor>
5128 Route::the_instrument () const
5129 {
5130         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5131         return the_instrument_unlocked ();
5132 }
5133
5134 boost::shared_ptr<Processor>
5135 Route::the_instrument_unlocked () const
5136 {
5137         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5138                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
5139                 if (pi && pi->plugin ()->get_info ()->is_instrument ()) {
5140                         return (*i);
5141                 }
5142         }
5143         return boost::shared_ptr<Processor>();
5144 }
5145
5146 bool
5147 Route::is_track()
5148 {
5149         return dynamic_cast<Track*>(this) != 0;
5150 }
5151
5152 void
5153 Route::non_realtime_locate (samplepos_t pos)
5154 {
5155         Automatable::non_realtime_locate (pos);
5156
5157         if (_pannable) {
5158                 _pannable->non_realtime_locate (pos);
5159         }
5160
5161 #if 0 // XXX mayhaps clear delayline here (and at stop?)
5162         if (_delayline) {
5163                 _delayline->flush ();
5164         }
5165 #endif
5166
5167         {
5168                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
5169                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5170
5171                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5172                         (*i)->non_realtime_locate (pos);
5173                 }
5174         }
5175 }
5176
5177 void
5178 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
5179 {
5180         size_t n_buffers;
5181         size_t i;
5182
5183         /* MIDI
5184          *
5185          * We don't currently mix MIDI input together, so we don't need the
5186          * complex logic of the audio case.
5187          */
5188
5189         n_buffers = bufs.count().n_midi ();
5190
5191         for (i = 0; i < n_buffers; ++i) {
5192
5193                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
5194                 MidiBuffer& buf (bufs.get_midi (i));
5195
5196                 if (source_port) {
5197                         buf.copy (source_port->get_midi_buffer(nframes));
5198                 } else {
5199                         buf.silence (nframes);
5200                 }
5201         }
5202
5203         /* AUDIO */
5204
5205         n_buffers = bufs.count().n_audio();
5206
5207         size_t n_ports = io->n_ports().n_audio();
5208         float scaling = 1.0f;
5209
5210         if (n_ports > n_buffers) {
5211                 scaling = ((float) n_buffers) / n_ports;
5212         }
5213
5214         for (i = 0; i < n_ports; ++i) {
5215
5216                 /* if there are more ports than buffers, map them onto buffers
5217                  * in a round-robin fashion
5218                  */
5219
5220                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
5221                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
5222
5223                 if (i < n_buffers) {
5224
5225                         /* first time through just copy a channel into
5226                            the output buffer.
5227                         */
5228
5229                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
5230
5231                         if (scaling != 1.0f) {
5232                                 buf.apply_gain (scaling, nframes);
5233                         }
5234
5235                 } else {
5236
5237                         /* on subsequent times around, merge data from
5238                          * the port with what is already there
5239                          */
5240
5241                         if (scaling != 1.0f) {
5242                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
5243                         } else {
5244                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
5245                         }
5246                 }
5247         }
5248
5249         /* silence any remaining buffers */
5250
5251         for (; i < n_buffers; ++i) {
5252                 AudioBuffer& buf (bufs.get_audio (i));
5253                 buf.silence (nframes);
5254         }
5255
5256         /* establish the initial setup of the buffer set, reflecting what was
5257            copied into it. unless, of course, we are the auditioner, in which
5258            case nothing was fed into it from the inputs at all.
5259         */
5260
5261         if (!is_auditioner()) {
5262                 bufs.set_count (io->n_ports());
5263         }
5264 }
5265
5266 boost::shared_ptr<AutomationControl>
5267 Route::pan_azimuth_control() const
5268 {
5269 #ifdef MIXBUS
5270         if (_mixbus_send) {
5271                 return _mixbus_send->master_pan_ctrl ();
5272         }
5273         return boost::shared_ptr<AutomationControl>();
5274 #else
5275         if (!_pannable || !panner()) {
5276                 return boost::shared_ptr<AutomationControl>();
5277         }
5278         return _pannable->pan_azimuth_control;
5279 #endif
5280 }
5281
5282 boost::shared_ptr<AutomationControl>
5283 Route::pan_elevation_control() const
5284 {
5285         if (Profile->get_mixbus() || !_pannable || !panner()) {
5286                 return boost::shared_ptr<AutomationControl>();
5287         }
5288
5289         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5290
5291         if (c.find (PanElevationAutomation) != c.end()) {
5292                 return _pannable->pan_elevation_control;
5293         } else {
5294                 return boost::shared_ptr<AutomationControl>();
5295         }
5296 }
5297 boost::shared_ptr<AutomationControl>
5298 Route::pan_width_control() const
5299 {
5300 #ifdef MIXBUS
5301         if (mixbus() && _ch_pre) {
5302                 //mono blend
5303                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl>(_ch_pre->control(Evoral::Parameter(PluginAutomation, 0, 1)));
5304         }
5305 #endif
5306         if (Profile->get_mixbus() || !_pannable || !panner()) {
5307                 return boost::shared_ptr<AutomationControl>();
5308         }
5309
5310         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5311
5312         if (c.find (PanWidthAutomation) != c.end()) {
5313                 return _pannable->pan_width_control;
5314         } else {
5315                 return boost::shared_ptr<AutomationControl>();
5316         }
5317 }
5318 boost::shared_ptr<AutomationControl>
5319 Route::pan_frontback_control() const
5320 {
5321         if (Profile->get_mixbus() || !_pannable || !panner()) {
5322                 return boost::shared_ptr<AutomationControl>();
5323         }
5324
5325         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5326
5327         if (c.find (PanFrontBackAutomation) != c.end()) {
5328                 return _pannable->pan_frontback_control;
5329         } else {
5330                 return boost::shared_ptr<AutomationControl>();
5331         }
5332 }
5333 boost::shared_ptr<AutomationControl>
5334 Route::pan_lfe_control() const
5335 {
5336         if (Profile->get_mixbus() || !_pannable || !panner()) {
5337                 return boost::shared_ptr<AutomationControl>();
5338         }
5339
5340         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5341
5342         if (c.find (PanLFEAutomation) != c.end()) {
5343                 return _pannable->pan_lfe_control;
5344         } else {
5345                 return boost::shared_ptr<AutomationControl>();
5346         }
5347 }
5348
5349 uint32_t
5350 Route::eq_band_cnt () const
5351 {
5352         if (Profile->get_mixbus()) {
5353 #ifdef MIXBUS32C
5354                 if (is_master() || mixbus()) {
5355                         return 3;
5356                 } else {
5357                         return 4;
5358                 }
5359 #else
5360                 return 3;
5361 #endif
5362         } else {
5363                 /* Ardour has no well-known EQ object */
5364                 return 0;
5365         }
5366 }
5367
5368 boost::shared_ptr<AutomationControl>
5369 Route::eq_gain_controllable (uint32_t band) const
5370 {
5371 #ifdef MIXBUS
5372         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5373
5374         if (!eq) {
5375                 return boost::shared_ptr<AutomationControl>();
5376         }
5377
5378         uint32_t port_number;
5379         if (is_master() || mixbus()) {
5380                 switch (band) {
5381                         case 0: port_number = 4; break;
5382                         case 1: port_number = 3; break;
5383                         case 2: port_number = 2; break;
5384                         default:
5385                                 return boost::shared_ptr<AutomationControl>();
5386                 }
5387         } else {
5388 #ifdef MIXBUS32C
5389                 switch (band) {
5390                         case 0: port_number = 14; break;
5391                         case 1: port_number = 12; break;
5392                         case 2: port_number = 10; break;
5393                         case 3: port_number =  8; break;
5394                         default:
5395                                 return boost::shared_ptr<AutomationControl>();
5396                 }
5397 #else
5398                 switch (band) {
5399                         case 0: port_number = 8; break;
5400                         case 1: port_number = 6; break;
5401                         case 2: port_number = 4; break;
5402                         default:
5403                                 return boost::shared_ptr<AutomationControl>();
5404                 }
5405 #endif
5406         }
5407
5408         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5409 #else
5410         return boost::shared_ptr<AutomationControl>();
5411 #endif
5412 }
5413 boost::shared_ptr<AutomationControl>
5414 Route::eq_freq_controllable (uint32_t band) const
5415 {
5416 #ifdef MIXBUS
5417         if (mixbus() || is_master()) {
5418                 /* no frequency controls for mixbusses or master */
5419                 return boost::shared_ptr<AutomationControl>();
5420         }
5421
5422         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5423
5424         if (!eq) {
5425                 return boost::shared_ptr<AutomationControl>();
5426         }
5427
5428         uint32_t port_number;
5429 #ifdef MIXBUS32C
5430         switch (band) {
5431                 case 0: port_number = 13; break; // lo
5432                 case 1: port_number = 11; break; // lo mid
5433                 case 2: port_number = 9; break; // hi mid
5434                 case 3: port_number = 7; break; // hi
5435                 default:
5436                         return boost::shared_ptr<AutomationControl>();
5437         }
5438 #else
5439         switch (band) {
5440                 case 0: port_number = 7; break;
5441                 case 1: port_number = 5; break;
5442                 case 2: port_number = 3; break;
5443                 default:
5444                         return boost::shared_ptr<AutomationControl>();
5445         }
5446 #endif
5447
5448         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5449 #else
5450         return boost::shared_ptr<AutomationControl>();
5451 #endif
5452 }
5453
5454 boost::shared_ptr<AutomationControl>
5455 Route::eq_q_controllable (uint32_t band) const
5456 {
5457         return boost::shared_ptr<AutomationControl>();
5458 }
5459
5460 boost::shared_ptr<AutomationControl>
5461 Route::eq_shape_controllable (uint32_t band) const
5462 {
5463 #ifdef MIXBUS32C
5464         if (is_master() || mixbus() || !eq) {
5465                 return boost::shared_ptr<AutomationControl>();
5466         }
5467         switch (band) {
5468                 case 0:
5469                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4))); // lo bell
5470                         break;
5471                 case 3:
5472                         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3))); // hi bell
5473                         break;
5474                 default:
5475                         break;
5476         }
5477 #endif
5478         return boost::shared_ptr<AutomationControl>();
5479 }
5480
5481 boost::shared_ptr<AutomationControl>
5482 Route::eq_enable_controllable () const
5483 {
5484 #ifdef MIXBUS
5485         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5486
5487         if (!eq) {
5488                 return boost::shared_ptr<AutomationControl>();
5489         }
5490
5491         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5492 #else
5493         return boost::shared_ptr<AutomationControl>();
5494 #endif
5495 }
5496
5497 boost::shared_ptr<AutomationControl>
5498 Route::filter_freq_controllable (bool hpf) const
5499 {
5500 #ifdef MIXBUS
5501         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5502
5503         if (is_master() || mixbus() || !eq) {
5504                 return boost::shared_ptr<AutomationControl>();
5505         }
5506         if (hpf) {
5507 #ifdef MIXBUS32C
5508                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5))); // HPF freq
5509 #else
5510                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5511 #endif
5512         } else {
5513 #ifdef MIXBUS32C
5514                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6))); // LPF freq
5515 #else
5516                 return boost::shared_ptr<AutomationControl>();
5517 #endif
5518         }
5519
5520 #else
5521         return boost::shared_ptr<AutomationControl>();
5522 #endif
5523 }
5524
5525 boost::shared_ptr<AutomationControl>
5526 Route::filter_slope_controllable (bool) const
5527 {
5528         return boost::shared_ptr<AutomationControl>();
5529 }
5530
5531 boost::shared_ptr<AutomationControl>
5532 Route::filter_enable_controllable (bool) const
5533 {
5534 #ifdef MIXBUS32C
5535         boost::shared_ptr<PluginInsert> eq = _ch_eq;
5536
5537         if (is_master() || mixbus() || !eq) {
5538                 return boost::shared_ptr<AutomationControl>();
5539         }
5540
5541         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5542 #else
5543         return boost::shared_ptr<AutomationControl>();
5544 #endif
5545 }
5546
5547 boost::shared_ptr<AutomationControl>
5548 Route::tape_drive_controllable () const
5549 {
5550 #ifdef MIXBUS
5551         if (_ch_pre) {
5552                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_pre->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 0)));
5553         }
5554 #endif
5555         return boost::shared_ptr<AutomationControl>();
5556 }
5557
5558 boost::shared_ptr<ReadOnlyControl>
5559 Route::tape_drive_mtr_controllable () const
5560 {
5561 #ifdef MIXBUS
5562         if (_ch_pre) {
5563                 return _ch_pre->control_output (is_master() ? 1 : 2);
5564         }
5565 #endif
5566         return boost::shared_ptr<ReadOnlyControl>();
5567 }
5568
5569 boost::shared_ptr<ReadOnlyControl>
5570 Route::master_correlation_mtr_controllable (bool mm) const
5571 {
5572 #ifdef MIXBUS
5573         if (is_master() && _ch_post) {
5574                 return _ch_post->control_output (mm ? 4 : 3);
5575         }
5576 #endif
5577         return boost::shared_ptr<ReadOnlyControl>();
5578 }
5579
5580 boost::shared_ptr<AutomationControl>
5581 Route::master_limiter_enable_controllable () const
5582 {
5583 #ifdef MIXBUS
5584         if (is_master() && _ch_post) {
5585                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_post->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5586         }
5587 #endif
5588         return boost::shared_ptr<AutomationControl>();
5589 }
5590
5591 boost::shared_ptr<ReadOnlyControl>
5592 Route::master_limiter_mtr_controllable () const
5593 {
5594 #ifdef MIXBUS
5595         if (is_master() && _ch_post) {
5596                 return _ch_post->control_output (2);
5597         }
5598 #endif
5599         return boost::shared_ptr<ReadOnlyControl>();
5600 }
5601
5602 boost::shared_ptr<ReadOnlyControl>
5603 Route::master_k_mtr_controllable () const
5604 {
5605 #ifdef MIXBUS
5606         if (is_master() && _ch_post) {
5607                 return _ch_post->control_output (5);
5608         }
5609 #endif
5610         return boost::shared_ptr<ReadOnlyControl>();
5611 }
5612
5613 string
5614 Route::eq_band_name (uint32_t band) const
5615 {
5616 #ifdef MIXBUS32C
5617         if (is_master() || mixbus()) {
5618 #endif
5619         if (Profile->get_mixbus()) {
5620                 switch (band) {
5621                         case 0: return _("lo");
5622                         case 1: return _("mid");
5623                         case 2: return _("hi");
5624                         default: return string();
5625                 }
5626         } else {
5627                 return string ();
5628         }
5629 #ifdef MIXBUS32C
5630         } else {
5631                 switch (band) {
5632                         case 0: return _("lo");
5633                         case 1: return _("lm");
5634                         case 2: return _("hm");
5635                         case 3: return _("hi");
5636                         default: return string();
5637                 }
5638         }
5639 #endif
5640 }
5641
5642 boost::shared_ptr<AutomationControl>
5643 Route::comp_enable_controllable () const
5644 {
5645 #ifdef MIXBUS
5646         if (_ch_comp) {
5647                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5648         }
5649 #endif
5650         return boost::shared_ptr<AutomationControl>();
5651 }
5652 boost::shared_ptr<AutomationControl>
5653 Route::comp_threshold_controllable () const
5654 {
5655 #ifdef MIXBUS
5656         if (_ch_comp) {
5657                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5658         }
5659 #endif
5660         return boost::shared_ptr<AutomationControl>();
5661 }
5662 boost::shared_ptr<AutomationControl>
5663 Route::comp_speed_controllable () const
5664 {
5665 #ifdef MIXBUS
5666         if (_ch_comp) {
5667                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5668         }
5669 #endif
5670         return boost::shared_ptr<AutomationControl>();
5671 }
5672 boost::shared_ptr<AutomationControl>
5673 Route::comp_mode_controllable () const
5674 {
5675 #ifdef MIXBUS
5676         if (_ch_comp) {
5677                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5678         }
5679 #endif
5680         return boost::shared_ptr<AutomationControl>();
5681 }
5682 boost::shared_ptr<AutomationControl>
5683 Route::comp_makeup_controllable () const
5684 {
5685 #ifdef MIXBUS
5686         if (_ch_comp) {
5687                 return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (_ch_comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5688         }
5689 #endif
5690         return boost::shared_ptr<AutomationControl>();
5691 }
5692 boost::shared_ptr<ReadOnlyControl>
5693 Route::comp_redux_controllable () const
5694 {
5695 #ifdef MIXBUS
5696         if (_ch_comp) {
5697                 return _ch_comp->control_output (6);
5698         }
5699 #endif
5700         return boost::shared_ptr<ReadOnlyControl>();
5701 }
5702
5703 string
5704 Route::comp_mode_name (uint32_t mode) const
5705 {
5706 #ifdef MIXBUS
5707         switch (mode) {
5708         case 0:
5709                 return _("Leveler");
5710         case 1:
5711                 return _("Compressor");
5712         case 2:
5713                 return _("Limiter");
5714         case 3:
5715                 return mixbus() ? _("Sidechain") : _("Limiter");
5716         }
5717
5718         return _("???");
5719 #else
5720         return _("???");
5721 #endif
5722 }
5723
5724 string
5725 Route::comp_speed_name (uint32_t mode) const
5726 {
5727 #ifdef MIXBUS
5728         switch (mode) {
5729         case 0:
5730                 return _("Attk");
5731         case 1:
5732                 return _("Ratio");
5733         case 2:
5734         case 3:
5735                 return _("Rels");
5736         }
5737         return _("???");
5738 #else
5739         return _("???");
5740 #endif
5741 }
5742
5743 boost::shared_ptr<AutomationControl>
5744 Route::send_pan_azimuth_controllable (uint32_t n) const
5745 {
5746 #ifdef  MIXBUS
5747         if (_mixbus_send) {
5748                 if (n < _mixbus_send->n_busses ()) {
5749                         return _mixbus_send->send_pan_ctrl (n + 1);
5750                 }
5751         }
5752 #endif
5753         return boost::shared_ptr<AutomationControl>();
5754 }
5755
5756 boost::shared_ptr<AutomationControl>
5757 Route::send_level_controllable (uint32_t n) const
5758 {
5759 #ifdef  MIXBUS
5760         if (_mixbus_send) {
5761                 if (n < _mixbus_send->n_busses ()) {
5762                         return _mixbus_send->send_gain_ctrl (n + 1);
5763                 }
5764                 n -= _mixbus_send->n_busses ();
5765         }
5766 #endif
5767         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5768         if (s) {
5769                 return s->gain_control ();
5770         }
5771         return boost::shared_ptr<AutomationControl>();
5772 }
5773
5774 boost::shared_ptr<AutomationControl>
5775 Route::send_enable_controllable (uint32_t n) const
5776 {
5777 #ifdef  MIXBUS
5778         if (_mixbus_send) {
5779                 if (n < _mixbus_send->n_busses ()) {
5780                         return _mixbus_send->send_enable_ctrl (n + 1);
5781                 }
5782         }
5783 #endif
5784         /* although Ardour sends have enable/disable as part of the Processor
5785          * API, it is not exposed as a controllable.
5786          *
5787          * XXX: we should fix this (make it click-free, automatable enable-control)
5788          */
5789         return boost::shared_ptr<AutomationControl>();
5790 }
5791
5792 boost::shared_ptr<AutomationControl>
5793 Route::send_pan_azimuth_enable_controllable (uint32_t n) const
5794 {
5795 #ifdef  MIXBUS
5796         if (_mixbus_send) {
5797                 if (n < _mixbus_send->n_busses ()) {
5798                         return _mixbus_send->send_pan_enable_ctrl (n + 1);
5799                 }
5800         }
5801 #endif
5802         return boost::shared_ptr<AutomationControl>();
5803 }
5804
5805 string
5806 Route::send_name (uint32_t n) const
5807 {
5808 #ifdef  MIXBUS
5809         if (_mixbus_send) {
5810                 if (n < _mixbus_send->n_busses ()) {
5811                         return _session.get_mixbus (n)->name();
5812                 }
5813                 n -= _mixbus_send->n_busses ();
5814         }
5815 #endif
5816         boost::shared_ptr<Processor> p = nth_send (n);
5817         if (p) {
5818                 return p->name();
5819         }
5820         return string();
5821 }
5822
5823 boost::shared_ptr<AutomationControl>
5824 Route::master_send_enable_controllable () const
5825 {
5826 #ifdef  MIXBUS
5827         if (is_master() || is_monitor() || is_auditioner()) {
5828                 return boost::shared_ptr<AutomationControl>();
5829         }
5830
5831         if (_mixbus_send) {
5832                 return _mixbus_send->master_send_enable_ctrl ();
5833         }
5834
5835 #endif
5836         return boost::shared_ptr<AutomationControl>();
5837 }
5838
5839 bool
5840 Route::slaved () const
5841 {
5842         if (!_gain_control) {
5843                 return false;
5844         }
5845         /* just test one particular control, not all of them */
5846         return _gain_control->slaved ();
5847 }
5848
5849 bool
5850 Route::slaved_to (boost::shared_ptr<VCA> vca) const
5851 {
5852         if (!vca || !_gain_control) {
5853                 return false;
5854         }
5855
5856         /* just test one particular control, not all of them */
5857
5858         return _gain_control->slaved_to (vca->gain_control());
5859 }
5860
5861 bool
5862 Route::muted_by_others_soloing () const
5863 {
5864         if (!can_be_muted_by_others ()) {
5865                 return false;
5866         }
5867
5868         return  _session.soloing() && !_solo_control->soloed() && !_solo_isolate_control->solo_isolated();
5869 }
5870
5871 void
5872 Route::clear_all_solo_state ()
5873 {
5874         _solo_control->clear_all_solo_state ();
5875 }
5876
5877 boost::shared_ptr<AutomationControl>
5878 Route::automation_control_recurse (PBD::ID const & id) const
5879 {
5880         boost::shared_ptr<AutomationControl> ac = Automatable::automation_control (id);
5881
5882         if (ac) {
5883                 return ac;
5884         }
5885
5886         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5887
5888         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5889                 if ((ac = (*i)->automation_control (id))) {
5890                         return ac;
5891                 }
5892         }
5893
5894         return boost::shared_ptr<AutomationControl> ();
5895 }
5896
5897 SlavableControlList
5898 Route::slavables () const
5899 {
5900         SlavableControlList rv;
5901         rv.push_back (_gain_control);
5902         rv.push_back (_mute_control);
5903         rv.push_back (_solo_control);
5904         return rv;
5905 }
5906
5907 void
5908 Route::set_meter_type (MeterType t)
5909 {
5910         _meter->set_meter_type (t);
5911 }
5912
5913 MeterType
5914 Route::meter_type () const
5915 {
5916         return _meter->meter_type ();
5917 }
5918
5919 void
5920 Route::set_disk_io_point (DiskIOPoint diop)
5921 {
5922         bool display = false;
5923
5924         cerr << "set disk io to " << enum_2_string (diop) << endl;
5925
5926         switch (diop) {
5927         case DiskIOCustom:
5928                 display = true;
5929                 break;
5930         default:
5931                 display = false;
5932         }
5933
5934         if (_disk_writer) {
5935                 _disk_writer->set_display_to_user (display);
5936         }
5937
5938         if (_disk_reader) {
5939                 _disk_reader->set_display_to_user (display);
5940         }
5941
5942         const bool changed = (diop != _disk_io_point);
5943
5944         _disk_io_point = diop;
5945
5946         if (changed) {
5947                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
5948                 configure_processors (0);
5949         }
5950
5951         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
5952 }
5953
5954 void
5955 Route::set_loop (Location* l)
5956 {
5957         _loop_location = l;
5958         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5959         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5960                 (*i)->set_loop (l);
5961         }
5962 }
5963
5964 MonitorState
5965 Route::monitoring_state () const
5966 {
5967         if (!_disk_reader) {
5968                 return MonitoringInput;
5969         }
5970
5971         /* Explicit requests */
5972         MonitorChoice m (_monitoring_control->monitoring_choice());
5973
5974         if (m != MonitorAuto) {
5975
5976                 MonitorState ms ((MonitorState) 0);
5977
5978                 if (m & MonitorInput) {
5979                         ms = MonitoringInput;
5980                 }
5981
5982                 if (m & MonitorDisk) {
5983                         ms = MonitorState (ms | MonitoringDisk);
5984                 }
5985
5986                 return ms;
5987         }
5988
5989         switch (_session.config.get_session_monitoring ()) {
5990                 case MonitorDisk:
5991                         return MonitoringDisk;
5992                         break;
5993                 case MonitorInput:
5994                         return MonitoringInput;
5995                         break;
5996                 default:
5997                         break;
5998         }
5999
6000         return get_auto_monitoring_state();
6001 }