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