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