libs/ardour/route.cc

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