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