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