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