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