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