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