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