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