libs/ardour/route.cc

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