libs/ardour/route.cc

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