libs/ardour/route.cc

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