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