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, &lm)) {
1314                                 pstate.restore ();
1315                                 configure_processors_unlocked (0, &lm); // 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         boost::shared_ptr<Send> send;
1343         if ((send = boost::dynamic_pointer_cast<Send> (processor))) {
1344                 send->SelfDestruct.connect_same_thread (*this,
1345                                 boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
1346         }
1347
1348         return 0;
1349 }
1350
1351 void
1352 Route::processor_selfdestruct (boost::weak_ptr<Processor> wp)
1353 {
1354         /* We cannot destruct the processor here (usually RT-thread
1355          * with various locks held - in case of sends also io_locks).
1356          * Queue for deletion in low-priority thread.
1357          */
1358         Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
1359         selfdestruct_sequence.push_back (wp);
1360 }
1361
1362 bool
1363 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
1364 {
1365         const XMLProperty *prop;
1366
1367         try {
1368                 boost::shared_ptr<Processor> processor;
1369
1370                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
1371                    so that we can add the processor in the right place (pre/post-fader)
1372                 */
1373
1374                 XMLNodeList const & children = node.children ();
1375                 XMLNodeList::const_iterator i = children.begin ();
1376
1377                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
1378                         ++i;
1379                 }
1380
1381                 Placement placement = PreFader;
1382
1383                 if (i != children.end()) {
1384                         if ((prop = (*i)->property (X_("placement"))) != 0) {
1385                                 placement = Placement (string_2_enum (prop->value(), placement));
1386                         }
1387                 }
1388
1389                 if (node.name() == "Insert") {
1390
1391                         if ((prop = node.property ("type")) != 0) {
1392
1393                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
1394                                                 prop->value() == "lv2" ||
1395                                                 prop->value() == "windows-vst" ||
1396                                                 prop->value() == "lxvst" ||
1397                                                 prop->value() == "audiounit") {
1398
1399                                         if (_session.get_disable_all_loaded_plugins ()) {
1400                                                 processor.reset (new UnknownProcessor (_session, node));
1401                                         } else {
1402                                                 processor.reset (new PluginInsert (_session));
1403                                                 processor->set_owner (this);
1404                                         }
1405
1406                                 } else {
1407
1408                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
1409                                 }
1410
1411                         }
1412
1413                 } else if (node.name() == "Send") {
1414
1415                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
1416                         processor.reset (new Send (_session, sendpan, _mute_master));
1417
1418                 } else {
1419
1420                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1421                         return false;
1422                 }
1423
1424                 if (processor->set_state (node, version)) {
1425                         return false;
1426                 }
1427
1428                 //A2 uses the "active" flag in the toplevel redirect node, not in the child plugin/IO
1429                 if (i != children.end()) {
1430                         if ((prop = (*i)->property (X_("active"))) != 0) {
1431                                 if ( string_is_affirmative (prop->value()) && (!_session.get_bypass_all_loaded_plugins () || !processor->display_to_user () ) )
1432                                         processor->activate();
1433                                 else
1434                                         processor->deactivate();
1435                         }
1436                 }
1437
1438                 return (add_processor (processor, placement, 0, false) == 0);
1439         }
1440
1441         catch (failed_constructor &err) {
1442                 warning << _("processor could not be created. Ignored.") << endmsg;
1443                 return false;
1444         }
1445 }
1446
1447 int
1448 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1449 {
1450         /* NOTE: this is intended to be used ONLY when copying
1451            processors from another Route. Hence the subtle
1452            differences between this and ::add_processor()
1453         */
1454
1455         ProcessorList::iterator loc;
1456
1457         if (before) {
1458                 loc = find(_processors.begin(), _processors.end(), before);
1459         } else {
1460                 /* nothing specified - at end */
1461                 loc = _processors.end ();
1462         }
1463
1464         if (!_session.engine().connected()) {
1465                 return 1;
1466         }
1467
1468         if (others.empty()) {
1469                 return 0;
1470         }
1471
1472         {
1473                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1474                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1475                 ProcessorState pstate (this);
1476
1477                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1478
1479                         if (*i == _meter) {
1480                                 continue;
1481                         }
1482
1483                         boost::shared_ptr<PluginInsert> pi;
1484
1485                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1486                                 pi->set_strict_io (_strict_io);
1487                         }
1488
1489                         _processors.insert (loc, *i);
1490                         (*i)->set_owner (this);
1491
1492                         if ((*i)->active()) {
1493                                 (*i)->activate ();
1494                         }
1495
1496                         /* Think: does this really need to be called for every processor in the loop? */
1497                         {
1498                                 if (configure_processors_unlocked (err, &lm)) {
1499                                         pstate.restore ();
1500                                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
1501                                         return -1;
1502                                 }
1503                         }
1504
1505                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1506                 }
1507
1508                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1509                         boost::shared_ptr<PluginInsert> pi;
1510
1511                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1512                                 if (pi->has_no_inputs ()) {
1513                                         _have_internal_generator = true;
1514                                         break;
1515                                 }
1516                         }
1517                 }
1518
1519                 _output->set_user_latency (0);
1520         }
1521
1522         reset_instrument_info ();
1523         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1524         set_processor_positions ();
1525
1526         return 0;
1527 }
1528
1529 void
1530 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1531 {
1532         if (p == PreFader) {
1533                 start = _processors.begin();
1534                 end = find(_processors.begin(), _processors.end(), _amp);
1535         } else {
1536                 start = find(_processors.begin(), _processors.end(), _amp);
1537                 ++start;
1538                 end = _processors.end();
1539         }
1540 }
1541
1542 /** Turn off all processors with a given placement
1543  * @param p Placement of processors to disable
1544  */
1545 void
1546 Route::disable_processors (Placement p)
1547 {
1548         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1549
1550         ProcessorList::iterator start, end;
1551         placement_range(p, start, end);
1552
1553         for (ProcessorList::iterator i = start; i != end; ++i) {
1554                 (*i)->deactivate ();
1555         }
1556
1557         _session.set_dirty ();
1558 }
1559
1560 /** Turn off all redirects
1561  */
1562 void
1563 Route::disable_processors ()
1564 {
1565         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1566
1567         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1568                 (*i)->deactivate ();
1569         }
1570
1571         _session.set_dirty ();
1572 }
1573
1574 /** Turn off all redirects with a given placement
1575  * @param p Placement of redirects to disable
1576  */
1577 void
1578 Route::disable_plugins (Placement p)
1579 {
1580         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1581
1582         ProcessorList::iterator start, end;
1583         placement_range(p, start, end);
1584
1585         for (ProcessorList::iterator i = start; i != end; ++i) {
1586                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1587                         (*i)->deactivate ();
1588                 }
1589         }
1590
1591         _session.set_dirty ();
1592 }
1593
1594 /** Turn off all plugins
1595  */
1596 void
1597 Route::disable_plugins ()
1598 {
1599         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1600
1601         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1602                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1603                         (*i)->deactivate ();
1604                 }
1605         }
1606
1607         _session.set_dirty ();
1608 }
1609
1610
1611 void
1612 Route::ab_plugins (bool forward)
1613 {
1614         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1615
1616         if (forward) {
1617
1618                 /* forward = turn off all active redirects, and mark them so that the next time
1619                    we go the other way, we will revert them
1620                 */
1621
1622                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1623                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1624                                 continue;
1625                         }
1626
1627                         if ((*i)->active()) {
1628                                 (*i)->deactivate ();
1629                                 (*i)->set_next_ab_is_active (true);
1630                         } else {
1631                                 (*i)->set_next_ab_is_active (false);
1632                         }
1633                 }
1634
1635         } else {
1636
1637                 /* backward = if the redirect was marked to go active on the next ab, do so */
1638
1639                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1640
1641                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1642                                 continue;
1643                         }
1644
1645                         if ((*i)->get_next_ab_is_active()) {
1646                                 (*i)->activate ();
1647                         } else {
1648                                 (*i)->deactivate ();
1649                         }
1650                 }
1651         }
1652
1653         _session.set_dirty ();
1654 }
1655
1656
1657 /** Remove processors with a given placement.
1658  * @param p Placement of processors to remove.
1659  */
1660 void
1661 Route::clear_processors (Placement p)
1662 {
1663         if (!_session.engine().connected()) {
1664                 return;
1665         }
1666
1667         bool already_deleting = _session.deletion_in_progress();
1668         if (!already_deleting) {
1669                 _session.set_deletion_in_progress();
1670         }
1671
1672         {
1673                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1674                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1675                 ProcessorList new_list;
1676                 ProcessorStreams err;
1677                 bool seen_amp = false;
1678
1679                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1680
1681                         if (*i == _amp) {
1682                                 seen_amp = true;
1683                         }
1684
1685                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs || (*i) == _delayline || (*i) == _trim) {
1686
1687                                 /* you can't remove these */
1688
1689                                 new_list.push_back (*i);
1690
1691                         } else {
1692                                 if (seen_amp) {
1693
1694                                         switch (p) {
1695                                         case PreFader:
1696                                                 new_list.push_back (*i);
1697                                                 break;
1698                                         case PostFader:
1699                                                 (*i)->drop_references ();
1700                                                 break;
1701                                         }
1702
1703                                 } else {
1704
1705                                         switch (p) {
1706                                         case PreFader:
1707                                                 (*i)->drop_references ();
1708                                                 break;
1709                                         case PostFader:
1710                                                 new_list.push_back (*i);
1711                                                 break;
1712                                         }
1713                                 }
1714                         }
1715                 }
1716
1717                 _processors = new_list;
1718                 configure_processors_unlocked (&err, &lm); // this can't fail
1719         }
1720
1721         processor_max_streams.reset();
1722         _have_internal_generator = false;
1723         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1724         set_processor_positions ();
1725
1726         reset_instrument_info ();
1727
1728         if (!already_deleting) {
1729                 _session.clear_deletion_in_progress();
1730         }
1731 }
1732
1733 int
1734 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err, bool need_process_lock)
1735 {
1736         // TODO once the export point can be configured properly, do something smarter here
1737         if (processor == _capturing_processor) {
1738                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1739                 if (need_process_lock) {
1740                         lx.acquire();
1741                 }
1742
1743                 _capturing_processor.reset();
1744
1745                 if (need_process_lock) {
1746                         lx.release();
1747                 }
1748         }
1749
1750         /* these can never be removed */
1751
1752         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1753                 return 0;
1754         }
1755
1756         if (!_session.engine().connected()) {
1757                 return 1;
1758         }
1759
1760         processor_max_streams.reset();
1761
1762         {
1763                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
1764                 if (need_process_lock) {
1765                         lx.acquire();
1766                 }
1767
1768                 /* Caller must hold process lock */
1769                 assert (!AudioEngine::instance()->process_lock().trylock());
1770
1771                 Glib::Threads::RWLock::WriterLock lm (_processor_lock); // XXX deadlock after export
1772
1773                 ProcessorState pstate (this);
1774
1775                 ProcessorList::iterator i;
1776                 bool removed = false;
1777
1778                 for (i = _processors.begin(); i != _processors.end(); ) {
1779                         if (*i == processor) {
1780
1781                                 /* move along, see failure case for configure_processors()
1782                                    where we may need to reconfigure the processor.
1783                                 */
1784
1785                                 /* stop redirects that send signals to JACK ports
1786                                    from causing noise as a result of no longer being
1787                                    run.
1788                                 */
1789
1790                                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1791                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*i);
1792
1793                                 if (pi != 0) {
1794                                         assert (iop == 0);
1795                                         iop = pi->sidechain();
1796                                 }
1797
1798                                 if (iop != 0) {
1799                                         iop->disconnect ();
1800                                 }
1801
1802                                 i = _processors.erase (i);
1803                                 removed = true;
1804                                 break;
1805
1806                         } else {
1807                                 ++i;
1808                         }
1809
1810                         _output->set_user_latency (0);
1811                 }
1812
1813                 if (!removed) {
1814                         /* what? */
1815                         return 1;
1816                 }
1817
1818                 if (configure_processors_unlocked (err, &lm)) {
1819                         pstate.restore ();
1820                         /* we know this will work, because it worked before :) */
1821                         configure_processors_unlocked (0, &lm);
1822                         return -1;
1823                 }
1824
1825                 _have_internal_generator = false;
1826
1827                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1828                         boost::shared_ptr<PluginInsert> pi;
1829
1830                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1831                                 if (pi->has_no_inputs ()) {
1832                                         _have_internal_generator = true;
1833                                         break;
1834                                 }
1835                         }
1836                 }
1837                 if (need_process_lock) {
1838                         lx.release();
1839                 }
1840         }
1841
1842         reset_instrument_info ();
1843         processor->drop_references ();
1844         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1845         set_processor_positions ();
1846
1847         return 0;
1848 }
1849
1850 int
1851 Route::replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err)
1852 {
1853         /* these can never be removed */
1854         if (old == _amp || old == _meter || old == _main_outs || old == _delayline || old == _trim) {
1855                 return 1;
1856         }
1857         /* and can't be used as substitute, either */
1858         if (sub == _amp || sub == _meter || sub == _main_outs || sub == _delayline || sub == _trim) {
1859                 return 1;
1860         }
1861
1862         /* I/Os are out, too */
1863         if (boost::dynamic_pointer_cast<IOProcessor> (old) || boost::dynamic_pointer_cast<IOProcessor> (sub)) {
1864                 return 1;
1865         }
1866
1867         /* this function cannot be used to swap/reorder processors */
1868         if (find (_processors.begin(), _processors.end(), sub) != _processors.end ()) {
1869                 return 1;
1870         }
1871
1872         if (!AudioEngine::instance()->connected() || !old || !sub) {
1873                 return 1;
1874         }
1875
1876         /* ensure that sub is not owned by another route */
1877         if (sub->owner ()) {
1878                 return 1;
1879         }
1880
1881         {
1882                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1883                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1884                 ProcessorState pstate (this);
1885
1886                 assert (find (_processors.begin(), _processors.end(), sub) == _processors.end ());
1887
1888                 ProcessorList::iterator i;
1889                 bool replaced = false;
1890                 bool enable = old->active ();
1891
1892                 for (i = _processors.begin(); i != _processors.end(); ) {
1893                         if (*i == old) {
1894                                 i = _processors.erase (i);
1895                                 _processors.insert (i, sub);
1896                                 sub->set_owner (this);
1897                                 replaced = true;
1898                                 break;
1899                         } else {
1900                                 ++i;
1901                         }
1902                 }
1903
1904                 if (!replaced) {
1905                         return 1;
1906                 }
1907
1908                 if (_strict_io) {
1909                         boost::shared_ptr<PluginInsert> pi;
1910                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(sub)) != 0) {
1911                                 pi->set_strict_io (true);
1912                         }
1913                 }
1914
1915                 if (configure_processors_unlocked (err, &lm)) {
1916                         pstate.restore ();
1917                         configure_processors_unlocked (0, &lm);
1918                         return -1;
1919                 }
1920
1921                 _have_internal_generator = false;
1922
1923                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1924                         boost::shared_ptr<PluginInsert> pi;
1925                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1926                                 if (pi->has_no_inputs ()) {
1927                                         _have_internal_generator = true;
1928                                         break;
1929                                 }
1930                         }
1931                 }
1932
1933                 if (enable) {
1934                         sub->activate ();
1935                 }
1936
1937                 sub->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1938                 _output->set_user_latency (0);
1939         }
1940
1941         reset_instrument_info ();
1942         old->drop_references ();
1943         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1944         set_processor_positions ();
1945         return 0;
1946 }
1947
1948 int
1949 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1950 {
1951         ProcessorList deleted;
1952
1953         if (!_session.engine().connected()) {
1954                 return 1;
1955         }
1956
1957         processor_max_streams.reset();
1958
1959         {
1960                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1961                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
1962                 ProcessorState pstate (this);
1963
1964                 ProcessorList::iterator i;
1965                 boost::shared_ptr<Processor> processor;
1966
1967                 for (i = _processors.begin(); i != _processors.end(); ) {
1968
1969                         processor = *i;
1970
1971                         /* these can never be removed */
1972
1973                         if (processor == _amp || processor == _meter || processor == _main_outs || processor == _delayline || processor == _trim) {
1974                                 ++i;
1975                                 continue;
1976                         }
1977
1978                         /* see if its in the list of processors to delete */
1979
1980                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1981                                 ++i;
1982                                 continue;
1983                         }
1984
1985                         /* stop IOProcessors that send to JACK ports
1986                            from causing noise as a result of no longer being
1987                            run.
1988                         */
1989
1990                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(processor);
1991                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
1992                         if (pi != 0) {
1993                                 assert (iop == 0);
1994                                 iop = pi->sidechain();
1995                         }
1996
1997                         if (iop != 0) {
1998                                 iop->disconnect ();
1999                         }
2000
2001                         deleted.push_back (processor);
2002                         i = _processors.erase (i);
2003                 }
2004
2005                 if (deleted.empty()) {
2006                         /* none of those in the requested list were found */
2007                         return 0;
2008                 }
2009
2010                 _output->set_user_latency (0);
2011
2012                 if (configure_processors_unlocked (err, &lm)) {
2013                         pstate.restore ();
2014                         /* we know this will work, because it worked before :) */
2015                         configure_processors_unlocked (0, &lm);
2016                         return -1;
2017                 }
2018                 //lx.unlock();
2019
2020                 _have_internal_generator = false;
2021
2022                 for (i = _processors.begin(); i != _processors.end(); ++i) {
2023                         boost::shared_ptr<PluginInsert> pi;
2024
2025                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2026                                 if (pi->has_no_inputs ()) {
2027                                         _have_internal_generator = true;
2028                                         break;
2029                                 }
2030                         }
2031                 }
2032         }
2033
2034         /* now try to do what we need to so that those that were removed will be deleted */
2035
2036         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
2037                 (*i)->drop_references ();
2038         }
2039
2040         reset_instrument_info ();
2041         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2042         set_processor_positions ();
2043
2044         return 0;
2045 }
2046
2047 void
2048 Route::reset_instrument_info ()
2049 {
2050         boost::shared_ptr<Processor> instr = the_instrument();
2051         if (instr) {
2052                 _instrument_info.set_internal_instrument (instr);
2053         }
2054 }
2055
2056 /** Caller must hold process lock */
2057 int
2058 Route::configure_processors (ProcessorStreams* err)
2059 {
2060 #ifndef PLATFORM_WINDOWS
2061         assert (!AudioEngine::instance()->process_lock().trylock());
2062 #endif
2063
2064         if (!_in_configure_processors) {
2065                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2066                 return configure_processors_unlocked (err, &lm);
2067         }
2068
2069         return 0;
2070 }
2071
2072 ChanCount
2073 Route::input_streams () const
2074 {
2075         return _input->n_ports ();
2076 }
2077
2078 list<pair<ChanCount, ChanCount> >
2079 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
2080 {
2081         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2082
2083         return try_configure_processors_unlocked (in, err);
2084 }
2085
2086 list<pair<ChanCount, ChanCount> >
2087 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
2088 {
2089         // Check each processor in order to see if we can configure as requested
2090         ChanCount out;
2091         list<pair<ChanCount, ChanCount> > configuration;
2092         uint32_t index = 0;
2093
2094         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
2095         DEBUG_TRACE (DEBUG::Processors, "{\n");
2096
2097         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
2098
2099                 if ((*p)->can_support_io_configuration(in, out)) {
2100
2101                         if (boost::dynamic_pointer_cast<Delivery> (*p)
2102                                         && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main
2103                                         && !(is_monitor() || is_auditioner())
2104                                         && ( _strict_io || Profile->get_mixbus ())) {
2105                                 /* with strict I/O the panner + output are forced to
2106                                  * follow the last processor's output.
2107                                  *
2108                                  * Delivery::can_support_io_configuration() will only add ports,
2109                                  * but not remove excess ports.
2110                                  *
2111                                  * This works because the delivery only requires
2112                                  * as many outputs as there are inputs.
2113                                  * Delivery::configure_io() will do the actual removal
2114                                  * by calling _output->ensure_io()
2115                                  */
2116                                 if (!is_master() && _session.master_out ()) {
2117                                         /* ..but at least as many as there are master-inputs */
2118                                         // XXX this may need special-casing for mixbus (master-outputs)
2119                                         // and should maybe be a preference anyway ?!
2120                                         out = ChanCount::max (in, _session.master_out ()->n_inputs ());
2121                                 } else {
2122                                         out = in;
2123                                 }
2124                         }
2125
2126                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
2127                         configuration.push_back(make_pair(in, out));
2128
2129                         if (is_monitor()) {
2130                                 // restriction for Monitor Section Processors
2131                                 if (in.n_audio() != out.n_audio() || out.n_midi() > 0) {
2132                                         /* do not allow to add/remove channels (for now)
2133                                          * The Monitor follows the master-bus and has no panner (unpan)
2134                                          * but do allow processors with midi-in to be added (e.g VSTs with control that
2135                                          * will remain unconnected)
2136                                          */
2137                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: Channel configuration not allowed.\n");
2138                                         return list<pair<ChanCount, ChanCount> > ();
2139                                 }
2140                                 if (boost::dynamic_pointer_cast<InternalSend> (*p)) {
2141                                         // internal sends make no sense, only feedback
2142                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
2143                                         return list<pair<ChanCount, ChanCount> > ();
2144                                 }
2145                                 if (boost::dynamic_pointer_cast<PortInsert> (*p)) {
2146                                         /* External Sends can be problematic. one can add/remove ports
2147                                          * there signal leaves the DAW to external monitors anyway, so there's
2148                                          * no real use for allowing them here anyway.
2149                                          */
2150                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No External Sends allowed.\n");
2151                                         return list<pair<ChanCount, ChanCount> > ();
2152                                 }
2153                                 if (boost::dynamic_pointer_cast<Send> (*p)) {
2154                                         // ditto
2155                                         DEBUG_TRACE (DEBUG::Processors, "Monitor: No Sends allowed.\n");
2156                                         return list<pair<ChanCount, ChanCount> > ();
2157                                 }
2158                         }
2159                         in = out;
2160                 } else {
2161                         if (err) {
2162                                 err->index = index;
2163                                 err->count = in;
2164                         }
2165                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
2166                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
2167                         DEBUG_TRACE (DEBUG::Processors, "}\n");
2168                         return list<pair<ChanCount, ChanCount> > ();
2169                 }
2170         }
2171
2172         DEBUG_TRACE (DEBUG::Processors, "}\n");
2173
2174         return configuration;
2175 }
2176
2177 /** Set the input/output configuration of each processor in the processors list.
2178  *  Caller must hold process lock.
2179  *  Return 0 on success, otherwise configuration is impossible.
2180  */
2181 int
2182 Route::configure_processors_unlocked (ProcessorStreams* err, Glib::Threads::RWLock::WriterLock* lm)
2183 {
2184 #ifndef PLATFORM_WINDOWS
2185         assert (!AudioEngine::instance()->process_lock().trylock());
2186 #endif
2187
2188         if (_in_configure_processors) {
2189                 return 0;
2190         }
2191
2192         /* put invisible processors where they should be */
2193         setup_invisible_processors ();
2194
2195         _in_configure_processors = true;
2196
2197         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
2198
2199         if (configuration.empty ()) {
2200                 _in_configure_processors = false;
2201                 return -1;
2202         }
2203
2204         ChanCount out;
2205         bool seen_mains_out = false;
2206         processor_out_streams = _input->n_ports();
2207         processor_max_streams.reset();
2208
2209         /* processor configure_io() may result in adding ports
2210          * e.g. Delivery::configure_io -> ARDOUR::IO::ensure_io ()
2211          *
2212          * with jack2 adding ports results in a graph-order callback,
2213          * which calls Session::resort_routes() and eventually
2214          * Route::direct_feeds_according_to_reality()
2215          * which takes a ReaderLock (_processor_lock).
2216          *
2217          * so we can't hold a WriterLock here until jack2 threading
2218          * is fixed.
2219          *
2220          * NB. we still hold the process lock
2221          *
2222          * (ardour's own engines do call graph-order from the
2223          * process-thread and hence do not have this issue; besides
2224          * merely adding ports won't trigger a graph-order, only
2225          * making connections does)
2226          */
2227         lm->release ();
2228
2229         // TODO check for a potential ReaderLock after ReaderLock ??
2230         Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
2231
2232         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
2233         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
2234
2235                 if (!(*p)->configure_io(c->first, c->second)) {
2236                         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration failed\n", _name));
2237                         _in_configure_processors = false;
2238                         lr.release ();
2239                         lm->acquire ();
2240                         return -1;
2241                 }
2242                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
2243                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
2244
2245                 boost::shared_ptr<IOProcessor> iop;
2246                 boost::shared_ptr<PluginInsert> pi;
2247                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2248                         /* plugins connected via Split or Hide Match may have more channels.
2249                          * route/scratch buffers are needed for all of them
2250                          * The configuration may only be a subset (both input and output)
2251                          */
2252                         processor_max_streams = ChanCount::max(processor_max_streams, pi->required_buffers());
2253                 }
2254                 else if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*p)) != 0) {
2255                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_input_streams());
2256                         processor_max_streams = ChanCount::max(processor_max_streams, iop->natural_output_streams());
2257                 }
2258                 out = c->second;
2259
2260                 if (boost::dynamic_pointer_cast<Delivery> (*p)
2261                                 && boost::dynamic_pointer_cast<Delivery> (*p)->role() == Delivery::Main) {
2262                         /* main delivery will increase port count to match input.
2263                          * the Delivery::Main is usually the last processor - followed only by
2264                          * 'MeterOutput'.
2265                          */
2266                         seen_mains_out = true;
2267                 }
2268                 if (!seen_mains_out) {
2269                         processor_out_streams = out;
2270                 }
2271         }
2272
2273         lr.release ();
2274         lm->acquire ();
2275
2276
2277         if (_meter) {
2278                 _meter->set_max_channels (processor_max_streams);
2279         }
2280
2281         /* make sure we have sufficient scratch buffers to cope with the new processor
2282            configuration
2283         */
2284         _session.ensure_buffers (n_process_buffers ());
2285
2286         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
2287
2288         _in_configure_processors = false;
2289         return 0;
2290 }
2291
2292 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
2293  *  @param state New active state for those processors.
2294  */
2295 void
2296 Route::all_visible_processors_active (bool state)
2297 {
2298         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2299
2300         if (_processors.empty()) {
2301                 return;
2302         }
2303
2304         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2305                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
2306                         continue;
2307                 }
2308
2309                 if (state) {
2310                         (*i)->activate ();
2311                 } else {
2312                         (*i)->deactivate ();
2313                 }
2314         }
2315
2316         _session.set_dirty ();
2317 }
2318
2319 bool
2320 Route::processors_reorder_needs_configure (const ProcessorList& new_order)
2321 {
2322         /* check if re-order requires re-configuration of any processors
2323          * -> compare channel configuration for all processors
2324          */
2325         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2326         ChanCount c = input_streams ();
2327
2328         for (ProcessorList::const_iterator j = new_order.begin(); j != new_order.end(); ++j) {
2329                 bool found = false;
2330                 if (c != (*j)->input_streams()) {
2331                         return true;
2332                 }
2333                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2334                         if (*i == *j) {
2335                                 found = true;
2336                                 if ((*i)->input_streams() != c) {
2337                                         return true;
2338                                 }
2339                                 c = (*i)->output_streams();
2340                                 break;
2341                         }
2342                 }
2343                 if (!found) {
2344                         return true;
2345                 }
2346         }
2347         return false;
2348 }
2349
2350 #ifdef __clang__
2351 __attribute__((annotate("realtime")))
2352 #endif
2353 void
2354 Route::apply_processor_order (const ProcessorList& new_order)
2355 {
2356         /* need to hold processor_lock; either read or write lock
2357          * and the engine process_lock.
2358          * Due to r/w lock ambiguity we can only assert the latter
2359          */
2360         assert (!AudioEngine::instance()->process_lock().trylock());
2361
2362
2363         /* "new_order" is an ordered list of processors to be positioned according to "placement".
2364          * NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
2365          * processors in the current actual processor list that are hidden. Any visible processors
2366          *  in the current list but not in "new_order" will be assumed to be deleted.
2367          */
2368
2369         /* "as_it_will_be" and "_processors" are lists of shared pointers.
2370          * actual memory usage is small, but insert/erase is not actually rt-safe :(
2371          * (note though that  ::processors_reorder_needs_configure() ensured that
2372          * this function will only ever be called from the rt-thread if no processor were removed)
2373          *
2374          * either way, I can't proove it, but an x-run due to re-order here is less likley
2375          * than an x-run-less 'ardour-silent cycle' both of which effectively "click".
2376          */
2377
2378         ProcessorList as_it_will_be;
2379         ProcessorList::iterator oiter;
2380         ProcessorList::const_iterator niter;
2381
2382         oiter = _processors.begin();
2383         niter = new_order.begin();
2384
2385         while (niter !=  new_order.end()) {
2386
2387                 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
2388                    then append it to the temp list.
2389
2390                    Otherwise, see if the next processor in the old list is in the new list. if not,
2391                    its been deleted. If its there, append it to the temp list.
2392                    */
2393
2394                 if (oiter == _processors.end()) {
2395
2396                         /* no more elements in the old list, so just stick the rest of
2397                            the new order onto the temp list.
2398                            */
2399
2400                         as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
2401                         while (niter != new_order.end()) {
2402                                 ++niter;
2403                         }
2404                         break;
2405
2406                 } else {
2407
2408                         if (!(*oiter)->display_to_user()) {
2409
2410                                 as_it_will_be.push_back (*oiter);
2411
2412                         } else {
2413
2414                                 /* visible processor: check that its in the new order */
2415
2416                                 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
2417                                         /* deleted: do nothing, shared_ptr<> will clean up */
2418                                 } else {
2419                                         /* ignore this one, and add the next item from the new order instead */
2420                                         as_it_will_be.push_back (*niter);
2421                                         ++niter;
2422                                 }
2423                         }
2424
2425                         /* now remove from old order - its taken care of no matter what */
2426                         oiter = _processors.erase (oiter);
2427                 }
2428
2429         }
2430         _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
2431
2432         /* If the meter is in a custom position, find it and make a rough note of its position */
2433         maybe_note_meter_position ();
2434 }
2435
2436 int
2437 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
2438 {
2439         // it a change is already queued, wait for it
2440         // (unless engine is stopped. apply immediately and proceed
2441         while (g_atomic_int_get (&_pending_process_reorder)) {
2442                 if (!AudioEngine::instance()->running()) {
2443                         DEBUG_TRACE (DEBUG::Processors, "offline apply queued processor re-order.\n");
2444                         Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2445
2446                         apply_processor_order(_pending_processor_order);
2447                         setup_invisible_processors ();
2448
2449                         g_atomic_int_set (&_pending_process_reorder, 0);
2450
2451                         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2452                         set_processor_positions ();
2453                 } else {
2454                         // TODO rather use a semaphore or something.
2455                         // but since ::reorder_processors() is called
2456                         // from the GUI thread, this is fine..
2457                         Glib::usleep(500);
2458                 }
2459         }
2460
2461         if (processors_reorder_needs_configure (new_order) || !AudioEngine::instance()->running()) {
2462
2463                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2464                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2465                 ProcessorState pstate (this);
2466
2467                 apply_processor_order (new_order);
2468
2469                 if (configure_processors_unlocked (err, &lm)) {
2470                         pstate.restore ();
2471                         return -1;
2472                 }
2473
2474                 lm.release();
2475                 lx.release();
2476
2477                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2478                 set_processor_positions ();
2479
2480         } else {
2481                 DEBUG_TRACE (DEBUG::Processors, "Queue clickless processor re-order.\n");
2482                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2483
2484                 // _pending_processor_order is protected by _processor_lock
2485                 _pending_processor_order = new_order;
2486                 g_atomic_int_set (&_pending_process_reorder, 1);
2487         }
2488
2489         return 0;
2490 }
2491
2492 bool
2493 Route::add_remove_sidechain (boost::shared_ptr<Processor> proc, bool add)
2494 {
2495         boost::shared_ptr<PluginInsert> pi;
2496         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2497                 return false;
2498         }
2499
2500         if (pi->has_sidechain () == add) {
2501                 return true; // ?? call failed, but result is as expected.
2502         }
2503
2504         {
2505                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2506                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2507                 if (i == _processors.end ()) {
2508                         return false;
2509                 }
2510         }
2511
2512         {
2513                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ()); // take before Writerlock to avoid deadlock
2514                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2515                 PBD::Unwinder<bool> uw (_in_sidechain_setup, true);
2516
2517                 lx.release (); // IO::add_port() and ~IO takes process lock  - XXX check if this is safe
2518                 if (add) {
2519                         if (!pi->add_sidechain ()) {
2520                                 return false;
2521                         }
2522                 } else {
2523                         if (!pi->del_sidechain ()) {
2524                                 return false;
2525                         }
2526                 }
2527
2528                 lx.acquire ();
2529                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2530                 lx.release ();
2531
2532                 if (c.empty()) {
2533                         if (add) {
2534                                 pi->del_sidechain ();
2535                         } else {
2536                                 pi->add_sidechain ();
2537                                 // TODO restore side-chain's state.
2538                         }
2539                         return false;
2540                 }
2541                 lx.acquire ();
2542                 configure_processors_unlocked (0, &lm);
2543         }
2544
2545         if (pi->has_sidechain ()) {
2546                 pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
2547         }
2548
2549         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2550         _session.set_dirty ();
2551         return true;
2552 }
2553
2554 bool
2555 Route::plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs)
2556 {
2557         boost::shared_ptr<PluginInsert> pi;
2558         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2559                 return false;
2560         }
2561
2562         {
2563                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2564                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2565                 if (i == _processors.end ()) {
2566                         return false;
2567                 }
2568         }
2569
2570         {
2571                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2572                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2573
2574                 const ChanCount& old (pi->preset_out ());
2575                 if (!pi->set_preset_out (outs)) {
2576                         return true; // no change, OK
2577                 }
2578
2579                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2580                 if (c.empty()) {
2581                         /* not possible */
2582                         pi->set_preset_out (old);
2583                         return false;
2584                 }
2585                 configure_processors_unlocked (0, &lm);
2586         }
2587
2588         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2589         _session.set_dirty ();
2590         return true;
2591 }
2592
2593 bool
2594 Route::reset_plugin_insert (boost::shared_ptr<Processor> proc)
2595 {
2596         ChanCount unused;
2597         return customize_plugin_insert (proc, 0, unused, unused);
2598 }
2599
2600 bool
2601 Route::customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks)
2602 {
2603         boost::shared_ptr<PluginInsert> pi;
2604         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(proc)) == 0) {
2605                 return false;
2606         }
2607
2608         {
2609                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2610                 ProcessorList::iterator i = find (_processors.begin(), _processors.end(), proc);
2611                 if (i == _processors.end ()) {
2612                         return false;
2613                 }
2614         }
2615
2616         {
2617                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2618                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
2619
2620                 bool      old_cust  = pi->custom_cfg ();
2621                 uint32_t  old_cnt   = pi->get_count ();
2622                 ChanCount old_chan  = pi->output_streams ();
2623                 ChanCount old_sinks = pi->natural_input_streams ();
2624
2625                 if (count == 0) {
2626                         pi->set_custom_cfg (false);
2627                 } else {
2628                         pi->set_custom_cfg (true);
2629                         pi->set_count (count);
2630                         pi->set_outputs (outs);
2631                         pi->set_sinks (sinks);
2632                 }
2633
2634                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2635                 if (c.empty()) {
2636                         /* not possible */
2637
2638                         pi->set_count (old_cnt);
2639                         pi->set_sinks (old_sinks);
2640                         pi->set_outputs (old_chan);
2641                         pi->set_custom_cfg (old_cust);
2642
2643                         return false;
2644                 }
2645                 configure_processors_unlocked (0, &lm);
2646         }
2647
2648         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2649         _session.set_dirty ();
2650         return true;
2651 }
2652
2653 bool
2654 Route::set_strict_io (const bool enable)
2655 {
2656         Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
2657
2658         if (_strict_io != enable) {
2659                 _strict_io = enable;
2660                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2661                 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2662                         boost::shared_ptr<PluginInsert> pi;
2663                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2664                                 pi->set_strict_io (_strict_io);
2665                         }
2666                 }
2667
2668                 list<pair<ChanCount, ChanCount> > c = try_configure_processors_unlocked (n_inputs (), 0);
2669
2670                 if (c.empty()) {
2671                         // not possible
2672                         _strict_io = !enable; // restore old value
2673                         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
2674                                 boost::shared_ptr<PluginInsert> pi;
2675                                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*p)) != 0) {
2676                                         pi->set_strict_io (_strict_io);
2677                                 }
2678                         }
2679                         return false;
2680                 }
2681                 lm.release ();
2682
2683                 configure_processors (0);
2684                 lx.release ();
2685
2686                 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2687                 _session.set_dirty ();
2688         }
2689         return true;
2690 }
2691
2692 XMLNode&
2693 Route::get_state()
2694 {
2695         return state(true);
2696 }
2697
2698 XMLNode&
2699 Route::get_template()
2700 {
2701         return state(false);
2702 }
2703
2704 XMLNode&
2705 Route::state(bool full_state)
2706 {
2707         if (!_session._template_state_dir.empty()) {
2708                 assert (!full_state); // only for templates
2709                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), _session._template_state_dir));
2710         }
2711
2712         XMLNode *node = new XMLNode("Route");
2713         ProcessorList::iterator i;
2714         char buf[32];
2715
2716         id().print (buf, sizeof (buf));
2717         node->add_property("id", buf);
2718         node->add_property ("name", _name);
2719         node->add_property("default-type", _default_type.to_string());
2720         node->add_property ("strict-io", _strict_io);
2721
2722         if (_flags) {
2723                 node->add_property("flags", enum_2_string (_flags));
2724         }
2725
2726         node->add_property("active", _active?"yes":"no");
2727         string p;
2728         boost::to_string (_phase_invert, p);
2729         node->add_property("phase-invert", p);
2730         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
2731         node->add_property("meter-point", enum_2_string (_meter_point));
2732
2733         node->add_property("meter-type", enum_2_string (_meter_type));
2734
2735         if (_route_group) {
2736                 node->add_property("route-group", _route_group->name());
2737         }
2738
2739         snprintf (buf, sizeof (buf), "%d", _order_key);
2740         node->add_property ("order-key", buf);
2741         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
2742         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
2743         node->add_property ("soloed-by-upstream", buf);
2744         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
2745         node->add_property ("soloed-by-downstream", buf);
2746         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
2747         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
2748
2749         node->add_child_nocopy (_input->state (full_state));
2750         node->add_child_nocopy (_output->state (full_state));
2751         node->add_child_nocopy (_solo_control->get_state ());
2752         node->add_child_nocopy (_mute_control->get_state ());
2753         node->add_child_nocopy (_mute_master->get_state ());
2754
2755         if (full_state) {
2756                 node->add_child_nocopy (Automatable::get_automation_xml_state ());
2757         }
2758
2759         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
2760         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
2761         remote_control_node->add_property (X_("id"), buf);
2762         node->add_child_nocopy (*remote_control_node);
2763
2764         if (_comment.length()) {
2765                 XMLNode *cmt = node->add_child ("Comment");
2766                 cmt->add_content (_comment);
2767         }
2768
2769         if (_pannable) {
2770                 node->add_child_nocopy (_pannable->state (full_state));
2771         }
2772
2773         for (i = _processors.begin(); i != _processors.end(); ++i) {
2774                 if (!full_state) {
2775                         /* template save: do not include internal sends functioning as
2776                            aux sends because the chance of the target ID
2777                            in the session where this template is used
2778                            is not very likely.
2779
2780                            similarly, do not save listen sends which connect to
2781                            the monitor section, because these will always be
2782                            added if necessary.
2783                         */
2784                         boost::shared_ptr<InternalSend> is;
2785
2786                         if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
2787                                 if (is->role() == Delivery::Listen) {
2788                                         continue;
2789                                 }
2790                         }
2791                 }
2792                 node->add_child_nocopy((*i)->state (full_state));
2793         }
2794
2795         if (_extra_xml) {
2796                 node->add_child_copy (*_extra_xml);
2797         }
2798
2799         if (_custom_meter_position_noted) {
2800                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
2801                 if (after) {
2802                         after->id().print (buf, sizeof (buf));
2803                         node->add_property (X_("processor-after-last-custom-meter"), buf);
2804                 }
2805         }
2806
2807         if (!_session._template_state_dir.empty()) {
2808                 foreach_processor (sigc::bind (sigc::mem_fun (*this, &Route::set_plugin_state_dir), ""));
2809         }
2810
2811         return *node;
2812 }
2813
2814 int
2815 Route::set_state (const XMLNode& node, int version)
2816 {
2817         if (version < 3000) {
2818                 return set_state_2X (node, version);
2819         }
2820
2821         XMLNodeList nlist;
2822         XMLNodeConstIterator niter;
2823         XMLNode *child;
2824         const XMLProperty *prop;
2825
2826         if (node.name() != "Route"){
2827                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2828                 return -1;
2829         }
2830
2831         if ((prop = node.property (X_("name"))) != 0) {
2832                 Route::set_name (prop->value());
2833         }
2834
2835         set_id (node);
2836         _initial_io_setup = true;
2837
2838         if ((prop = node.property (X_("flags"))) != 0) {
2839                 _flags = Flag (string_2_enum (prop->value(), _flags));
2840         } else {
2841                 _flags = Flag (0);
2842         }
2843
2844         if ((prop = node.property (X_("strict-io"))) != 0) {
2845                 _strict_io = string_is_affirmative (prop->value());
2846         }
2847
2848         if (is_master() || is_monitor() || is_auditioner()) {
2849                 _mute_master->set_solo_ignore (true);
2850         }
2851
2852         if (is_monitor()) {
2853                 /* monitor bus does not get a panner, but if (re)created
2854                    via XML, it will already have one by the time we
2855                    call ::set_state(). so ... remove it.
2856                 */
2857                 unpan ();
2858         }
2859
2860         /* add all processors (except amp, which is always present) */
2861
2862         nlist = node.children();
2863         XMLNode processor_state (X_("processor_state"));
2864
2865         Stateful::save_extra_xml (node);
2866
2867         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2868
2869                 child = *niter;
2870
2871                 if (child->name() == IO::state_node_name) {
2872                         if ((prop = child->property (X_("direction"))) == 0) {
2873                                 continue;
2874                         }
2875
2876                         if (prop->value() == "Input") {
2877                                 _input->set_state (*child, version);
2878                         } else if (prop->value() == "Output") {
2879                                 _output->set_state (*child, version);
2880                         }
2881                 }
2882
2883                 if (child->name() == X_("Processor")) {
2884                         processor_state.add_child_copy (*child);
2885                 }
2886
2887                 if (child->name() == X_("Pannable")) {
2888                         if (_pannable) {
2889                                 _pannable->set_state (*child, version);
2890                         } else {
2891                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2892                         }
2893                 }
2894         }
2895
2896         if ((prop = node.property (X_("meter-point"))) != 0) {
2897                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2898                 set_meter_point (mp, true);
2899                 if (_meter) {
2900                         _meter->set_display_to_user (_meter_point == MeterCustom);
2901                 }
2902         }
2903
2904         if ((prop = node.property (X_("meter-type"))) != 0) {
2905                 _meter_type = MeterType (string_2_enum (prop->value (), _meter_type));
2906         }
2907
2908         _initial_io_setup = false;
2909
2910         set_processor_state (processor_state);
2911
2912         // this looks up the internal instrument in processors
2913         reset_instrument_info();
2914
2915         if ((prop = node.property ("self-solo")) != 0) {
2916                 set_self_solo (string_is_affirmative (prop->value()));
2917         }
2918
2919         if ((prop = node.property ("soloed-by-upstream")) != 0) {
2920                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2921                 mod_solo_by_others_upstream (atoi (prop->value()));
2922         }
2923
2924         if ((prop = node.property ("soloed-by-downstream")) != 0) {
2925                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2926                 mod_solo_by_others_downstream (atoi (prop->value()));
2927         }
2928
2929         if ((prop = node.property ("solo-isolated")) != 0) {
2930                 set_solo_isolated (string_is_affirmative (prop->value()), Controllable::NoGroup);
2931         }
2932
2933         if ((prop = node.property ("solo-safe")) != 0) {
2934                 set_solo_safe (string_is_affirmative (prop->value()), Controllable::NoGroup);
2935         }
2936
2937         if ((prop = node.property (X_("phase-invert"))) != 0) {
2938                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2939         }
2940
2941         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2942                 set_denormal_protection (string_is_affirmative (prop->value()));
2943         }
2944
2945         if ((prop = node.property (X_("active"))) != 0) {
2946                 bool yn = string_is_affirmative (prop->value());
2947                 _active = !yn; // force switch
2948                 set_active (yn, this);
2949         }
2950
2951         if ((prop = node.property (X_("order-key"))) != 0) { // New order key (no separate mixer/editor ordering)
2952                 set_order_key (atoi(prop->value()));
2953         }
2954
2955         if ((prop = node.property (X_("order-keys"))) != 0) { // Deprecated order keys
2956
2957                 int32_t n;
2958
2959                 string::size_type colon, equal;
2960                 string remaining = prop->value();
2961
2962                 while (remaining.length()) {
2963
2964                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2965                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2966                                       << endmsg;
2967                         } else {
2968                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2969                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2970                                               << endmsg;
2971                                 } else {
2972                                         string keyname = remaining.substr (0, equal);
2973
2974                                         if ((keyname == "EditorSort") || (keyname == "editor")) {
2975                                                 cerr << "Setting " << name() << " order key to " << n << " using saved Editor order." << endl;
2976                                                 set_order_key (n);
2977                                         }
2978                                 }
2979                         }
2980
2981                         colon = remaining.find_first_of (':');
2982
2983                         if (colon != string::npos) {
2984                                 remaining = remaining.substr (colon+1);
2985                         } else {
2986                                 break;
2987                         }
2988                 }
2989         }
2990
2991         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2992                 PBD::ID id (prop->value ());
2993                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
2994                 ProcessorList::const_iterator i = _processors.begin ();
2995                 while (i != _processors.end() && (*i)->id() != id) {
2996                         ++i;
2997                 }
2998
2999                 if (i != _processors.end ()) {
3000                         _processor_after_last_custom_meter = *i;
3001                         _custom_meter_position_noted = true;
3002                 }
3003         }
3004
3005         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
3006                 child = *niter;
3007
3008                 if (child->name() == X_("Comment")) {
3009
3010                         /* XXX this is a terrible API design in libxml++ */
3011
3012                         XMLNode *cmt = *(child->children().begin());
3013                         _comment = cmt->content();
3014
3015                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
3016                         if (prop->value() == "solo") {
3017                                 _solo_control->set_state (*child, version);
3018                         } else if (prop->value() == "mute") {
3019                                 _mute_control->set_state (*child, version);
3020                         }
3021
3022                 } else if (child->name() == X_("RemoteControl")) {
3023                         if ((prop = child->property (X_("id"))) != 0) {
3024                                 int32_t x;
3025                                 sscanf (prop->value().c_str(), "%d", &x);
3026                                 set_remote_control_id_internal (x);
3027                         }
3028
3029                 } else if (child->name() == X_("MuteMaster")) {
3030                         _mute_master->set_state (*child, version);
3031
3032                 } else if (child->name() == Automatable::xml_node_name) {
3033                         set_automation_xml_state (*child, Evoral::Parameter(NullAutomation));
3034                 }
3035         }
3036
3037         return 0;
3038 }
3039
3040 int
3041 Route::set_state_2X (const XMLNode& node, int version)
3042 {
3043         LocaleGuard lg (X_("C"));
3044         XMLNodeList nlist;
3045         XMLNodeConstIterator niter;
3046         XMLNode *child;
3047         const XMLProperty *prop;
3048
3049         /* 2X things which still remain to be handled:
3050          * default-type
3051          * automation
3052          * controlouts
3053          */
3054
3055         if (node.name() != "Route") {
3056                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
3057                 return -1;
3058         }
3059
3060         if ((prop = node.property (X_("flags"))) != 0) {
3061                 string f = prop->value ();
3062                 boost::replace_all (f, "ControlOut", "MonitorOut");
3063                 _flags = Flag (string_2_enum (f, _flags));
3064         } else {
3065                 _flags = Flag (0);
3066         }
3067
3068         if (is_master() || is_monitor() || is_auditioner()) {
3069                 _mute_master->set_solo_ignore (true);
3070         }
3071
3072         if ((prop = node.property (X_("phase-invert"))) != 0) {
3073                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
3074                 if (string_is_affirmative (prop->value ())) {
3075                         p.set ();
3076                 }
3077                 set_phase_invert (p);
3078         }
3079
3080         if ((prop = node.property (X_("denormal-protection"))) != 0) {
3081                 set_denormal_protection (string_is_affirmative (prop->value()));
3082         }
3083
3084         if ((prop = node.property (X_("soloed"))) != 0) {
3085                 bool yn = string_is_affirmative (prop->value());
3086
3087                 /* XXX force reset of solo status */
3088
3089                 set_solo (yn);
3090         }
3091
3092         if ((prop = node.property (X_("muted"))) != 0) {
3093
3094                 bool first = true;
3095                 bool muted = string_is_affirmative (prop->value());
3096
3097                 if (muted) {
3098
3099                         string mute_point;
3100
3101                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
3102
3103                                 if (string_is_affirmative (prop->value())){
3104                                         mute_point = mute_point + "PreFader";
3105                                         first = false;
3106                                 }
3107                         }
3108
3109                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
3110
3111                                 if (string_is_affirmative (prop->value())){
3112
3113                                         if (!first) {
3114                                                 mute_point = mute_point + ",";
3115                                         }
3116
3117                                         mute_point = mute_point + "PostFader";
3118                                         first = false;
3119                                 }
3120                         }
3121
3122                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
3123
3124                                 if (string_is_affirmative (prop->value())){
3125
3126                                         if (!first) {
3127                                                 mute_point = mute_point + ",";
3128                                         }
3129
3130                                         mute_point = mute_point + "Listen";
3131                                         first = false;
3132                                 }
3133                         }
3134
3135                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
3136
3137                                 if (string_is_affirmative (prop->value())){
3138
3139                                         if (!first) {
3140                                                 mute_point = mute_point + ",";
3141                                         }
3142
3143                                         mute_point = mute_point + "Main";
3144                                 }
3145                         }
3146
3147                         _mute_master->set_mute_points (mute_point);
3148                         _mute_master->set_muted_by_self (true);
3149                 }
3150         }
3151
3152         if ((prop = node.property (X_("meter-point"))) != 0) {
3153                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
3154         }
3155
3156         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
3157            don't mean the same thing.
3158         */
3159
3160         if ((prop = node.property (X_("order-keys"))) != 0) {
3161
3162                 int32_t n;
3163
3164                 string::size_type colon, equal;
3165                 string remaining = prop->value();
3166
3167                 while (remaining.length()) {
3168
3169                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
3170                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
3171                                         << endmsg;
3172                         } else {
3173                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
3174                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
3175                                                 << endmsg;
3176                                 } else {
3177                                         string keyname = remaining.substr (0, equal);
3178
3179                                         if (keyname == "EditorSort" || keyname == "editor") {
3180                                                 info << string_compose(_("Converting deprecated order key for %1 using Editor order %2"), name (), n) << endmsg;
3181                                                 set_order_key (n);
3182                                         }
3183                                 }
3184                         }
3185
3186                         colon = remaining.find_first_of (':');
3187
3188                         if (colon != string::npos) {
3189                                 remaining = remaining.substr (colon+1);
3190                         } else {
3191                                 break;
3192                         }
3193                 }
3194         }
3195
3196         /* IOs */
3197
3198         nlist = node.children ();
3199         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
3200
3201                 child = *niter;
3202
3203                 if (child->name() == IO::state_node_name) {
3204
3205                         /* there is a note in IO::set_state_2X() about why we have to call
3206                            this directly.
3207                            */
3208
3209                         _input->set_state_2X (*child, version, true);
3210                         _output->set_state_2X (*child, version, false);
3211
3212                         if ((prop = child->property (X_("name"))) != 0) {
3213                                 Route::set_name (prop->value ());
3214                         }
3215
3216                         set_id (*child);
3217
3218                         if ((prop = child->property (X_("active"))) != 0) {
3219                                 bool yn = string_is_affirmative (prop->value());
3220                                 _active = !yn; // force switch
3221                                 set_active (yn, this);
3222                         }
3223
3224                         if ((prop = child->property (X_("gain"))) != 0) {
3225                                 gain_t val;
3226
3227                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
3228                                         _amp->gain_control()->set_value (val, Controllable::NoGroup);
3229                                 }
3230                         }
3231
3232                         /* Set up Panners in the IO */
3233                         XMLNodeList io_nlist = child->children ();
3234
3235                         XMLNodeConstIterator io_niter;
3236                         XMLNode *io_child;
3237
3238                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
3239
3240                                 io_child = *io_niter;
3241
3242                                 if (io_child->name() == X_("Panner")) {
3243                                         _main_outs->panner_shell()->set_state(*io_child, version);
3244                                 } else if (io_child->name() == X_("Automation")) {
3245                                         /* IO's automation is for the fader */
3246                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
3247                                 }
3248                         }
3249                 }
3250         }
3251
3252         XMLNodeList redirect_nodes;
3253
3254         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
3255
3256                 child = *niter;
3257
3258                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
3259                         redirect_nodes.push_back(child);
3260                 }
3261
3262         }
3263
3264         set_processor_state_2X (redirect_nodes, version);
3265
3266         Stateful::save_extra_xml (node);
3267
3268         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
3269                 child = *niter;
3270
3271                 if (child->name() == X_("Comment")) {
3272
3273                         /* XXX this is a terrible API design in libxml++ */
3274
3275                         XMLNode *cmt = *(child->children().begin());
3276                         _comment = cmt->content();
3277
3278                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
3279                         if (prop->value() == X_("solo")) {
3280                                 _solo_control->set_state (*child, version);
3281                         } else if (prop->value() == X_("mute")) {
3282                                 _mute_control->set_state (*child, version);
3283                         }
3284
3285                 } else if (child->name() == X_("RemoteControl")) {
3286                         if ((prop = child->property (X_("id"))) != 0) {
3287                                 int32_t x;
3288                                 sscanf (prop->value().c_str(), "%d", &x);
3289                                 set_remote_control_id_internal (x);
3290                         }
3291
3292                 }
3293         }
3294
3295         return 0;
3296 }
3297
3298 XMLNode&
3299 Route::get_processor_state ()
3300 {
3301         XMLNode* root = new XMLNode (X_("redirects"));
3302         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3303                 root->add_child_nocopy ((*i)->state (true));
3304         }
3305
3306         return *root;
3307 }
3308
3309 void
3310 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
3311 {
3312         /* We don't bother removing existing processors not in nList, as this
3313            method will only be called when creating a Route from scratch, not
3314            for undo purposes.  Just put processors in at the appropriate place
3315            in the list.
3316         */
3317
3318         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
3319                 add_processor_from_xml_2X (**i, version);
3320         }
3321 }
3322
3323 void
3324 Route::set_processor_state (const XMLNode& node)
3325 {
3326         const XMLNodeList &nlist = node.children();
3327         XMLNodeConstIterator niter;
3328         ProcessorList new_order;
3329         bool must_configure = false;
3330
3331         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
3332
3333                 XMLProperty* prop = (*niter)->property ("type");
3334
3335                 if (prop->value() == "amp") {
3336                         _amp->set_state (**niter, Stateful::current_state_version);
3337                         new_order.push_back (_amp);
3338                 } else if (prop->value() == "trim") {
3339                         _trim->set_state (**niter, Stateful::current_state_version);
3340                         new_order.push_back (_trim);
3341                 } else if (prop->value() == "meter") {
3342                         _meter->set_state (**niter, Stateful::current_state_version);
3343                         new_order.push_back (_meter);
3344                 } else if (prop->value() == "delay") {
3345                         if (_delayline) {
3346                                 _delayline->set_state (**niter, Stateful::current_state_version);
3347                                 new_order.push_back (_delayline);
3348                         }
3349                 } else if (prop->value() == "main-outs") {
3350                         _main_outs->set_state (**niter, Stateful::current_state_version);
3351                 } else if (prop->value() == "intreturn") {
3352                         if (!_intreturn) {
3353                                 _intreturn.reset (new InternalReturn (_session));
3354                                 must_configure = true;
3355                         }
3356                         _intreturn->set_state (**niter, Stateful::current_state_version);
3357                 } else if (is_monitor() && prop->value() == "monitor") {
3358                         if (!_monitor_control) {
3359                                 _monitor_control.reset (new MonitorProcessor (_session));
3360                                 must_configure = true;
3361                         }
3362                         _monitor_control->set_state (**niter, Stateful::current_state_version);
3363                 } else if (prop->value() == "capture") {
3364                         /* CapturingProcessor should never be restored, it's always
3365                            added explicitly when needed */
3366                 } else {
3367                         ProcessorList::iterator o;
3368
3369                         for (o = _processors.begin(); o != _processors.end(); ++o) {
3370                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
3371                                 if (id_prop && (*o)->id() == id_prop->value()) {
3372                                         (*o)->set_state (**niter, Stateful::current_state_version);
3373                                         new_order.push_back (*o);
3374                                         break;
3375                                 }
3376                         }
3377
3378                         // If the processor (*niter) is not on the route then create it
3379
3380                         if (o == _processors.end()) {
3381
3382                                 boost::shared_ptr<Processor> processor;
3383
3384                                 if (prop->value() == "intsend") {
3385
3386                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), boost::shared_ptr<Route>(), Delivery::Aux, true));
3387
3388                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
3389                                            prop->value() == "lv2" ||
3390                                            prop->value() == "windows-vst" ||
3391                                            prop->value() == "lxvst" ||
3392                                            prop->value() == "luaproc" ||
3393                                            prop->value() == "audiounit") {
3394
3395                                         if (_session.get_disable_all_loaded_plugins ()) {
3396                                                 processor.reset (new UnknownProcessor (_session, **niter));
3397                                         } else {
3398                                                 processor.reset (new PluginInsert (_session));
3399                                                 processor->set_owner (this);
3400                                                 if (_strict_io) {
3401                                                         boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(processor);
3402                                                         pi->set_strict_io (true);
3403                                                 }
3404
3405                                         }
3406                                 } else if (prop->value() == "port") {
3407
3408                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
3409
3410                                 } else if (prop->value() == "send") {
3411
3412                                         processor.reset (new Send (_session, _pannable, _mute_master, Delivery::Send, true));
3413                                         boost::shared_ptr<Send> send = boost::dynamic_pointer_cast<Send> (processor);
3414                                         send->SelfDestruct.connect_same_thread (*this,
3415                                                         boost::bind (&Route::processor_selfdestruct, this, boost::weak_ptr<Processor> (processor)));
3416
3417                                 } else {
3418                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
3419                                         continue;
3420                                 }
3421
3422                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
3423                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
3424                                         processor.reset (new UnknownProcessor (_session, **niter));
3425                                 }
3426
3427                                 /* subscribe to Sidechain IO changes */
3428                                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert> (processor);
3429                                 if (pi && pi->has_sidechain ()) {
3430                                         pi->sidechain_input ()->changed.connect_same_thread (*this, boost::bind (&Route::sidechain_change_handler, this, _1, _2));
3431                                 }
3432
3433                                 /* we have to note the monitor send here, otherwise a new one will be created
3434                                    and the state of this one will be lost.
3435                                 */
3436                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
3437                                 if (isend && isend->role() == Delivery::Listen) {
3438                                         _monitor_send = isend;
3439                                 }
3440
3441                                 /* it doesn't matter if invisible processors are added here, as they
3442                                    will be sorted out by setup_invisible_processors () shortly.
3443                                 */
3444
3445                                 new_order.push_back (processor);
3446                                 must_configure = true;
3447                         }
3448                 }
3449         }
3450
3451         {
3452                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
3453                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
3454                 _processors = new_order;
3455
3456                 if (must_configure) {
3457                         configure_processors_unlocked (0, &lm);
3458                 }
3459
3460                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3461
3462                         (*i)->set_owner (this);
3463                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
3464
3465                         boost::shared_ptr<PluginInsert> pi;
3466
3467                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
3468                                 if (pi->has_no_inputs ()) {
3469                                         _have_internal_generator = true;
3470                                         break;
3471                                 }
3472                         }
3473                 }
3474         }
3475
3476         reset_instrument_info ();
3477         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3478         set_processor_positions ();
3479 }
3480
3481 void
3482 Route::curve_reallocate ()
3483 {
3484 //      _gain_automation_curve.finish_resize ();
3485 //      _pan_automation_curve.finish_resize ();
3486 }
3487
3488 void
3489 Route::silence (framecnt_t nframes)
3490 {
3491         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
3492         if (!lm.locked()) {
3493                 return;
3494         }
3495
3496         silence_unlocked (nframes);
3497 }
3498
3499 void
3500 Route::silence_unlocked (framecnt_t nframes)
3501 {
3502         /* Must be called with the processor lock held */
3503
3504         if (!_silent) {
3505
3506                 _output->silence (nframes);
3507
3508                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3509                         boost::shared_ptr<PluginInsert> pi;
3510
3511                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
3512                                 // skip plugins, they don't need anything when we're not active
3513                                 continue;
3514                         }
3515
3516                         (*i)->silence (nframes);
3517                 }
3518
3519                 if (nframes == _session.get_block_size()) {
3520                         // _silent = true;
3521                 }
3522         }
3523 }
3524
3525 void
3526 Route::add_internal_return ()
3527 {
3528         if (!_intreturn) {
3529                 _intreturn.reset (new InternalReturn (_session));
3530                 add_processor (_intreturn, PreFader);
3531         }
3532 }
3533
3534 void
3535 Route::add_send_to_internal_return (InternalSend* send)
3536 {
3537         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3538
3539         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3540                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3541
3542                 if (d) {
3543                         return d->add_send (send);
3544                 }
3545         }
3546 }
3547
3548 void
3549 Route::remove_send_from_internal_return (InternalSend* send)
3550 {
3551         Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3552
3553         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
3554                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
3555
3556                 if (d) {
3557                         return d->remove_send (send);
3558                 }
3559         }
3560 }
3561
3562 void
3563 Route::enable_monitor_send ()
3564 {
3565         /* Caller must hold process lock */
3566         assert (!AudioEngine::instance()->process_lock().trylock());
3567
3568         /* master never sends to monitor section via the normal mechanism */
3569         assert (!is_master ());
3570         assert (!is_monitor ());
3571
3572         /* make sure we have one */
3573         if (!_monitor_send) {
3574                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), _session.monitor_out(), Delivery::Listen));
3575                 _monitor_send->set_display_to_user (false);
3576         }
3577
3578         /* set it up */
3579         configure_processors (0);
3580 }
3581
3582 /** Add an aux send to a route.
3583  *  @param route route to send to.
3584  *  @param before Processor to insert before, or 0 to insert at the end.
3585  */
3586 int
3587 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
3588 {
3589         assert (route != _session.monitor_out ());
3590
3591         {
3592                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
3593
3594                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3595
3596                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
3597
3598                         if (d && d->target_route() == route) {
3599                                 /* already listening via the specified IO: do nothing */
3600                                 return 0;
3601                         }
3602                 }
3603         }
3604
3605         try {
3606
3607                 boost::shared_ptr<InternalSend> listener;
3608
3609                 {
3610                         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3611                         boost::shared_ptr<Pannable> sendpan (new Pannable (_session));
3612                         listener.reset (new InternalSend (_session, sendpan, _mute_master, boost::dynamic_pointer_cast<ARDOUR::Route>(shared_from_this()), route, Delivery::Aux));
3613                 }
3614
3615                 add_processor (listener, before);
3616
3617         } catch (failed_constructor& err) {
3618                 return -1;
3619         }
3620
3621         return 0;
3622 }
3623
3624 void
3625 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
3626 {
3627         ProcessorStreams err;
3628         ProcessorList::iterator tmp;
3629
3630         {
3631                 Glib::Threads::RWLock::ReaderLock rl(_processor_lock);
3632
3633                 /* have to do this early because otherwise processor reconfig
3634                  * will put _monitor_send back in the list
3635                  */
3636
3637                 if (route == _session.monitor_out()) {
3638                         _monitor_send.reset ();
3639                 }
3640
3641           again:
3642                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
3643
3644                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
3645
3646                         if (d && d->target_route() == route) {
3647                                 rl.release ();
3648                                 if (remove_processor (*x, &err, false) > 0) {
3649                                         rl.acquire ();
3650                                         continue;
3651                                 }
3652                                 rl.acquire ();
3653
3654                                 /* list could have been demolished while we dropped the lock
3655                                    so start over.
3656                                 */
3657                                 if (_session.engine().connected()) {
3658                                         /* i/o processors cannot be removed if the engine is not running
3659                                          * so don't live-loop in case the engine is N/A or dies
3660                                          */
3661                                         goto again;
3662                                 }
3663                         }
3664                 }
3665         }
3666 }
3667
3668 void
3669 Route::set_comment (string cmt, void *src)
3670 {
3671         _comment = cmt;
3672         comment_changed ();
3673         _session.set_dirty ();
3674 }
3675
3676 bool
3677 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
3678 {
3679         FeedRecord fr (other, via_sends_only);
3680
3681         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
3682
3683         if (!result.second) {
3684
3685                 /* already a record for "other" - make sure sends-only information is correct */
3686                 if (!via_sends_only && result.first->sends_only) {
3687                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
3688                         frp->sends_only = false;
3689                 }
3690         }
3691
3692         return result.second;
3693 }
3694
3695 void
3696 Route::clear_fed_by ()
3697 {
3698         _fed_by.clear ();
3699 }
3700
3701 bool
3702 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
3703 {
3704         const FedBy& fed_by (other->fed_by());
3705
3706         for (FedBy::const_iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
3707                 boost::shared_ptr<Route> sr = f->r.lock();
3708
3709                 if (sr && (sr.get() == this)) {
3710
3711                         if (via_sends_only) {
3712                                 *via_sends_only = f->sends_only;
3713                         }
3714
3715                         return true;
3716                 }
3717         }
3718
3719         return false;
3720 }
3721
3722 IOVector
3723 Route::all_inputs () const
3724 {
3725         /* TODO, if this works as expected,
3726          * cache the IOVector and maintain it via
3727          * input_change_handler(), sidechain_change_handler() etc
3728          */
3729         IOVector ios;
3730         ios.push_back (_input);
3731
3732         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3733         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3734
3735                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3736                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3737                 if (pi != 0) {
3738                         assert (iop == 0);
3739                         iop = pi->sidechain();
3740                 }
3741
3742                 if (iop != 0 && iop->input()) {
3743                         ios.push_back (iop->input());
3744                 }
3745         }
3746         return ios;
3747 }
3748
3749 IOVector
3750 Route::all_outputs () const
3751 {
3752         IOVector ios;
3753         // _output is included via Delivery
3754         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3755         for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) {
3756                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3757                 if (iop != 0 && iop->output()) {
3758                         ios.push_back (iop->output());
3759                 }
3760         }
3761         return ios;
3762 }
3763
3764 bool
3765 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
3766 {
3767         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
3768         if (other->all_inputs().fed_by (_output)) {
3769                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
3770                 if (via_send_only) {
3771                         *via_send_only = false;
3772                 }
3773
3774                 return true;
3775         }
3776
3777         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3778
3779         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
3780
3781                 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor>(*r);
3782                 boost::shared_ptr<PluginInsert> pi = boost::dynamic_pointer_cast<PluginInsert>(*r);
3783                 if (pi != 0) {
3784                         assert (iop == 0);
3785                         iop = pi->sidechain();
3786                 }
3787
3788                 if (iop != 0) {
3789                         boost::shared_ptr<const IO> iop_out = iop->output();
3790                         if ((iop_out && other->all_inputs().fed_by (iop_out)) || iop->feeds (other)) {
3791                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
3792                                 if (via_send_only) {
3793                                         *via_send_only = true;
3794                                 }
3795                                 return true;
3796                         } else {
3797                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
3798                         }
3799                 } else {
3800                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
3801                 }
3802
3803         }
3804
3805         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
3806         return false;
3807 }
3808
3809 bool
3810 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
3811 {
3812         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
3813 }
3814
3815 bool
3816 Route::feeds_according_to_graph (boost::shared_ptr<Route> other)
3817 {
3818         return _session._current_route_graph.feeds (shared_from_this (), other);
3819 }
3820
3821 /** Called from the (non-realtime) butler thread when the transport is stopped */
3822 void
3823 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool /*did_locate*/, bool can_flush_processors)
3824 {
3825         framepos_t now = _session.transport_frame();
3826
3827         {
3828                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
3829
3830                 Automatable::transport_stopped (now);
3831
3832                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3833
3834                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
3835                                 (*i)->flush ();
3836                         }
3837
3838                         (*i)->transport_stopped (now);
3839                 }
3840         }
3841
3842         _roll_delay = _initial_delay;
3843 }
3844
3845 void
3846 Route::input_change_handler (IOChange change, void * /*src*/)
3847 {
3848         if ((change.type & IOChange::ConfigurationChanged)) {
3849                 /* This is called with the process lock held if change
3850                    contains ConfigurationChanged
3851                 */
3852                 configure_processors (0);
3853                 _phase_invert.resize (_input->n_ports().n_audio ());
3854                 io_changed (); /* EMIT SIGNAL */
3855         }
3856
3857         if (_soloed_by_others_upstream || _solo_isolated_by_upstream) {
3858                 int sbou = 0;
3859                 int ibou = 0;
3860                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3861                 if (_input->connected()) {
3862                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3863                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3864                                         continue;
3865                                 }
3866                                 bool sends_only;
3867                                 bool does_feed = (*i)->direct_feeds_according_to_reality (shared_from_this(), &sends_only);
3868                                 if (does_feed && !sends_only) {
3869                                         if ((*i)->soloed()) {
3870                                                 ++sbou;
3871                                         }
3872                                         if ((*i)->solo_isolated()) {
3873                                                 ++ibou;
3874                                         }
3875                                 }
3876                         }
3877                 }
3878
3879                 int delta  = sbou - _soloed_by_others_upstream;
3880                 int idelta = ibou - _solo_isolated_by_upstream;
3881
3882                 if (idelta < -1) {
3883                         PBD::warning << string_compose (
3884                                         _("Invalid Solo-Isolate propagation: from:%1 new:%2 - old:%3 = delta:%4"),
3885                                         _name, ibou, _solo_isolated_by_upstream, idelta)
3886                                      << endmsg;
3887
3888                 }
3889
3890                 if (_soloed_by_others_upstream) {
3891                         // ignore new connections (they're not propagated)
3892                         if (delta <= 0) {
3893                                 mod_solo_by_others_upstream (delta);
3894                         }
3895                 }
3896
3897                 if (_solo_isolated_by_upstream) {
3898                         // solo-isolate currently only propagates downstream
3899                         if (idelta < 0) {
3900                                 mod_solo_isolated_by_upstream (false);
3901                         }
3902                         // TODO think: mod_solo_isolated_by_upstream() does not take delta arg,
3903                         // but idelta can't be smaller than -1, can it?
3904                         //_solo_isolated_by_upstream = ibou;
3905                 }
3906
3907                 // Session::route_solo_changed  does not propagate indirect solo-changes
3908                 // propagate downstream to tracks
3909                 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3910                         if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3911                                 continue;
3912                         }
3913                         bool sends_only;
3914                         bool does_feed = feeds (*i, &sends_only);
3915                         if (delta <= 0 && does_feed && !sends_only) {
3916                                 (*i)->mod_solo_by_others_upstream (delta);
3917                         }
3918
3919                         if (idelta < 0 && does_feed && !sends_only) {
3920                                 (*i)->mod_solo_isolated_by_upstream (false);
3921                         }
3922                 }
3923         }
3924 }
3925
3926 void
3927 Route::output_change_handler (IOChange change, void * /*src*/)
3928 {
3929         if (_initial_io_setup) {
3930                 return;
3931         }
3932
3933         if ((change.type & IOChange::ConfigurationChanged)) {
3934                 /* This is called with the process lock held if change
3935                    contains ConfigurationChanged
3936                 */
3937                 configure_processors (0);
3938
3939                 if (is_master()) {
3940                         _session.reset_monitor_section();
3941                 }
3942
3943                 io_changed (); /* EMIT SIGNAL */
3944         }
3945
3946         if (_soloed_by_others_downstream) {
3947                 int sbod = 0;
3948                 /* checking all all downstream routes for
3949                  * explicit of implict solo is a rather drastic measure,
3950                  * ideally the input_change_handler() of the other route
3951                  * would propagate the change to us.
3952                  */
3953                 boost::shared_ptr<RouteList> routes = _session.get_routes ();
3954                 if (_output->connected()) {
3955                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3956                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3957                                         continue;
3958                                 }
3959                                 bool sends_only;
3960                                 bool does_feed = direct_feeds_according_to_reality (*i, &sends_only);
3961                                 if (does_feed && !sends_only) {
3962                                         if ((*i)->soloed()) {
3963                                                 ++sbod;
3964                                                 break;
3965                                         }
3966                                 }
3967                         }
3968                 }
3969                 int delta = sbod - _soloed_by_others_downstream;
3970                 if (delta <= 0) {
3971                         // do not allow new connections to change implicit solo (no propagation)
3972                         mod_solo_by_others_downstream (delta);
3973                         // Session::route_solo_changed() does not propagate indirect solo-changes
3974                         // propagate upstream to tracks
3975                         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
3976                                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_auditioner()) {
3977                                         continue;
3978                                 }
3979                                 bool sends_only;
3980                                 bool does_feed = (*i)->feeds (shared_from_this(), &sends_only);
3981                                 if (delta != 0 && does_feed && !sends_only) {
3982                                         (*i)->mod_solo_by_others_downstream (delta);
3983                                 }
3984                         }
3985
3986                 }
3987         }
3988 }
3989
3990 void
3991 Route::sidechain_change_handler (IOChange change, void* src)
3992 {
3993         if (_initial_io_setup || _in_sidechain_setup) {
3994                 return;
3995         }
3996
3997         input_change_handler (change, src);
3998 }
3999
4000 uint32_t
4001 Route::pans_required () const
4002 {
4003         if (n_outputs().n_audio() < 2) {
4004                 return 0;
4005         }
4006
4007         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
4008 }
4009
4010 int
4011 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
4012 {
4013         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4014
4015         if (!lm.locked()) {
4016                 return 0;
4017         }
4018
4019         if (n_outputs().n_total() == 0) {
4020                 return 0;
4021         }
4022
4023         if (!_active || n_inputs() == ChanCount::ZERO)  {
4024                 silence_unlocked (nframes);
4025                 return 0;
4026         }
4027
4028         if (session_state_changing) {
4029                 if (_session.transport_speed() != 0.0f) {
4030                         /* we're rolling but some state is changing (e.g. our diskstream contents)
4031                            so we cannot use them. Be silent till this is over.
4032
4033                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
4034                         */
4035                         silence_unlocked (nframes);
4036                         return 0;
4037                 }
4038                 /* we're really not rolling, so we're either delivery silence or actually
4039                    monitoring, both of which are safe to do while session_state_changing is true.
4040                 */
4041         }
4042
4043         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
4044
4045         fill_buffers_with_input (bufs, _input, nframes);
4046
4047         if (_meter_point == MeterInput) {
4048                 _meter->run (bufs, start_frame, end_frame, nframes, true);
4049         }
4050
4051         _amp->apply_gain_automation (false);
4052         _trim->apply_gain_automation (false);
4053         passthru (bufs, start_frame, end_frame, nframes, 0);
4054
4055         return 0;
4056 }
4057
4058 int
4059 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
4060 {
4061         Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4062         if (!lm.locked()) {
4063                 return 0;
4064         }
4065
4066         if (n_outputs().n_total() == 0) {
4067                 return 0;
4068         }
4069
4070         if (!_active || n_inputs().n_total() == 0) {
4071                 silence_unlocked (nframes);
4072                 return 0;
4073         }
4074
4075         framepos_t unused = 0;
4076
4077         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
4078                 return 0;
4079         }
4080
4081         _silent = false;
4082
4083         BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
4084
4085         fill_buffers_with_input (bufs, _input, nframes);
4086
4087         if (_meter_point == MeterInput) {
4088                 _meter->run (bufs, start_frame, end_frame, nframes, true);
4089         }
4090
4091         passthru (bufs, start_frame, end_frame, nframes, declick);
4092
4093         return 0;
4094 }
4095
4096 int
4097 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
4098 {
4099         silence (nframes);
4100         return 0;
4101 }
4102
4103 void
4104 Route::flush_processors ()
4105 {
4106         /* XXX shouldn't really try to take this lock, since
4107            this is called from the RT audio thread.
4108         */
4109
4110         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4111
4112         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4113                 (*i)->flush ();
4114         }
4115 }
4116
4117 #ifdef __clang__
4118 __attribute__((annotate("realtime")))
4119 #endif
4120 bool
4121 Route::apply_processor_changes_rt ()
4122 {
4123         int emissions = EmitNone;
4124
4125         if (_pending_meter_point != _meter_point) {
4126                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
4127                 if (pwl.locked()) {
4128                         /* meters always have buffers for 'processor_max_streams'
4129                          * they can be re-positioned without re-allocation */
4130                         if (set_meter_point_unlocked()) {
4131                                 emissions |= EmitMeterChanged | EmitMeterVisibilityChange;;
4132                         } else {
4133                                 emissions |= EmitMeterChanged;
4134                         }
4135                 }
4136         }
4137
4138         bool changed = false;
4139
4140         if (g_atomic_int_get (&_pending_process_reorder)) {
4141                 Glib::Threads::RWLock::WriterLock pwl (_processor_lock, Glib::Threads::TRY_LOCK);
4142                 if (pwl.locked()) {
4143                         apply_processor_order (_pending_processor_order);
4144                         setup_invisible_processors ();
4145                         changed = true;
4146                         g_atomic_int_set (&_pending_process_reorder, 0);
4147                         emissions |= EmitRtProcessorChange;
4148                 }
4149         }
4150         if (changed) {
4151                 set_processor_positions ();
4152         }
4153         if (emissions != 0) {
4154                 g_atomic_int_set (&_pending_signals, emissions);
4155                 return true;
4156         }
4157         return (!selfdestruct_sequence.empty ());
4158 }
4159
4160 void
4161 Route::emit_pending_signals ()
4162 {
4163         int sig = g_atomic_int_and (&_pending_signals, 0);
4164         if (sig & EmitMeterChanged) {
4165                 _meter->emit_configuration_changed();
4166                 meter_change (); /* EMIT SIGNAL */
4167                 if (sig & EmitMeterVisibilityChange) {
4168                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
4169                 } else {
4170                 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
4171                 }
4172         }
4173         if (sig & EmitRtProcessorChange) {
4174                 processors_changed (RouteProcessorChange (RouteProcessorChange::RealTimeChange)); /* EMIT SIGNAL */
4175         }
4176
4177         /* this would be a job for the butler.
4178          * Conceptually we should not take processe/processor locks here.
4179          * OTOH its more efficient (less overhead for summoning the butler and
4180          * telling her what do do) and signal emission is called
4181          * directly after the process callback, which decreases the chance
4182          * of x-runs when taking the locks.
4183          */
4184         while (!selfdestruct_sequence.empty ()) {
4185                 Glib::Threads::Mutex::Lock lx (selfdestruct_lock);
4186                 if (selfdestruct_sequence.empty ()) { break; } // re-check with lock
4187                 boost::shared_ptr<Processor> proc = selfdestruct_sequence.back ().lock ();
4188                 selfdestruct_sequence.pop_back ();
4189                 lx.release ();
4190                 if (proc) {
4191                         remove_processor (proc);
4192                 }
4193         }
4194 }
4195
4196 void
4197 Route::set_meter_point (MeterPoint p, bool force)
4198 {
4199         if (_pending_meter_point == p && !force) {
4200                 return;
4201         }
4202
4203         if (force || !AudioEngine::instance()->running()) {
4204                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4205                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4206                 _pending_meter_point = p;
4207                 _meter->emit_configuration_changed();
4208                 meter_change (); /* EMIT SIGNAL */
4209                 if (set_meter_point_unlocked()) {
4210                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, true)); /* EMIT SIGNAL */
4211                 } else {
4212                         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, false)); /* EMIT SIGNAL */
4213                 }
4214         } else {
4215                 _pending_meter_point = p;
4216         }
4217 }
4218
4219
4220 #ifdef __clang__
4221 __attribute__((annotate("realtime")))
4222 #endif
4223 bool
4224 Route::set_meter_point_unlocked ()
4225 {
4226 #ifndef NDEBUG
4227         /* Caller must hold process and processor write lock */
4228         assert (!AudioEngine::instance()->process_lock().trylock());
4229         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
4230         assert (!lm.locked ());
4231 #endif
4232
4233         _meter_point = _pending_meter_point;
4234
4235         bool meter_was_visible_to_user = _meter->display_to_user ();
4236
4237         if (!_custom_meter_position_noted) {
4238                 maybe_note_meter_position ();
4239         }
4240
4241         if (_meter_point != MeterCustom) {
4242
4243                 _meter->set_display_to_user (false);
4244
4245                 setup_invisible_processors ();
4246
4247         } else {
4248                 _meter->set_display_to_user (true);
4249
4250                 /* If we have a previous position for the custom meter, try to put it there */
4251                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
4252                 if (after) {
4253                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
4254                         if (i != _processors.end ()) {
4255                                 _processors.remove (_meter);
4256                                 _processors.insert (i, _meter);
4257                         }
4258                 } else {// at end, right before the mains_out/panner
4259                         _processors.remove (_meter);
4260                         ProcessorList::iterator main = _processors.end();
4261                         _processors.insert (--main, _meter);
4262                 }
4263         }
4264
4265         /* Set up the meter for its new position */
4266
4267         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
4268
4269         ChanCount m_in;
4270
4271         if (loc == _processors.begin()) {
4272                 m_in = _input->n_ports();
4273         } else {
4274                 ProcessorList::iterator before = loc;
4275                 --before;
4276                 m_in = (*before)->output_streams ();
4277         }
4278
4279         _meter->reflect_inputs (m_in);
4280
4281         /* we do not need to reconfigure the processors, because the meter
4282            (a) is always ready to handle processor_max_streams
4283            (b) is always an N-in/N-out processor, and thus moving
4284            it doesn't require any changes to the other processors.
4285         */
4286
4287         /* these should really be done after releasing the lock
4288          * but all those signals are subscribed to with gui_thread()
4289          * so we're safe.
4290          */
4291          return (_meter->display_to_user() != meter_was_visible_to_user);
4292 }
4293
4294 void
4295 Route::listen_position_changed ()
4296 {
4297         {
4298                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4299                 Glib::Threads::RWLock::WriterLock lm (_processor_lock);
4300                 ProcessorState pstate (this);
4301
4302                 if (configure_processors_unlocked (0, &lm)) {
4303                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
4304                         pstate.restore ();
4305                         configure_processors_unlocked (0, &lm); // it worked before we tried to add it ...
4306                         return;
4307                 }
4308         }
4309
4310         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
4311         _session.set_dirty ();
4312 }
4313
4314 boost::shared_ptr<CapturingProcessor>
4315 Route::add_export_point()
4316 {
4317         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4318         if (!_capturing_processor) {
4319                 lm.release();
4320                 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
4321                 Glib::Threads::RWLock::WriterLock lw (_processor_lock);
4322
4323                 _capturing_processor.reset (new CapturingProcessor (_session));
4324                 _capturing_processor->activate ();
4325
4326                 configure_processors_unlocked (0, &lw);
4327
4328         }
4329
4330         return _capturing_processor;
4331 }
4332
4333 framecnt_t
4334 Route::update_signal_latency ()
4335 {
4336         framecnt_t l = _output->user_latency();
4337         framecnt_t lamp = 0;
4338         bool before_amp = true;
4339         framecnt_t ltrim = 0;
4340         bool before_trim = true;
4341
4342         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4343                 if ((*i)->active ()) {
4344                         l += (*i)->signal_latency ();
4345                 }
4346                 if ((*i) == _amp) {
4347                         before_amp = false;
4348                 }
4349                 if ((*i) == _trim) {
4350                         before_amp = false;
4351                 }
4352                 if (before_amp) {
4353                         lamp = l;
4354                 }
4355                 if (before_trim) {
4356                         lamp = l;
4357                 }
4358         }
4359
4360         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
4361
4362         // TODO: (lamp - _signal_latency) to sync to output (read-ahed),  currently _roll_delay shifts this around
4363         _signal_latency_at_amp_position = lamp;
4364         _signal_latency_at_trim_position = ltrim;
4365
4366         if (_signal_latency != l) {
4367                 _signal_latency = l;
4368                 signal_latency_changed (); /* EMIT SIGNAL */
4369         }
4370
4371         return _signal_latency;
4372 }
4373
4374 void
4375 Route::set_user_latency (framecnt_t nframes)
4376 {
4377         _output->set_user_latency (nframes);
4378         _session.update_latency_compensation ();
4379 }
4380
4381 void
4382 Route::set_latency_compensation (framecnt_t longest_session_latency)
4383 {
4384         framecnt_t old = _initial_delay;
4385
4386         if (_signal_latency < longest_session_latency) {
4387                 _initial_delay = longest_session_latency - _signal_latency;
4388         } else {
4389                 _initial_delay = 0;
4390         }
4391
4392         DEBUG_TRACE (DEBUG::Latency, string_compose (
4393                              "%1: compensate for maximum latency of %2,"
4394                              "given own latency of %3, using initial delay of %4\n",
4395                              name(), longest_session_latency, _signal_latency, _initial_delay));
4396
4397         if (_initial_delay != old) {
4398                 initial_delay_changed (); /* EMIT SIGNAL */
4399         }
4400
4401         if (_session.transport_stopped()) {
4402                 _roll_delay = _initial_delay;
4403         }
4404 }
4405
4406 void
4407 Route::set_block_size (pframes_t nframes)
4408 {
4409         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4410                 (*i)->set_block_size (nframes);
4411         }
4412
4413         _session.ensure_buffers (n_process_buffers ());
4414 }
4415
4416 void
4417 Route::protect_automation ()
4418 {
4419         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
4420                 (*i)->protect_automation();
4421 }
4422
4423 /** @param declick 1 to set a pending declick fade-in,
4424  *                -1 to set a pending declick fade-out
4425  */
4426 void
4427 Route::set_pending_declick (int declick)
4428 {
4429         if (_declickable) {
4430                 /* this call is not allowed to turn off a pending declick */
4431                 if (declick) {
4432                         _pending_declick = declick;
4433                 }
4434         } else {
4435                 _pending_declick = 0;
4436         }
4437 }
4438
4439 /** Shift automation forwards from a particular place, thereby inserting time.
4440  *  Adds undo commands for any shifts that are performed.
4441  *
4442  * @param pos Position to start shifting from.
4443  * @param frames Amount to shift forwards by.
4444  */
4445
4446 void
4447 Route::shift (framepos_t pos, framecnt_t frames)
4448 {
4449         /* gain automation */
4450         {
4451                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
4452
4453                 XMLNode &before = gc->alist()->get_state ();
4454                 gc->alist()->shift (pos, frames);
4455                 XMLNode &after = gc->alist()->get_state ();
4456                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
4457         }
4458
4459         /* gain automation */
4460         {
4461                 boost::shared_ptr<AutomationControl> gc = _trim->gain_control();
4462
4463                 XMLNode &before = gc->alist()->get_state ();
4464                 gc->alist()->shift (pos, frames);
4465                 XMLNode &after = gc->alist()->get_state ();
4466                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
4467         }
4468
4469         // TODO mute automation ??
4470
4471         /* pan automation */
4472         if (_pannable) {
4473                 ControlSet::Controls& c (_pannable->controls());
4474
4475                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
4476                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
4477                         if (pc) {
4478                                 boost::shared_ptr<AutomationList> al = pc->alist();
4479                                 XMLNode& before = al->get_state ();
4480                                 al->shift (pos, frames);
4481                                 XMLNode& after = al->get_state ();
4482                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4483                         }
4484                 }
4485         }
4486
4487         /* redirect automation */
4488         {
4489                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4490                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
4491
4492                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
4493
4494                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
4495                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
4496                                 if (ac) {
4497                                         boost::shared_ptr<AutomationList> al = ac->alist();
4498                                         XMLNode &before = al->get_state ();
4499                                         al->shift (pos, frames);
4500                                         XMLNode &after = al->get_state ();
4501                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
4502                                 }
4503                         }
4504                 }
4505         }
4506 }
4507
4508 void
4509 Route::set_plugin_state_dir (boost::weak_ptr<Processor> p, const std::string& d)
4510 {
4511         boost::shared_ptr<Processor> processor (p.lock ());
4512         boost::shared_ptr<PluginInsert> pi  = boost::dynamic_pointer_cast<PluginInsert> (processor);
4513         if (!pi) {
4514                 return;
4515         }
4516         pi->set_state_dir (d);
4517 }
4518
4519 int
4520 Route::save_as_template (const string& path, const string& name)
4521 {
4522         std::string state_dir = path.substr (0, path.find_last_of ('.')); // strip template_suffix
4523         PBD::Unwinder<std::string> uw (_session._template_state_dir, state_dir);
4524
4525         XMLNode& node (state (false));
4526
4527         XMLTree tree;
4528
4529         IO::set_name_in_state (*node.children().front(), name);
4530
4531         tree.set_root (&node);
4532
4533         /* return zero on success, non-zero otherwise */
4534         return !tree.write (path.c_str());
4535 }
4536
4537
4538 bool
4539 Route::set_name (const string& str)
4540 {
4541         if (str == name()) {
4542                 return true;
4543         }
4544
4545         string name = Route::ensure_track_or_route_name (str, _session);
4546         SessionObject::set_name (name);
4547
4548         bool ret = (_input->set_name(name) && _output->set_name(name));
4549
4550         if (ret) {
4551                 /* rename the main outs. Leave other IO processors
4552                  * with whatever name they already have, because its
4553                  * just fine as it is (it will not contain the route
4554                  * name if its a port insert, port send or port return).
4555                  */
4556
4557                 if (_main_outs) {
4558                         if (_main_outs->set_name (name)) {
4559                                 /* XXX returning false here is stupid because
4560                                    we already changed the route name.
4561                                 */
4562                                 return false;
4563                         }
4564                 }
4565         }
4566
4567         return ret;
4568 }
4569
4570 /** Set the name of a route in an XML description.
4571  *  @param node XML <Route> node to set the name in.
4572  *  @param name New name.
4573  */
4574 void
4575 Route::set_name_in_state (XMLNode& node, string const & name, bool rename_playlist)
4576 {
4577         node.add_property (X_("name"), name);
4578
4579         XMLNodeList children = node.children();
4580         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
4581
4582                 if ((*i)->name() == X_("IO")) {
4583
4584                         IO::set_name_in_state (**i, name);
4585
4586                 } else if ((*i)->name() == X_("Processor")) {
4587
4588                         XMLProperty* role = (*i)->property (X_("role"));
4589                         if (role && role->value() == X_("Main")) {
4590                                 (*i)->add_property (X_("name"), name);
4591                         }
4592
4593                 } else if ((*i)->name() == X_("Diskstream")) {
4594
4595                         if (rename_playlist) {
4596                                 (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
4597                         }
4598                         (*i)->add_property (X_("name"), name);
4599
4600                 }
4601         }
4602 }
4603
4604 boost::shared_ptr<Send>
4605 Route::internal_send_for (boost::shared_ptr<const Route> target) const
4606 {
4607         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4608
4609         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4610                 boost::shared_ptr<InternalSend> send;
4611
4612                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
4613                         if (send->target_route() == target) {
4614                                 return send;
4615                         }
4616                 }
4617         }
4618
4619         return boost::shared_ptr<Send>();
4620 }
4621
4622 /** @param c Audio channel index.
4623  *  @param yn true to invert phase, otherwise false.
4624  */
4625 void
4626 Route::set_phase_invert (uint32_t c, bool yn)
4627 {
4628         if (_phase_invert[c] != yn) {
4629                 _phase_invert[c] = yn;
4630                 phase_invert_changed (); /* EMIT SIGNAL */
4631                 _phase_control->Changed(); /* EMIT SIGNAL */
4632                 _session.set_dirty ();
4633         }
4634 }
4635
4636 void
4637 Route::set_phase_invert (boost::dynamic_bitset<> p)
4638 {
4639         if (_phase_invert != p) {
4640                 _phase_invert = p;
4641                 phase_invert_changed (); /* EMIT SIGNAL */
4642                 _session.set_dirty ();
4643         }
4644 }
4645
4646 bool
4647 Route::phase_invert (uint32_t c) const
4648 {
4649         return _phase_invert[c];
4650 }
4651
4652 boost::dynamic_bitset<>
4653 Route::phase_invert () const
4654 {
4655         return _phase_invert;
4656 }
4657
4658 void
4659 Route::set_denormal_protection (bool yn)
4660 {
4661         if (_denormal_protection != yn) {
4662                 _denormal_protection = yn;
4663                 denormal_protection_changed (); /* EMIT SIGNAL */
4664         }
4665 }
4666
4667 bool
4668 Route::denormal_protection () const
4669 {
4670         return _denormal_protection;
4671 }
4672
4673 void
4674 Route::set_active (bool yn, void* src)
4675 {
4676         if (_session.transport_rolling()) {
4677                 return;
4678         }
4679
4680         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
4681                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
4682                 return;
4683         }
4684
4685         if (_active != yn) {
4686                 _active = yn;
4687                 _input->set_active (yn);
4688                 _output->set_active (yn);
4689                 active_changed (); // EMIT SIGNAL
4690                 _session.set_dirty ();
4691         }
4692 }
4693
4694 boost::shared_ptr<Pannable>
4695 Route::pannable() const
4696 {
4697         return _pannable;
4698 }
4699
4700 boost::shared_ptr<Panner>
4701 Route::panner() const
4702 {
4703         /* may be null ! */
4704         return _main_outs->panner_shell()->panner();
4705 }
4706
4707 boost::shared_ptr<PannerShell>
4708 Route::panner_shell() const
4709 {
4710         return _main_outs->panner_shell();
4711 }
4712
4713 boost::shared_ptr<GainControl>
4714 Route::gain_control() const
4715 {
4716         return _gain_control;
4717 }
4718
4719 boost::shared_ptr<GainControl>
4720 Route::trim_control() const
4721 {
4722         return _trim_control;
4723 }
4724
4725 boost::shared_ptr<Route::PhaseControllable>
4726 Route::phase_control() const
4727 {
4728         if (phase_invert().size()) {
4729                 return _phase_control;
4730         } else {
4731                 return boost::shared_ptr<PhaseControllable>();
4732         }
4733 }
4734
4735 boost::shared_ptr<AutomationControl>
4736 Route::get_control (const Evoral::Parameter& param)
4737 {
4738         /* either we own the control or .... */
4739
4740         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
4741
4742         if (!c) {
4743
4744                 /* maybe one of our processors does or ... */
4745
4746                 Glib::Threads::RWLock::ReaderLock rm (_processor_lock);
4747                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4748                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
4749                                 break;
4750                         }
4751                 }
4752         }
4753
4754         if (!c) {
4755
4756                 /* nobody does so we'll make a new one */
4757
4758                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
4759                 add_control(c);
4760         }
4761
4762         return c;
4763 }
4764
4765 boost::shared_ptr<Processor>
4766 Route::nth_plugin (uint32_t n) const
4767 {
4768         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4769         ProcessorList::const_iterator i;
4770
4771         for (i = _processors.begin(); i != _processors.end(); ++i) {
4772                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
4773                         if (n-- == 0) {
4774                                 return *i;
4775                         }
4776                 }
4777         }
4778
4779         return boost::shared_ptr<Processor> ();
4780 }
4781
4782 boost::shared_ptr<Processor>
4783 Route::nth_send (uint32_t n) const
4784 {
4785         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4786         ProcessorList::const_iterator i;
4787
4788         for (i = _processors.begin(); i != _processors.end(); ++i) {
4789                 if (boost::dynamic_pointer_cast<Send> (*i)) {
4790
4791                         if ((*i)->name().find (_("Monitor")) == 0) {
4792                                 /* send to monitor section is not considered
4793                                    to be an accessible send.
4794                                 */
4795                                 continue;
4796                         }
4797
4798                         if (n-- == 0) {
4799                                 return *i;
4800                         }
4801                 }
4802         }
4803
4804         return boost::shared_ptr<Processor> ();
4805 }
4806
4807 bool
4808 Route::has_io_processor_named (const string& name)
4809 {
4810         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4811         ProcessorList::iterator i;
4812
4813         for (i = _processors.begin(); i != _processors.end(); ++i) {
4814                 if (boost::dynamic_pointer_cast<Send> (*i) ||
4815                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
4816                         if ((*i)->name() == name) {
4817                                 return true;
4818                         }
4819                 }
4820         }
4821
4822         return false;
4823 }
4824
4825 MuteMaster::MutePoint
4826 Route::mute_points () const
4827 {
4828         return _mute_master->mute_points ();
4829 }
4830
4831 void
4832 Route::set_processor_positions ()
4833 {
4834         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4835
4836         bool had_amp = false;
4837         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4838                 (*i)->set_pre_fader (!had_amp);
4839                 if (*i == _amp) {
4840                         had_amp = true;
4841                 }
4842         }
4843 }
4844
4845 /** Called when there is a proposed change to the input port count */
4846 bool
4847 Route::input_port_count_changing (ChanCount to)
4848 {
4849         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
4850         if (c.empty()) {
4851                 /* The processors cannot be configured with the new input arrangement, so
4852                    block the change.
4853                 */
4854                 return true;
4855         }
4856
4857         /* The change is ok */
4858         return false;
4859 }
4860
4861 /** Called when there is a proposed change to the output port count */
4862 bool
4863 Route::output_port_count_changing (ChanCount to)
4864 {
4865         if (_strict_io && !_in_configure_processors) {
4866                 return true;
4867         }
4868         for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
4869                 if (processor_out_streams.get(*t) > to.get(*t)) {
4870                         return true;
4871                 }
4872         }
4873         /* The change is ok */
4874         return false;
4875 }
4876
4877 list<string>
4878 Route::unknown_processors () const
4879 {
4880         list<string> p;
4881
4882         if (_session.get_disable_all_loaded_plugins ()) {
4883                 // Do not list "missing plugins" if they are explicitly disabled
4884                 return p;
4885         }
4886
4887         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
4888         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4889                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
4890                         p.push_back ((*i)->name ());
4891                 }
4892         }
4893
4894         return p;
4895 }
4896
4897
4898 framecnt_t
4899 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
4900 {
4901         /* we assume that all our input ports feed all our output ports. its not
4902            universally true, but the alternative is way too corner-case to worry about.
4903         */
4904
4905         LatencyRange all_connections;
4906
4907         if (from.empty()) {
4908                 all_connections.min = 0;
4909                 all_connections.max = 0;
4910         } else {
4911                 all_connections.min = ~((pframes_t) 0);
4912                 all_connections.max = 0;
4913
4914                 /* iterate over all "from" ports and determine the latency range for all of their
4915                    connections to the "outside" (outside of this Route).
4916                 */
4917
4918                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4919
4920                         LatencyRange range;
4921
4922                         p->get_connected_latency_range (range, playback);
4923
4924                         all_connections.min = min (all_connections.min, range.min);
4925                         all_connections.max = max (all_connections.max, range.max);
4926                 }
4927         }
4928
4929         /* set the "from" port latencies to the max/min range of all their connections */
4930
4931         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
4932                 p->set_private_latency_range (all_connections, playback);
4933         }
4934
4935         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
4936
4937         all_connections.min += our_latency;
4938         all_connections.max += our_latency;
4939
4940         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
4941                 p->set_private_latency_range (all_connections, playback);
4942         }
4943
4944         return all_connections.max;
4945 }
4946
4947 framecnt_t
4948 Route::set_private_port_latencies (bool playback) const
4949 {
4950         framecnt_t own_latency = 0;
4951
4952         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
4953            OR LATENCY CALLBACK.
4954
4955            This is called (early) from the latency callback. It computes the REAL
4956            latency associated with each port and stores the result as the "private"
4957            latency of the port. A later call to Route::set_public_port_latencies()
4958            sets all ports to the same value to reflect the fact that we do latency
4959            compensation and so all signals are delayed by the same amount as they
4960            flow through ardour.
4961         */
4962
4963         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4964                 if ((*i)->active ()) {
4965                         own_latency += (*i)->signal_latency ();
4966                 }
4967         }
4968
4969         if (playback) {
4970                 /* playback: propagate latency from "outside the route" to outputs to inputs */
4971                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
4972         } else {
4973                 /* capture: propagate latency from "outside the route" to inputs to outputs */
4974                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
4975         }
4976 }
4977
4978 void
4979 Route::set_public_port_latencies (framecnt_t value, bool playback) const
4980 {
4981         /* this is called to set the JACK-visible port latencies, which take
4982            latency compensation into account.
4983         */
4984
4985         LatencyRange range;
4986
4987         range.min = value;
4988         range.max = value;
4989
4990         {
4991                 const PortSet& ports (_input->ports());
4992                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
4993                         p->set_public_latency_range (range, playback);
4994                 }
4995         }
4996
4997         {
4998                 const PortSet& ports (_output->ports());
4999                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
5000                         p->set_public_latency_range (range, playback);
5001                 }
5002         }
5003 }
5004
5005 /** Put the invisible processors in the right place in _processors.
5006  *  Must be called with a writer lock on _processor_lock held.
5007  */
5008 #ifdef __clang__
5009 __attribute__((annotate("realtime")))
5010 #endif
5011 void
5012 Route::setup_invisible_processors ()
5013 {
5014 #ifndef NDEBUG
5015         Glib::Threads::RWLock::WriterLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
5016         assert (!lm.locked ());
5017 #endif
5018
5019         if (!_main_outs) {
5020                 /* too early to be doing this stuff */
5021                 return;
5022         }
5023
5024         /* we'll build this new list here and then use it
5025          *
5026          * TODO put the ProcessorList is on the stack for RT-safety.
5027          */
5028
5029         ProcessorList new_processors;
5030
5031         /* find visible processors */
5032
5033         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5034                 if ((*i)->display_to_user ()) {
5035                         new_processors.push_back (*i);
5036                 }
5037         }
5038
5039         /* find the amp */
5040
5041         ProcessorList::iterator amp = new_processors.begin ();
5042         while (amp != new_processors.end() && *amp != _amp) {
5043                 ++amp;
5044         }
5045
5046         assert (amp != new_processors.end ());
5047
5048         /* and the processor after the amp */
5049
5050         ProcessorList::iterator after_amp = amp;
5051         ++after_amp;
5052
5053         /* METER */
5054
5055         if (_meter) {
5056                 switch (_meter_point) {
5057                 case MeterInput:
5058                         assert (!_meter->display_to_user ());
5059                         new_processors.push_front (_meter);
5060                         break;
5061                 case MeterPreFader:
5062                         assert (!_meter->display_to_user ());
5063                         new_processors.insert (amp, _meter);
5064                         break;
5065                 case MeterPostFader:
5066                         /* do nothing here */
5067                         break;
5068                 case MeterOutput:
5069                         /* do nothing here */
5070                         break;
5071                 case MeterCustom:
5072                         /* the meter is visible, so we don't touch it here */
5073                         break;
5074                 }
5075         }
5076
5077         /* MAIN OUTS */
5078
5079         assert (_main_outs);
5080         assert (!_main_outs->display_to_user ());
5081         new_processors.push_back (_main_outs);
5082
5083         /* iterator for the main outs */
5084
5085         ProcessorList::iterator main = new_processors.end();
5086         --main;
5087
5088         /* OUTPUT METERING */
5089
5090         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
5091                 assert (!_meter->display_to_user ());
5092
5093                 /* add the processor just before or just after the main outs */
5094
5095                 ProcessorList::iterator meter_point = main;
5096
5097                 if (_meter_point == MeterOutput) {
5098                         ++meter_point;
5099                 }
5100                 new_processors.insert (meter_point, _meter);
5101         }
5102
5103         /* MONITOR SEND */
5104
5105         if (_monitor_send && !is_monitor ()) {
5106                 assert (!_monitor_send->display_to_user ());
5107                 switch (Config->get_listen_position ()) {
5108                 case PreFaderListen:
5109                         switch (Config->get_pfl_position ()) {
5110                         case PFLFromBeforeProcessors:
5111                                 new_processors.push_front (_monitor_send);
5112                                 break;
5113                         case PFLFromAfterProcessors:
5114                                 new_processors.insert (amp, _monitor_send);
5115                                 break;
5116                         }
5117                         _monitor_send->set_can_pan (false);
5118                         break;
5119                 case AfterFaderListen:
5120                         switch (Config->get_afl_position ()) {
5121                         case AFLFromBeforeProcessors:
5122                                 new_processors.insert (after_amp, _monitor_send);
5123                                 break;
5124                         case AFLFromAfterProcessors:
5125                                 new_processors.insert (new_processors.end(), _monitor_send);
5126                                 break;
5127                         }
5128                         _monitor_send->set_can_pan (true);
5129                         break;
5130                 }
5131         }
5132
5133 #if 0 // not used - just yet
5134         if (!is_master() && !is_monitor() && !is_auditioner()) {
5135                 new_processors.push_front (_delayline);
5136         }
5137 #endif
5138
5139         /* MONITOR CONTROL */
5140
5141         if (_monitor_control && is_monitor ()) {
5142                 assert (!_monitor_control->display_to_user ());
5143                 new_processors.insert (amp, _monitor_control);
5144         }
5145
5146         /* INTERNAL RETURN */
5147
5148         /* doing this here means that any monitor control will come just after
5149            the return.
5150         */
5151
5152         if (_intreturn) {
5153                 assert (!_intreturn->display_to_user ());
5154                 new_processors.push_front (_intreturn);
5155         }
5156
5157         if (_trim && _trim->active()) {
5158                 assert (!_trim->display_to_user ());
5159                 new_processors.push_front (_trim);
5160         }
5161         /* EXPORT PROCESSOR */
5162
5163         if (_capturing_processor) {
5164                 assert (!_capturing_processor->display_to_user ());
5165                 new_processors.push_front (_capturing_processor);
5166         }
5167
5168         _processors = new_processors;
5169
5170         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5171                 if (!(*i)->display_to_user () && !(*i)->active () && (*i) != _monitor_send) {
5172                         (*i)->activate ();
5173                 }
5174         }
5175
5176         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
5177         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5178                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
5179         }
5180 }
5181
5182 void
5183 Route::unpan ()
5184 {
5185         Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
5186         Glib::Threads::RWLock::ReaderLock lp (_processor_lock);
5187
5188         _pannable.reset ();
5189
5190         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5191                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
5192                 if (d) {
5193                         d->unpan ();
5194                 }
5195         }
5196 }
5197
5198 /** If the meter point is `Custom', make a note of where the meter is.
5199  *  This is so that if the meter point is subsequently set to something else,
5200  *  and then back to custom, we can put the meter back where it was last time
5201  *  custom was enabled.
5202  *
5203  *  Must be called with the _processor_lock held.
5204  */
5205 void
5206 Route::maybe_note_meter_position ()
5207 {
5208         if (_meter_point != MeterCustom) {
5209                 return;
5210         }
5211
5212         _custom_meter_position_noted = true;
5213         /* custom meter points range from after trim to before panner/main_outs
5214          * this is a limitation by the current processor UI
5215          */
5216         bool seen_trim = false;
5217         _processor_after_last_custom_meter.reset();
5218         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5219                 if ((*i) == _trim) {
5220                         seen_trim = true;
5221                 }
5222                 if ((*i) == _main_outs) {
5223                         _processor_after_last_custom_meter = *i;
5224                         break;
5225                 }
5226                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
5227                         if (!seen_trim) {
5228                                 _processor_after_last_custom_meter = _trim;
5229                         } else {
5230                                 ProcessorList::iterator j = i;
5231                                 ++j;
5232                                 assert(j != _processors.end ()); // main_outs should be before
5233                                 _processor_after_last_custom_meter = *j;
5234                         }
5235                         break;
5236                 }
5237         }
5238         assert(_processor_after_last_custom_meter.lock());
5239 }
5240
5241 boost::shared_ptr<Processor>
5242 Route::processor_by_id (PBD::ID id) const
5243 {
5244         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5245         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5246                 if ((*i)->id() == id) {
5247                         return *i;
5248                 }
5249         }
5250
5251         return boost::shared_ptr<Processor> ();
5252 }
5253
5254 /** @return the monitoring state, or in other words what data we are pushing
5255  *  into the route (data from the inputs, data from disk or silence)
5256  */
5257 MonitorState
5258 Route::monitoring_state () const
5259 {
5260         return MonitoringInput;
5261 }
5262
5263 /** @return what we should be metering; either the data coming from the input
5264  *  IO or the data that is flowing through the route.
5265  */
5266 MeterState
5267 Route::metering_state () const
5268 {
5269         return MeteringRoute;
5270 }
5271
5272 bool
5273 Route::has_external_redirects () const
5274 {
5275         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5276
5277                 /* ignore inactive processors and obviously ignore the main
5278                  * outs since everything has them and we don't care.
5279                  */
5280
5281                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
5282                         return true;;
5283                 }
5284         }
5285
5286         return false;
5287 }
5288
5289 boost::shared_ptr<Processor>
5290 Route::the_instrument () const
5291 {
5292         Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5293         return the_instrument_unlocked ();
5294 }
5295
5296 boost::shared_ptr<Processor>
5297 Route::the_instrument_unlocked () const
5298 {
5299         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
5300                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
5301                         if ((*i)->input_streams().n_midi() > 0 &&
5302                             (*i)->output_streams().n_audio() > 0) {
5303                                 return (*i);
5304                         }
5305                 }
5306         }
5307         return boost::shared_ptr<Processor>();
5308 }
5309
5310
5311
5312 void
5313 Route::non_realtime_locate (framepos_t pos)
5314 {
5315         if (_pannable) {
5316                 _pannable->transport_located (pos);
5317         }
5318
5319         if (_delayline.get()) {
5320                 _delayline.get()->flush();
5321         }
5322
5323         {
5324                 //Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
5325                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
5326
5327                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
5328                         (*i)->transport_located (pos);
5329                 }
5330         }
5331         _roll_delay = _initial_delay;
5332 }
5333
5334 void
5335 Route::fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes)
5336 {
5337         size_t n_buffers;
5338         size_t i;
5339
5340         /* MIDI
5341          *
5342          * We don't currently mix MIDI input together, so we don't need the
5343          * complex logic of the audio case.
5344          */
5345
5346         n_buffers = bufs.count().n_midi ();
5347
5348         for (i = 0; i < n_buffers; ++i) {
5349
5350                 boost::shared_ptr<MidiPort> source_port = io->midi (i);
5351                 MidiBuffer& buf (bufs.get_midi (i));
5352
5353                 if (source_port) {
5354                         buf.copy (source_port->get_midi_buffer(nframes));
5355                 } else {
5356                         buf.silence (nframes);
5357                 }
5358         }
5359
5360         /* AUDIO */
5361
5362         n_buffers = bufs.count().n_audio();
5363
5364         size_t n_ports = io->n_ports().n_audio();
5365         float scaling = 1.0f;
5366
5367         if (n_ports > n_buffers) {
5368                 scaling = ((float) n_buffers) / n_ports;
5369         }
5370
5371         for (i = 0; i < n_ports; ++i) {
5372
5373                 /* if there are more ports than buffers, map them onto buffers
5374                  * in a round-robin fashion
5375                  */
5376
5377                 boost::shared_ptr<AudioPort> source_port = io->audio (i);
5378                 AudioBuffer& buf (bufs.get_audio (i%n_buffers));
5379
5380
5381                 if (i < n_buffers) {
5382
5383                         /* first time through just copy a channel into
5384                            the output buffer.
5385                         */
5386
5387                         buf.read_from (source_port->get_audio_buffer (nframes), nframes);
5388
5389                         if (scaling != 1.0f) {
5390                                 buf.apply_gain (scaling, nframes);
5391                         }
5392
5393                 } else {
5394
5395                         /* on subsequent times around, merge data from
5396                          * the port with what is already there
5397                          */
5398
5399                         if (scaling != 1.0f) {
5400                                 buf.accumulate_with_gain_from (source_port->get_audio_buffer (nframes), nframes, 0, scaling);
5401                         } else {
5402                                 buf.accumulate_from (source_port->get_audio_buffer (nframes), nframes);
5403                         }
5404                 }
5405         }
5406
5407         /* silence any remaining buffers */
5408
5409         for (; i < n_buffers; ++i) {
5410                 AudioBuffer& buf (bufs.get_audio (i));
5411                 buf.silence (nframes);
5412         }
5413
5414         /* establish the initial setup of the buffer set, reflecting what was
5415            copied into it. unless, of course, we are the auditioner, in which
5416            case nothing was fed into it from the inputs at all.
5417         */
5418
5419         if (!is_auditioner()) {
5420                 bufs.set_count (io->n_ports());
5421         }
5422 }
5423
5424 boost::shared_ptr<AutomationControl>
5425 Route::pan_azimuth_control() const
5426 {
5427 #ifdef MIXBUS
5428         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5429         if (!plug) {
5430                 return boost::shared_ptr<AutomationControl>();
5431         }
5432         const uint32_t port_channel_post_pan = 2; // gtk2_ardour/mixbus_ports.h
5433         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_pan)));
5434 #else
5435         if (!_pannable || !panner()) {
5436                 return boost::shared_ptr<AutomationControl>();
5437         }
5438         return _pannable->pan_azimuth_control;
5439 #endif
5440 }
5441
5442 boost::shared_ptr<AutomationControl>
5443 Route::pan_elevation_control() const
5444 {
5445         if (Profile->get_mixbus() || !_pannable || !panner()) {
5446                 return boost::shared_ptr<AutomationControl>();
5447         }
5448
5449         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5450
5451         if (c.find (PanElevationAutomation) != c.end()) {
5452                 return _pannable->pan_elevation_control;
5453         } else {
5454                 return boost::shared_ptr<AutomationControl>();
5455         }
5456 }
5457 boost::shared_ptr<AutomationControl>
5458 Route::pan_width_control() const
5459 {
5460         if (Profile->get_mixbus() || !_pannable || !panner()) {
5461                 return boost::shared_ptr<AutomationControl>();
5462         }
5463
5464         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5465
5466         if (c.find (PanWidthAutomation) != c.end()) {
5467                 return _pannable->pan_width_control;
5468         } else {
5469                 return boost::shared_ptr<AutomationControl>();
5470         }
5471 }
5472 boost::shared_ptr<AutomationControl>
5473 Route::pan_frontback_control() const
5474 {
5475         if (Profile->get_mixbus() || !_pannable || !panner()) {
5476                 return boost::shared_ptr<AutomationControl>();
5477         }
5478
5479         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5480
5481         if (c.find (PanFrontBackAutomation) != c.end()) {
5482                 return _pannable->pan_frontback_control;
5483         } else {
5484                 return boost::shared_ptr<AutomationControl>();
5485         }
5486 }
5487 boost::shared_ptr<AutomationControl>
5488 Route::pan_lfe_control() const
5489 {
5490         if (Profile->get_mixbus() || !_pannable || !panner()) {
5491                 return boost::shared_ptr<AutomationControl>();
5492         }
5493
5494         set<Evoral::Parameter> c = panner()->what_can_be_automated ();
5495
5496         if (c.find (PanLFEAutomation) != c.end()) {
5497                 return _pannable->pan_lfe_control;
5498         } else {
5499                 return boost::shared_ptr<AutomationControl>();
5500         }
5501 }
5502
5503 uint32_t
5504 Route::eq_band_cnt () const
5505 {
5506         if (Profile->get_mixbus()) {
5507                 return 3;
5508         } else {
5509                 /* Ardour has no well-known EQ object */
5510                 return 0;
5511         }
5512 }
5513
5514 boost::shared_ptr<AutomationControl>
5515 Route::eq_gain_controllable (uint32_t band) 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         uint32_t port_number;
5525         switch (band) {
5526         case 0:
5527                 if (is_master() || mixbus()) {
5528                         port_number = 4;
5529                 } else {
5530                         port_number = 8;
5531                 }
5532                 break;
5533         case 1:
5534                 if (is_master() || mixbus()) {
5535                         port_number = 3;
5536                 } else {
5537                         port_number = 6;
5538                 }
5539                 break;
5540         case 2:
5541                 if (is_master() || mixbus()) {
5542                         port_number = 2;
5543                 } else {
5544                         port_number = 4;
5545                 }
5546                 break;
5547         default:
5548                 return boost::shared_ptr<AutomationControl>();
5549         }
5550
5551         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5552 #else
5553         return boost::shared_ptr<AutomationControl>();
5554 #endif
5555 }
5556 boost::shared_ptr<AutomationControl>
5557 Route::eq_freq_controllable (uint32_t band) const
5558 {
5559 #ifdef MIXBUS
5560
5561         if (mixbus() || is_master()) {
5562                 /* no frequency controls for mixbusses or master */
5563                 return boost::shared_ptr<AutomationControl>();
5564         }
5565
5566         boost::shared_ptr<PluginInsert> eq = ch_eq();
5567
5568         if (!eq) {
5569                 return boost::shared_ptr<AutomationControl>();
5570         }
5571
5572         uint32_t port_number;
5573         switch (band) {
5574         case 0:
5575                 port_number = 7;
5576                 break;
5577         case 1:
5578                 port_number = 5;
5579                 break;
5580         case 2:
5581                 port_number = 3;
5582                 break;
5583         default:
5584                 return boost::shared_ptr<AutomationControl>();
5585         }
5586
5587         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_number)));
5588 #else
5589         return boost::shared_ptr<AutomationControl>();
5590 #endif
5591 }
5592
5593 boost::shared_ptr<AutomationControl>
5594 Route::eq_q_controllable (uint32_t band) const
5595 {
5596         return boost::shared_ptr<AutomationControl>();
5597 }
5598
5599 boost::shared_ptr<AutomationControl>
5600 Route::eq_shape_controllable (uint32_t band) const
5601 {
5602         return boost::shared_ptr<AutomationControl>();
5603 }
5604
5605 boost::shared_ptr<AutomationControl>
5606 Route::eq_enable_controllable () const
5607 {
5608 #ifdef MIXBUS
5609         boost::shared_ptr<PluginInsert> eq = ch_eq();
5610
5611         if (!eq) {
5612                 return boost::shared_ptr<AutomationControl>();
5613         }
5614
5615         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5616 #else
5617         return boost::shared_ptr<AutomationControl>();
5618 #endif
5619 }
5620
5621 boost::shared_ptr<AutomationControl>
5622 Route::eq_hpf_controllable () const
5623 {
5624 #ifdef MIXBUS
5625         boost::shared_ptr<PluginInsert> eq = ch_eq();
5626
5627         if (!eq) {
5628                 return boost::shared_ptr<AutomationControl>();
5629         }
5630
5631         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (eq->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5632 #else
5633         return boost::shared_ptr<AutomationControl>();
5634 #endif
5635 }
5636
5637 string
5638 Route::eq_band_name (uint32_t band) const
5639 {
5640         if (Profile->get_mixbus()) {
5641                 switch (band) {
5642                 case 0:
5643                         return _("lo");
5644                 case 1:
5645                         return _("mid");
5646                 case 2:
5647                         return _("hi");
5648                 default:
5649                         return string();
5650                 }
5651         } else {
5652                 return string ();
5653         }
5654 }
5655
5656 boost::shared_ptr<AutomationControl>
5657 Route::comp_enable_controllable () const
5658 {
5659 #ifdef MIXBUS
5660         boost::shared_ptr<PluginInsert> comp = ch_comp();
5661
5662         if (!comp) {
5663                 return boost::shared_ptr<AutomationControl>();
5664         }
5665
5666         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 1)));
5667 #else
5668         return boost::shared_ptr<AutomationControl>();
5669 #endif
5670 }
5671 boost::shared_ptr<AutomationControl>
5672 Route::comp_threshold_controllable () const
5673 {
5674 #ifdef MIXBUS
5675         boost::shared_ptr<PluginInsert> comp = ch_comp();
5676
5677         if (!comp) {
5678                 return boost::shared_ptr<AutomationControl>();
5679         }
5680
5681         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 2)));
5682
5683 #else
5684         return boost::shared_ptr<AutomationControl>();
5685 #endif
5686 }
5687 boost::shared_ptr<AutomationControl>
5688 Route::comp_speed_controllable () const
5689 {
5690 #ifdef MIXBUS
5691         boost::shared_ptr<PluginInsert> comp = ch_comp();
5692
5693         if (!comp) {
5694                 return boost::shared_ptr<AutomationControl>();
5695         }
5696
5697         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 3)));
5698 #else
5699         return boost::shared_ptr<AutomationControl>();
5700 #endif
5701 }
5702 boost::shared_ptr<AutomationControl>
5703 Route::comp_mode_controllable () const
5704 {
5705 #ifdef MIXBUS
5706         boost::shared_ptr<PluginInsert> comp = ch_comp();
5707
5708         if (!comp) {
5709                 return boost::shared_ptr<AutomationControl>();
5710         }
5711
5712         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 4)));
5713 #else
5714         return boost::shared_ptr<AutomationControl>();
5715 #endif
5716 }
5717 boost::shared_ptr<AutomationControl>
5718 Route::comp_makeup_controllable () const
5719 {
5720 #ifdef MIXBUS
5721         boost::shared_ptr<PluginInsert> comp = ch_comp();
5722
5723         if (!comp) {
5724                 return boost::shared_ptr<AutomationControl>();
5725         }
5726
5727         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 5)));
5728 #else
5729         return boost::shared_ptr<AutomationControl>();
5730 #endif
5731 }
5732 boost::shared_ptr<AutomationControl>
5733 Route::comp_redux_controllable () const
5734 {
5735 #ifdef MIXBUS
5736         boost::shared_ptr<PluginInsert> comp = ch_comp();
5737
5738         if (!comp) {
5739                 return boost::shared_ptr<AutomationControl>();
5740         }
5741
5742         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (comp->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, 6)));
5743 #else
5744         return boost::shared_ptr<AutomationControl>();
5745 #endif
5746 }
5747
5748 string
5749 Route::comp_mode_name (uint32_t mode) const
5750 {
5751 #ifdef MIXBUS
5752         switch (mode) {
5753         case 0:
5754                 return _("Leveler");
5755         case 1:
5756                 return _("Compressor");
5757         case 2:
5758                 return _("Limiter");
5759         case 3:
5760                 return mixbus() ? _("Sidechain") : _("Limiter");
5761         }
5762
5763         return _("???");
5764 #else
5765         return _("???");
5766 #endif
5767 }
5768
5769 string
5770 Route::comp_speed_name (uint32_t mode) const
5771 {
5772 #ifdef MIXBUS
5773         switch (mode) {
5774         case 0:
5775                 return _("Attk");
5776         case 1:
5777                 return _("Ratio");
5778         case 2:
5779         case 3:
5780                 return _("Rels");
5781         }
5782         return _("???");
5783 #else
5784         return _("???");
5785 #endif
5786 }
5787
5788 boost::shared_ptr<AutomationControl>
5789 Route::send_level_controllable (uint32_t n) const
5790 {
5791 #ifdef  MIXBUS
5792         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5793         if (!plug) {
5794                 return boost::shared_ptr<AutomationControl>();
5795         }
5796
5797         if (n >= 8) {
5798                 /* no such bus */
5799                 return boost::shared_ptr<AutomationControl>();
5800         }
5801
5802         const uint32_t port_id = port_channel_post_aux1_level + (2*n); // gtk2_ardour/mixbus_ports.h
5803         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5804 #else
5805         boost::shared_ptr<Send> s = boost::dynamic_pointer_cast<Send>(nth_send (n));
5806         if (!s) {
5807                 return boost::shared_ptr<AutomationControl>();
5808         }
5809         return s->gain_control ();
5810 #endif
5811 }
5812
5813 boost::shared_ptr<AutomationControl>
5814 Route::send_enable_controllable (uint32_t n) const
5815 {
5816 #ifdef  MIXBUS
5817         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5818         if (!plug) {
5819                 return boost::shared_ptr<AutomationControl>();
5820         }
5821
5822         if (n >= 8) {
5823                 /* no such bus */
5824                 return boost::shared_ptr<AutomationControl>();
5825         }
5826
5827         const uint32_t port_id = port_channel_post_aux1_asgn + (2*n); // gtk2_ardour/mixbus_ports.h
5828         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_id)));
5829 #else
5830         /* although Ardour sends have enable/disable as part of the Processor
5831            API, it is not exposed as a controllable.
5832
5833            XXX: we should fix this.
5834         */
5835         return boost::shared_ptr<AutomationControl>();
5836 #endif
5837 }
5838
5839 string
5840 Route::send_name (uint32_t n) const
5841 {
5842 #ifdef MIXBUS
5843         if (n >= 8) {
5844                 return string();
5845         }
5846         boost::shared_ptr<Route> r = _session.get_mixbus (n);
5847         assert (r);
5848         return r->name();
5849 #else
5850         boost::shared_ptr<Processor> p = nth_send (n);
5851         if (p) {
5852                 return p->name();
5853         } else {
5854                 return string();
5855         }
5856 #endif
5857 }
5858
5859 boost::shared_ptr<AutomationControl>
5860 Route::master_send_enable_controllable () const
5861 {
5862 #ifdef  MIXBUS
5863         boost::shared_ptr<ARDOUR::PluginInsert> plug = ch_post();
5864         if (!plug) {
5865                 return boost::shared_ptr<AutomationControl>();
5866         }
5867         return boost::dynamic_pointer_cast<ARDOUR::AutomationControl> (plug->control (Evoral::Parameter (ARDOUR::PluginAutomation, 0, port_channel_post_mstr_assign)));
5868 #else
5869         return boost::shared_ptr<AutomationControl>();
5870 #endif
5871 }