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