libs/ardour/route.cc

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