libs/ardour/route.cc

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