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