libs/ardour/route.cc

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