libs/ardour/route.cc

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