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