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 void
3294 Route::set_pending_declick (int declick)
3295 {
3296         if (_declickable) {
3297                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3298                 if (declick) {
3299                         _pending_declick = declick;
3300                 }
3301                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3302         } else {
3303                 _pending_declick = 0;
3304         }
3305
3306 }
3307
3308 /** Shift automation forwards from a particular place, thereby inserting time.
3309  *  Adds undo commands for any shifts that are performed.
3310  *
3311  * @param pos Position to start shifting from.
3312  * @param frames Amount to shift forwards by.
3313  */
3314
3315 void
3316 Route::shift (framepos_t pos, framecnt_t frames)
3317 {
3318         /* gain automation */
3319         {
3320                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3321
3322                 XMLNode &before = gc->alist()->get_state ();
3323                 gc->alist()->shift (pos, frames);
3324                 XMLNode &after = gc->alist()->get_state ();
3325                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3326         }
3327
3328         /* pan automation */
3329         if (_pannable) {
3330                 ControlSet::Controls& c (_pannable->controls());
3331
3332                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3333                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3334                         if (pc) {
3335                                 boost::shared_ptr<AutomationList> al = pc->alist();
3336                                 XMLNode& before = al->get_state ();
3337                                 al->shift (pos, frames);
3338                                 XMLNode& after = al->get_state ();
3339                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3340                         }
3341                 }
3342         }
3343
3344         /* redirect automation */
3345         {
3346                 Glib::RWLock::ReaderLock lm (_processor_lock);
3347                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3348
3349                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3350
3351                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3352                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3353                                 if (ac) {
3354                                         boost::shared_ptr<AutomationList> al = ac->alist();
3355                                         XMLNode &before = al->get_state ();
3356                                         al->shift (pos, frames);
3357                                         XMLNode &after = al->get_state ();
3358                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3359                                 }
3360                         }
3361                 }
3362         }
3363 }
3364
3365
3366 int
3367 Route::save_as_template (const string& path, const string& name)
3368 {
3369         XMLNode& node (state (false));
3370         XMLTree tree;
3371
3372         IO::set_name_in_state (*node.children().front(), name);
3373
3374         tree.set_root (&node);
3375         return tree.write (path.c_str());
3376 }
3377
3378
3379 bool
3380 Route::set_name (const string& str)
3381 {
3382         bool ret;
3383         string ioproc_name;
3384         string name;
3385
3386         name = Route::ensure_track_or_route_name (str, _session);
3387         SessionObject::set_name (name);
3388
3389         ret = (_input->set_name(name) && _output->set_name(name));
3390
3391         if (ret) {
3392                 /* rename the main outs. Leave other IO processors
3393                  * with whatever name they already have, because its
3394                  * just fine as it is (it will not contain the route
3395                  * name if its a port insert, port send or port return).
3396                  */
3397
3398                 if (_main_outs) {
3399                         if (_main_outs->set_name (name)) {
3400                                 /* XXX returning false here is stupid because
3401                                    we already changed the route name.
3402                                 */
3403                                 return false;
3404                         }
3405                 }
3406         }
3407
3408         return ret;
3409 }
3410
3411 /** Set the name of a route in an XML description.
3412  *  @param node XML <Route> node to set the name in.
3413  *  @param name New name.
3414  */
3415 void
3416 Route::set_name_in_state (XMLNode& node, string const & name)
3417 {
3418         node.add_property (X_("name"), name);
3419
3420         XMLNodeList children = node.children();
3421         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3422
3423                 if ((*i)->name() == X_("IO")) {
3424
3425                         IO::set_name_in_state (**i, name);
3426
3427                 } else if ((*i)->name() == X_("Processor")) {
3428
3429                         XMLProperty* role = (*i)->property (X_("role"));
3430                         if (role && role->value() == X_("Main")) {
3431                                 (*i)->add_property (X_("name"), name);
3432                         }
3433
3434                 } else if ((*i)->name() == X_("Diskstream")) {
3435
3436                         (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3437                         (*i)->add_property (X_("name"), name);
3438
3439                 }
3440         }
3441 }
3442
3443 boost::shared_ptr<Send>
3444 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3445 {
3446         Glib::RWLock::ReaderLock lm (_processor_lock);
3447
3448         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3449                 boost::shared_ptr<InternalSend> send;
3450
3451                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3452                         if (send->target_route() == target) {
3453                                 return send;
3454                         }
3455                 }
3456         }
3457
3458         return boost::shared_ptr<Send>();
3459 }
3460
3461 /** @param c Audio channel index.
3462  *  @param yn true to invert phase, otherwise false.
3463  */
3464 void
3465 Route::set_phase_invert (uint32_t c, bool yn)
3466 {
3467         if (_phase_invert[c] != yn) {
3468                 _phase_invert[c] = yn;
3469                 phase_invert_changed (); /* EMIT SIGNAL */
3470                 _session.set_dirty ();
3471         }
3472 }
3473
3474 void
3475 Route::set_phase_invert (boost::dynamic_bitset<> p)
3476 {
3477         if (_phase_invert != p) {
3478                 _phase_invert = p;
3479                 phase_invert_changed (); /* EMIT SIGNAL */
3480                 _session.set_dirty ();
3481         }
3482 }
3483
3484 bool
3485 Route::phase_invert (uint32_t c) const
3486 {
3487         return _phase_invert[c];
3488 }
3489
3490 boost::dynamic_bitset<>
3491 Route::phase_invert () const
3492 {
3493         return _phase_invert;
3494 }
3495
3496 void
3497 Route::set_denormal_protection (bool yn)
3498 {
3499         if (_denormal_protection != yn) {
3500                 _denormal_protection = yn;
3501                 denormal_protection_changed (); /* EMIT SIGNAL */
3502         }
3503 }
3504
3505 bool
3506 Route::denormal_protection () const
3507 {
3508         return _denormal_protection;
3509 }
3510
3511 void
3512 Route::set_active (bool yn, void* src)
3513 {
3514         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3515                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3516                 return;
3517         }
3518
3519         if (_active != yn) {
3520                 _active = yn;
3521                 _input->set_active (yn);
3522                 _output->set_active (yn);
3523                 active_changed (); // EMIT SIGNAL
3524         }
3525 }
3526
3527 void
3528 Route::meter ()
3529 {
3530         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3531
3532         assert (_meter);
3533
3534         _meter->meter ();
3535
3536         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3537
3538                 boost::shared_ptr<Send> s;
3539                 boost::shared_ptr<Return> r;
3540
3541                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3542                         s->meter()->meter();
3543                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3544                         r->meter()->meter ();
3545                 }
3546         }
3547 }
3548
3549 boost::shared_ptr<Pannable>
3550 Route::pannable() const
3551 {
3552         return _pannable;
3553 }
3554
3555 boost::shared_ptr<Panner>
3556 Route::panner() const
3557 {
3558         /* may be null ! */
3559         return _main_outs->panner_shell()->panner();
3560 }
3561
3562 boost::shared_ptr<PannerShell>
3563 Route::panner_shell() const
3564 {
3565         return _main_outs->panner_shell();
3566 }
3567
3568 boost::shared_ptr<AutomationControl>
3569 Route::gain_control() const
3570 {
3571         return _amp->gain_control();
3572 }
3573
3574 boost::shared_ptr<AutomationControl>
3575 Route::get_control (const Evoral::Parameter& param)
3576 {
3577         /* either we own the control or .... */
3578
3579         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3580
3581         if (!c) {
3582
3583                 /* maybe one of our processors does or ... */
3584
3585                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3586                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3587                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3588                                 break;
3589                         }
3590                 }
3591         }
3592
3593         if (!c) {
3594
3595                 /* nobody does so we'll make a new one */
3596
3597                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3598                 add_control(c);
3599         }
3600
3601         return c;
3602 }
3603
3604 boost::shared_ptr<Processor>
3605 Route::nth_plugin (uint32_t n)
3606 {
3607         Glib::RWLock::ReaderLock lm (_processor_lock);
3608         ProcessorList::iterator i;
3609
3610         for (i = _processors.begin(); i != _processors.end(); ++i) {
3611                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3612                         if (n-- == 0) {
3613                                 return *i;
3614                         }
3615                 }
3616         }
3617
3618         return boost::shared_ptr<Processor> ();
3619 }
3620
3621 boost::shared_ptr<Processor>
3622 Route::nth_send (uint32_t n)
3623 {
3624         Glib::RWLock::ReaderLock lm (_processor_lock);
3625         ProcessorList::iterator i;
3626
3627         for (i = _processors.begin(); i != _processors.end(); ++i) {
3628                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3629                         if (n-- == 0) {
3630                                 return *i;
3631                         }
3632                 }
3633         }
3634
3635         return boost::shared_ptr<Processor> ();
3636 }
3637
3638 bool
3639 Route::has_io_processor_named (const string& name)
3640 {
3641         Glib::RWLock::ReaderLock lm (_processor_lock);
3642         ProcessorList::iterator i;
3643
3644         for (i = _processors.begin(); i != _processors.end(); ++i) {
3645                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3646                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3647                         if ((*i)->name() == name) {
3648                                 return true;
3649                         }
3650                 }
3651         }
3652
3653         return false;
3654 }
3655
3656 MuteMaster::MutePoint
3657 Route::mute_points () const
3658 {
3659         return _mute_master->mute_points ();
3660 }
3661
3662 void
3663 Route::set_processor_positions ()
3664 {
3665         Glib::RWLock::ReaderLock lm (_processor_lock);
3666
3667         bool had_amp = false;
3668         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3669                 (*i)->set_pre_fader (!had_amp);
3670                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3671                         had_amp = true;
3672                 }
3673         }
3674 }
3675
3676 /** Called when there is a proposed change to the input port count */
3677 bool
3678 Route::input_port_count_changing (ChanCount to)
3679 {
3680         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3681         if (c.empty()) {
3682                 /* The processors cannot be configured with the new input arrangement, so
3683                    block the change.
3684                 */
3685                 return true;
3686         }
3687
3688         /* The change is ok */
3689         return false;
3690 }
3691
3692 list<string>
3693 Route::unknown_processors () const
3694 {
3695         list<string> p;
3696
3697         Glib::RWLock::ReaderLock lm (_processor_lock);
3698         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3699                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3700                         p.push_back ((*i)->name ());
3701                 }
3702         }
3703
3704         return p;
3705 }
3706
3707
3708 framecnt_t
3709 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3710 {
3711         /* we assume that all our input ports feed all our output ports. its not
3712            universally true, but the alternative is way too corner-case to worry about.
3713         */
3714
3715         jack_latency_range_t all_connections;
3716
3717         if (from.empty()) {
3718                 all_connections.min = 0;
3719                 all_connections.max = 0;
3720         } else {
3721                 all_connections.min = ~((jack_nframes_t) 0);
3722                 all_connections.max = 0;
3723
3724                 /* iterate over all "from" ports and determine the latency range for all of their
3725                    connections to the "outside" (outside of this Route).
3726                 */
3727
3728                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3729
3730                         jack_latency_range_t range;
3731
3732                         p->get_connected_latency_range (range, playback);
3733
3734                         all_connections.min = min (all_connections.min, range.min);
3735                         all_connections.max = max (all_connections.max, range.max);
3736                 }
3737         }
3738
3739         /* set the "from" port latencies to the max/min range of all their connections */
3740
3741         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3742                 p->set_private_latency_range (all_connections, playback);
3743         }
3744
3745         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3746
3747         all_connections.min += our_latency;
3748         all_connections.max += our_latency;
3749
3750         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3751                 p->set_private_latency_range (all_connections, playback);
3752         }
3753
3754         return all_connections.max;
3755 }
3756
3757 framecnt_t
3758 Route::set_private_port_latencies (bool playback) const
3759 {
3760         framecnt_t own_latency = 0;
3761
3762         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3763            OR LATENCY CALLBACK.
3764
3765            This is called (early) from the latency callback. It computes the REAL
3766            latency associated with each port and stores the result as the "private"
3767            latency of the port. A later call to Route::set_public_port_latencies()
3768            sets all ports to the same value to reflect the fact that we do latency
3769            compensation and so all signals are delayed by the same amount as they
3770            flow through ardour.
3771         */
3772
3773         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3774                 if ((*i)->active ()) {
3775                         own_latency += (*i)->signal_latency ();
3776                 }
3777         }
3778
3779         if (playback) {
3780                 /* playback: propagate latency from "outside the route" to outputs to inputs */
3781                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3782         } else {
3783                 /* capture: propagate latency from "outside the route" to inputs to outputs */
3784                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3785         }
3786 }
3787
3788 void
3789 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3790 {
3791         /* this is called to set the JACK-visible port latencies, which take
3792            latency compensation into account.
3793         */
3794
3795         jack_latency_range_t range;
3796
3797         range.min = value;
3798         range.max = value;
3799
3800         {
3801                 const PortSet& ports (_input->ports());
3802                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3803                         p->set_public_latency_range (range, playback);
3804                 }
3805         }
3806
3807         {
3808                 const PortSet& ports (_output->ports());
3809                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3810                         p->set_public_latency_range (range, playback);
3811                 }
3812         }
3813 }
3814
3815 /** Put the invisible processors in the right place in _processors.
3816  *  Must be called with a writer lock on _processor_lock held.
3817  */
3818 void
3819 Route::setup_invisible_processors ()
3820 {
3821 #ifndef NDEBUG
3822         Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3823         assert (!lm.locked ());
3824 #endif
3825
3826         if (!_main_outs) {
3827                 /* too early to be doing this stuff */
3828                 return;
3829         }
3830
3831         /* we'll build this new list here and then use it */
3832
3833         ProcessorList new_processors;
3834
3835         /* find visible processors */
3836
3837         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3838                 if ((*i)->display_to_user ()) {
3839                         new_processors.push_back (*i);
3840                 }
3841         }
3842
3843         /* find the amp */
3844
3845         ProcessorList::iterator amp = new_processors.begin ();
3846         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3847                 ++amp;
3848         }
3849
3850         assert (amp != _processors.end ());
3851
3852         /* and the processor after the amp */
3853
3854         ProcessorList::iterator after_amp = amp;
3855         ++after_amp;
3856
3857         /* METER */
3858
3859         if (_meter) {
3860                 switch (_meter_point) {
3861                 case MeterInput:
3862                         assert (!_meter->display_to_user ());
3863                         new_processors.push_front (_meter);
3864                         break;
3865                 case MeterPreFader:
3866                         assert (!_meter->display_to_user ());
3867                         new_processors.insert (amp, _meter);
3868                         break;
3869                 case MeterPostFader:
3870                         /* do nothing here */
3871                         break;
3872                 case MeterOutput:
3873                         /* do nothing here */
3874                         break;
3875                 case MeterCustom:
3876                         /* the meter is visible, so we don't touch it here */
3877                         break;
3878                 }
3879         }
3880
3881         /* MAIN OUTS */
3882
3883         assert (_main_outs);
3884         assert (!_main_outs->display_to_user ());
3885         new_processors.push_back (_main_outs);
3886
3887         /* iterator for the main outs */
3888
3889         ProcessorList::iterator main = new_processors.end();
3890         --main;
3891
3892         /* OUTPUT METERING */
3893
3894         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3895                 assert (!_meter->display_to_user ());
3896
3897                 /* add the processor just before or just after the main outs */
3898
3899                 ProcessorList::iterator meter_point = main;
3900
3901                 if (_meter_point == MeterOutput) {
3902                         ++meter_point;
3903                 }
3904                 new_processors.insert (meter_point, _meter);
3905         }
3906
3907         /* MONITOR SEND */
3908
3909         if (_monitor_send && !is_monitor ()) {
3910                 assert (!_monitor_send->display_to_user ());
3911                 if (Config->get_solo_control_is_listen_control()) {
3912                         switch (Config->get_listen_position ()) {
3913                         case PreFaderListen:
3914                                 switch (Config->get_pfl_position ()) {
3915                                 case PFLFromBeforeProcessors:
3916                                         new_processors.push_front (_monitor_send);
3917                                         break;
3918                                 case PFLFromAfterProcessors:
3919                                         new_processors.insert (amp, _monitor_send);
3920                                         break;
3921                                 }
3922                                 _monitor_send->set_can_pan (false);
3923                                 break;
3924                         case AfterFaderListen:
3925                                 switch (Config->get_afl_position ()) {
3926                                 case AFLFromBeforeProcessors:
3927                                         new_processors.insert (after_amp, _monitor_send);
3928                                         break;
3929                                 case AFLFromAfterProcessors:
3930                                         new_processors.insert (new_processors.end(), _monitor_send);
3931                                         break;
3932                                 }
3933                                 _monitor_send->set_can_pan (true);
3934                                 break;
3935                         }
3936                 }  else {
3937                         new_processors.insert (new_processors.end(), _monitor_send);
3938                         _monitor_send->set_can_pan (false);
3939                 }
3940         }
3941
3942         /* MONITOR CONTROL */
3943
3944         if (_monitor_control && is_monitor ()) {
3945                 assert (!_monitor_control->display_to_user ());
3946                 new_processors.push_front (_monitor_control);
3947         }
3948
3949         /* INTERNAL RETURN */
3950
3951         /* doing this here means that any monitor control will come just after
3952            the return.
3953         */
3954
3955         if (_intreturn) {
3956                 assert (!_intreturn->display_to_user ());
3957                 new_processors.push_front (_intreturn);
3958         }
3959
3960         /* EXPORT PROCESSOR */
3961
3962         if (_capturing_processor) {
3963                 assert (!_capturing_processor->display_to_user ());
3964                 new_processors.push_front (_capturing_processor);
3965         }
3966
3967         _processors = new_processors;
3968
3969         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3970         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3971                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3972         }
3973 }
3974
3975 void
3976 Route::unpan ()
3977 {
3978         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3979         Glib::RWLock::ReaderLock lp (_processor_lock);
3980
3981         _pannable.reset ();
3982
3983         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3984                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
3985                 if (d) {
3986                         d->unpan ();
3987                 }
3988         }
3989 }
3990
3991 /** If the meter point is `Custom', make a note of where the meter is.
3992  *  This is so that if the meter point is subsequently set to something else,
3993  *  and then back to custom, we can put the meter back where it was last time
3994  *  custom was enabled.
3995  *
3996  *  Must be called with the _processor_lock held.
3997  */
3998 void
3999 Route::maybe_note_meter_position ()
4000 {
4001         if (_meter_point != MeterCustom) {
4002                 return;
4003         }
4004
4005         _custom_meter_position_noted = true;
4006         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4007                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4008                         ProcessorList::iterator j = i;
4009                         ++j;
4010                         if (j != _processors.end ()) {
4011                                 _processor_after_last_custom_meter = *j;
4012                                 _last_custom_meter_was_at_end = false;
4013                         } else {
4014                                 _last_custom_meter_was_at_end = true;
4015                         }
4016                 }
4017         }
4018 }
4019
4020 boost::shared_ptr<Processor>
4021 Route::processor_by_id (PBD::ID id) const
4022 {
4023         Glib::RWLock::ReaderLock lm (_processor_lock);
4024         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4025                 if ((*i)->id() == id) {
4026                         return *i;
4027                 }
4028         }
4029
4030         return boost::shared_ptr<Processor> ();
4031 }
4032
4033 /** @return the monitoring state, or in other words what data we are pushing
4034  *  into the route (data from the inputs, data from disk or silence)
4035  */
4036 MonitorState
4037 Route::monitoring_state () const
4038 {
4039         return MonitoringInput;
4040 }
4041
4042 /** @return what we should be metering; either the data coming from the input
4043  *  IO or the data that is flowing through the route.
4044  */
4045 MeterState
4046 Route::metering_state () const
4047 {
4048         return MeteringRoute;
4049 }
4050
4051 bool
4052 Route::has_external_redirects () const
4053 {
4054         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4055
4056                 /* ignore inactive processors and obviously ignore the main
4057                  * outs since everything has them and we don't care.
4058                  */
4059
4060                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4061                         return true;;
4062                 }
4063         }
4064
4065         return false;
4066 }
4067
4068 boost::shared_ptr<Processor>
4069 Route::the_instrument () const
4070 {
4071         Glib::RWLock::WriterLock lm (_processor_lock);
4072         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4073                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4074                         if ((*i)->input_streams().n_midi() > 0 &&
4075                             (*i)->output_streams().n_audio() > 0) {
4076                                 return (*i);
4077                         }
4078                 }
4079         }
4080         return boost::shared_ptr<Processor>();
4081 }