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