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