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