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