libs/ardour/route.cc

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