libs/ardour/route.cc

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