libs/ardour/route.cc

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