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         // TODO once the export point can be configured properly, do something smarter here
1386         if (processor == _capturing_processor) {
1387                 _capturing_processor.reset();
1388         }
1389
1390         /* these can never be removed */
1391
1392         if (processor == _amp || processor == _meter || processor == _main_outs) {
1393                 return 0;
1394         }
1395
1396         if (!_session.engine().connected()) {
1397                 return 1;
1398         }
1399
1400         processor_max_streams.reset();
1401
1402         {
1403                 Glib::RWLock::WriterLock lm (_processor_lock);
1404                 ProcessorState pstate (this);
1405
1406                 ProcessorList::iterator i;
1407                 bool removed = false;
1408
1409                 for (i = _processors.begin(); i != _processors.end(); ) {
1410                         if (*i == processor) {
1411
1412                                 /* move along, see failure case for configure_processors()
1413                                    where we may need to reconfigure the processor.
1414                                 */
1415
1416                                 /* stop redirects that send signals to JACK ports
1417                                    from causing noise as a result of no longer being
1418                                    run.
1419                                 */
1420
1421                                 boost::shared_ptr<IOProcessor> iop;
1422
1423                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1424                                         if (iop->input()) {
1425                                                 iop->input()->disconnect (this);
1426                                         }
1427                                         if (iop->output()) {
1428                                                 iop->output()->disconnect (this);
1429                                         }
1430                                 }
1431
1432                                 i = _processors.erase (i);
1433                                 removed = true;
1434                                 break;
1435
1436                         } else {
1437                                 ++i;
1438                         }
1439
1440                         _output->set_user_latency (0);
1441                 }
1442
1443                 if (!removed) {
1444                         /* what? */
1445                         return 1;
1446                 }
1447
1448                 if (need_process_lock) {
1449                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1450
1451                         if (configure_processors_unlocked (err)) {
1452                                 pstate.restore ();
1453                                 /* we know this will work, because it worked before :) */
1454                                 configure_processors_unlocked (0);
1455                                 return -1;
1456                         }
1457                 } else {
1458                         if (configure_processors_unlocked (err)) {
1459                                 pstate.restore ();
1460                                 /* we know this will work, because it worked before :) */
1461                                 configure_processors_unlocked (0);
1462                                 return -1;
1463                         }
1464                 }
1465
1466                 _have_internal_generator = false;
1467
1468                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1469                         boost::shared_ptr<PluginInsert> pi;
1470
1471                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1472                                 if (pi->has_no_inputs ()) {
1473                                         _have_internal_generator = true;
1474                                         break;
1475                                 }
1476                         }
1477                 }
1478         }
1479
1480         reset_instrument_info ();
1481         processor->drop_references ();
1482         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1483         set_processor_positions ();
1484
1485         return 0;
1486 }
1487
1488 int
1489 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1490 {
1491         ProcessorList deleted;
1492
1493         if (!_session.engine().connected()) {
1494                 return 1;
1495         }
1496
1497         processor_max_streams.reset();
1498
1499         {
1500                 Glib::RWLock::WriterLock lm (_processor_lock);
1501                 ProcessorState pstate (this);
1502
1503                 ProcessorList::iterator i;
1504                 boost::shared_ptr<Processor> processor;
1505
1506                 for (i = _processors.begin(); i != _processors.end(); ) {
1507
1508                         processor = *i;
1509
1510                         /* these can never be removed */
1511
1512                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1513                                 ++i;
1514                                 continue;
1515                         }
1516
1517                         /* see if its in the list of processors to delete */
1518
1519                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1520                                 ++i;
1521                                 continue;
1522                         }
1523
1524                         /* stop IOProcessors that send to JACK ports
1525                            from causing noise as a result of no longer being
1526                            run.
1527                         */
1528
1529                         boost::shared_ptr<IOProcessor> iop;
1530
1531                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1532                                 iop->disconnect ();
1533                         }
1534
1535                         deleted.push_back (processor);
1536                         i = _processors.erase (i);
1537                 }
1538
1539                 if (deleted.empty()) {
1540                         /* none of those in the requested list were found */
1541                         return 0;
1542                 }
1543
1544                 _output->set_user_latency (0);
1545
1546                 {
1547                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1548
1549                         if (configure_processors_unlocked (err)) {
1550                                 pstate.restore ();
1551                                 /* we know this will work, because it worked before :) */
1552                                 configure_processors_unlocked (0);
1553                                 return -1;
1554                         }
1555                 }
1556
1557                 _have_internal_generator = false;
1558
1559                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1560                         boost::shared_ptr<PluginInsert> pi;
1561
1562                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1563                                 if (pi->has_no_inputs ()) {
1564                                         _have_internal_generator = true;
1565                                         break;
1566                                 }
1567                         }
1568                 }
1569         }
1570
1571         /* now try to do what we need to so that those that were removed will be deleted */
1572
1573         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1574                 (*i)->drop_references ();
1575         }
1576
1577         reset_instrument_info ();
1578         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1579         set_processor_positions ();
1580
1581         return 0;
1582 }
1583
1584 void
1585 Route::reset_instrument_info ()
1586 {
1587         boost::shared_ptr<Processor> instr = the_instrument();
1588         _instrument_info.set_internal_instrument (instr);
1589 }
1590
1591 /** Caller must hold process lock */
1592 int
1593 Route::configure_processors (ProcessorStreams* err)
1594 {
1595         assert (!AudioEngine::instance()->process_lock().trylock());
1596
1597         if (!_in_configure_processors) {
1598                 Glib::RWLock::WriterLock lm (_processor_lock);
1599                 return configure_processors_unlocked (err);
1600         }
1601
1602         return 0;
1603 }
1604
1605 ChanCount
1606 Route::input_streams () const
1607 {
1608         return _input->n_ports ();
1609 }
1610
1611 list<pair<ChanCount, ChanCount> >
1612 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1613 {
1614         Glib::RWLock::ReaderLock lm (_processor_lock);
1615
1616         return try_configure_processors_unlocked (in, err);
1617 }
1618
1619 list<pair<ChanCount, ChanCount> >
1620 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1621 {
1622         // Check each processor in order to see if we can configure as requested
1623         ChanCount out;
1624         list<pair<ChanCount, ChanCount> > configuration;
1625         uint32_t index = 0;
1626
1627         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1628         DEBUG_TRACE (DEBUG::Processors, "{\n");
1629
1630         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1631
1632                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1633                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1634                         break;
1635                 }
1636
1637                 if ((*p)->can_support_io_configuration(in, out)) {
1638                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1639                         configuration.push_back(make_pair(in, out));
1640                         in = out;
1641                 } else {
1642                         if (err) {
1643                                 err->index = index;
1644                                 err->count = in;
1645                         }
1646                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1647                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1648                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1649                         return list<pair<ChanCount, ChanCount> > ();
1650                 }
1651         }
1652
1653         DEBUG_TRACE (DEBUG::Processors, "}\n");
1654
1655         return configuration;
1656 }
1657
1658 /** Set the input/output configuration of each processor in the processors list.
1659  *  Caller must hold process lock.
1660  *  Return 0 on success, otherwise configuration is impossible.
1661  */
1662 int
1663 Route::configure_processors_unlocked (ProcessorStreams* err)
1664 {
1665         assert (!AudioEngine::instance()->process_lock().trylock());
1666
1667         if (_in_configure_processors) {
1668                 return 0;
1669         }
1670
1671         /* put invisible processors where they should be */
1672         setup_invisible_processors ();
1673
1674         _in_configure_processors = true;
1675
1676         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1677
1678         if (configuration.empty ()) {
1679                 _in_configure_processors = false;
1680                 return -1;
1681         }
1682
1683         ChanCount out;
1684
1685         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1686         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1687
1688                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1689                         break;
1690                 }
1691
1692                 (*p)->configure_io(c->first, c->second);
1693                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1694                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1695                 out = c->second;
1696         }
1697
1698         if (_meter) {
1699                 _meter->reset_max_channels (processor_max_streams);
1700         }
1701
1702         /* make sure we have sufficient scratch buffers to cope with the new processor
1703            configuration
1704         */
1705         _session.ensure_buffers (n_process_buffers ());
1706
1707         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1708
1709         _in_configure_processors = false;
1710         return 0;
1711 }
1712
1713 /** Set all visible processors to a given active state (except Fader, whose state is not changed)
1714  *  @param state New active state for those processors.
1715  */
1716 void
1717 Route::all_visible_processors_active (bool state)
1718 {
1719         Glib::RWLock::ReaderLock lm (_processor_lock);
1720
1721         if (_processors.empty()) {
1722                 return;
1723         }
1724
1725         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1726                 if (!(*i)->display_to_user() || boost::dynamic_pointer_cast<Amp> (*i)) {
1727                         continue;
1728                 }
1729
1730                 if (state) {
1731                         (*i)->activate ();
1732                 } else {
1733                         (*i)->deactivate ();
1734                 }
1735         }
1736
1737         _session.set_dirty ();
1738 }
1739
1740 int
1741 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1742 {
1743         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1744            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1745            processors in the current actual processor list that are hidden. Any visible processors
1746            in the current list but not in "new_order" will be assumed to be deleted.
1747         */
1748
1749         {
1750                 Glib::RWLock::WriterLock lm (_processor_lock);
1751                 ProcessorState pstate (this);
1752
1753                 ProcessorList::iterator oiter;
1754                 ProcessorList::const_iterator niter;
1755                 ProcessorList as_it_will_be;
1756
1757                 oiter = _processors.begin();
1758                 niter = new_order.begin();
1759
1760                 while (niter !=  new_order.end()) {
1761
1762                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1763                            then append it to the temp list.
1764
1765                            Otherwise, see if the next processor in the old list is in the new list. if not,
1766                            its been deleted. If its there, append it to the temp list.
1767                         */
1768
1769                         if (oiter == _processors.end()) {
1770
1771                                 /* no more elements in the old list, so just stick the rest of
1772                                    the new order onto the temp list.
1773                                 */
1774
1775                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1776                                 while (niter != new_order.end()) {
1777                                         ++niter;
1778                                 }
1779                                 break;
1780
1781                         } else {
1782
1783                                 if (!(*oiter)->display_to_user()) {
1784
1785                                         as_it_will_be.push_back (*oiter);
1786
1787                                 } else {
1788
1789                                         /* visible processor: check that its in the new order */
1790
1791                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1792                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1793                                         } else {
1794                                                 /* ignore this one, and add the next item from the new order instead */
1795                                                 as_it_will_be.push_back (*niter);
1796                                                 ++niter;
1797                                         }
1798                                 }
1799
1800                                 /* now remove from old order - its taken care of no matter what */
1801                                 oiter = _processors.erase (oiter);
1802                         }
1803
1804                 }
1805
1806                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1807
1808                 /* If the meter is in a custom position, find it and make a rough note of its position */
1809                 maybe_note_meter_position ();
1810
1811                 {
1812                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1813
1814                         if (configure_processors_unlocked (err)) {
1815                                 pstate.restore ();
1816                                 return -1;
1817                         }
1818                 }
1819         }
1820
1821         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1822         set_processor_positions ();
1823
1824         return 0;
1825 }
1826
1827 XMLNode&
1828 Route::get_state()
1829 {
1830         return state(true);
1831 }
1832
1833 XMLNode&
1834 Route::get_template()
1835 {
1836         return state(false);
1837 }
1838
1839 XMLNode&
1840 Route::state(bool full_state)
1841 {
1842         XMLNode *node = new XMLNode("Route");
1843         ProcessorList::iterator i;
1844         char buf[32];
1845
1846         id().print (buf, sizeof (buf));
1847         node->add_property("id", buf);
1848         node->add_property ("name", _name);
1849         node->add_property("default-type", _default_type.to_string());
1850
1851         if (_flags) {
1852                 node->add_property("flags", enum_2_string (_flags));
1853         }
1854
1855         node->add_property("active", _active?"yes":"no");
1856         string p;
1857         boost::to_string (_phase_invert, p);
1858         node->add_property("phase-invert", p);
1859         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1860         node->add_property("meter-point", enum_2_string (_meter_point));
1861
1862         if (_route_group) {
1863                 node->add_property("route-group", _route_group->name());
1864         }
1865
1866         string order_string;
1867         OrderKeys::iterator x = order_keys.begin();
1868
1869         while (x != order_keys.end()) {
1870                 order_string += string ((*x).first);
1871                 order_string += '=';
1872                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1873                 order_string += buf;
1874
1875                 ++x;
1876
1877                 if (x == order_keys.end()) {
1878                         break;
1879                 }
1880
1881                 order_string += ':';
1882         }
1883         node->add_property ("order-keys", order_string);
1884         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1885         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1886         node->add_property ("soloed-by-upstream", buf);
1887         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1888         node->add_property ("soloed-by-downstream", buf);
1889         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1890         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1891
1892         node->add_child_nocopy (_input->state (full_state));
1893         node->add_child_nocopy (_output->state (full_state));
1894         node->add_child_nocopy (_solo_control->get_state ());
1895         node->add_child_nocopy (_mute_control->get_state ());
1896         node->add_child_nocopy (_mute_master->get_state ());
1897
1898         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1899         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1900         remote_control_node->add_property (X_("id"), buf);
1901         node->add_child_nocopy (*remote_control_node);
1902
1903         if (_comment.length()) {
1904                 XMLNode *cmt = node->add_child ("Comment");
1905                 cmt->add_content (_comment);
1906         }
1907
1908         if (_pannable) {
1909                 node->add_child_nocopy (_pannable->state (full_state));
1910         }
1911
1912         for (i = _processors.begin(); i != _processors.end(); ++i) {
1913                 if (!full_state) {
1914                         /* template save: do not include internal sends functioning as
1915                            aux sends because the chance of the target ID
1916                            in the session where this template is used
1917                            is not very likely.
1918
1919                            similarly, do not save listen sends which connect to
1920                            the monitor section, because these will always be
1921                            added if necessary.
1922                         */
1923                         boost::shared_ptr<InternalSend> is;
1924
1925                         if ((is = boost::dynamic_pointer_cast<InternalSend> (*i)) != 0) {
1926                                 if (is->role() == Delivery::Aux || is->role() == Delivery::Listen) {
1927                                         continue;
1928                                 }
1929                         }
1930                 }
1931                 node->add_child_nocopy((*i)->state (full_state));
1932         }
1933
1934         if (_extra_xml) {
1935                 node->add_child_copy (*_extra_xml);
1936         }
1937
1938         if (_custom_meter_position_noted) {
1939                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
1940                 if (after) {
1941                         after->id().print (buf, sizeof (buf));
1942                         node->add_property (X_("processor-after-last-custom-meter"), buf);
1943                 }
1944
1945                 node->add_property (X_("last-custom-meter-was-at-end"), _last_custom_meter_was_at_end ? "yes" : "no");
1946         }
1947
1948         return *node;
1949 }
1950
1951 int
1952 Route::set_state (const XMLNode& node, int version)
1953 {
1954         if (version < 3000) {
1955                 return set_state_2X (node, version);
1956         }
1957
1958         XMLNodeList nlist;
1959         XMLNodeConstIterator niter;
1960         XMLNode *child;
1961         const XMLProperty *prop;
1962
1963         if (node.name() != "Route"){
1964                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1965                 return -1;
1966         }
1967
1968         if ((prop = node.property (X_("name"))) != 0) {
1969                 Route::set_name (prop->value());
1970         }
1971
1972         set_id (node);
1973
1974         if ((prop = node.property (X_("flags"))) != 0) {
1975                 _flags = Flag (string_2_enum (prop->value(), _flags));
1976         } else {
1977                 _flags = Flag (0);
1978         }
1979
1980         if (is_master() || is_monitor() || is_hidden()) {
1981                 _mute_master->set_solo_ignore (true);
1982         }
1983
1984         if (is_monitor()) {
1985                 /* monitor bus does not get a panner, but if (re)created
1986                    via XML, it will already have one by the time we
1987                    call ::set_state(). so ... remove it.
1988                 */
1989                 unpan ();
1990         }
1991
1992         /* add all processors (except amp, which is always present) */
1993
1994         nlist = node.children();
1995         XMLNode processor_state (X_("processor_state"));
1996
1997         Stateful::save_extra_xml (node);
1998
1999         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2000
2001                 child = *niter;
2002
2003                 if (child->name() == IO::state_node_name) {
2004                         if ((prop = child->property (X_("direction"))) == 0) {
2005                                 continue;
2006                         }
2007
2008                         if (prop->value() == "Input") {
2009                                 _input->set_state (*child, version);
2010                         } else if (prop->value() == "Output") {
2011                                 _output->set_state (*child, version);
2012                         }
2013                 }
2014
2015                 if (child->name() == X_("Processor")) {
2016                         processor_state.add_child_copy (*child);
2017                 }
2018
2019
2020                 if (child->name() == X_("Pannable")) {
2021                         if (_pannable) {
2022                                 _pannable->set_state (*child, version);
2023                         } else {
2024                                 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
2025                         }
2026                 }
2027         }
2028
2029         if ((prop = node.property (X_("meter-point"))) != 0) {
2030                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2031                 set_meter_point (mp, true);
2032                 if (_meter) {
2033                         _meter->set_display_to_user (_meter_point == MeterCustom);
2034                 }
2035         }
2036
2037         set_processor_state (processor_state);
2038
2039         if ((prop = node.property ("self-solo")) != 0) {
2040                 set_self_solo (string_is_affirmative (prop->value()));
2041         }
2042
2043         if ((prop = node.property ("soloed-by-upstream")) != 0) {
2044                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
2045                 mod_solo_by_others_upstream (atoi (prop->value()));
2046         }
2047
2048         if ((prop = node.property ("soloed-by-downstream")) != 0) {
2049                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
2050                 mod_solo_by_others_downstream (atoi (prop->value()));
2051         }
2052
2053         if ((prop = node.property ("solo-isolated")) != 0) {
2054                 set_solo_isolated (string_is_affirmative (prop->value()), this);
2055         }
2056
2057         if ((prop = node.property ("solo-safe")) != 0) {
2058                 set_solo_safe (string_is_affirmative (prop->value()), this);
2059         }
2060
2061         if ((prop = node.property (X_("phase-invert"))) != 0) {
2062                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
2063         }
2064
2065         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2066                 set_denormal_protection (string_is_affirmative (prop->value()));
2067         }
2068
2069         if ((prop = node.property (X_("active"))) != 0) {
2070                 bool yn = string_is_affirmative (prop->value());
2071                 _active = !yn; // force switch
2072                 set_active (yn, this);
2073         }
2074
2075         if ((prop = node.property (X_("order-keys"))) != 0) {
2076
2077                 int32_t n;
2078
2079                 string::size_type colon, equal;
2080                 string remaining = prop->value();
2081
2082                 while (remaining.length()) {
2083
2084                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2085                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2086                                       << endmsg;
2087                         } else {
2088                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2089                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2090                                               << endmsg;
2091                                 } else {
2092                                         set_order_key (remaining.substr (0, equal), n);
2093                                 }
2094                         }
2095
2096                         colon = remaining.find_first_of (':');
2097
2098                         if (colon != string::npos) {
2099                                 remaining = remaining.substr (colon+1);
2100                         } else {
2101                                 break;
2102                         }
2103                 }
2104         }
2105
2106         if ((prop = node.property (X_("processor-after-last-custom-meter"))) != 0) {
2107                 PBD::ID id (prop->value ());
2108                 Glib::RWLock::ReaderLock lm (_processor_lock);
2109                 ProcessorList::const_iterator i = _processors.begin ();
2110                 while (i != _processors.end() && (*i)->id() != id) {
2111                         ++i;
2112                 }
2113
2114                 if (i != _processors.end ()) {
2115                         _processor_after_last_custom_meter = *i;
2116                         _custom_meter_position_noted = true;
2117                 }
2118         }
2119
2120         if ((prop = node.property (X_("last-custom-meter-was-at-end"))) != 0) {
2121                 _last_custom_meter_was_at_end = string_is_affirmative (prop->value ());
2122         }
2123
2124         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2125                 child = *niter;
2126
2127                 if (child->name() == X_("Comment")) {
2128
2129                         /* XXX this is a terrible API design in libxml++ */
2130
2131                         XMLNode *cmt = *(child->children().begin());
2132                         _comment = cmt->content();
2133
2134                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2135                         if (prop->value() == "solo") {
2136                                 _solo_control->set_state (*child, version);
2137                         } else if (prop->value() == "mute") {
2138                                 _mute_control->set_state (*child, version);
2139                         }
2140
2141                 } else if (child->name() == X_("RemoteControl")) {
2142                         if ((prop = child->property (X_("id"))) != 0) {
2143                                 int32_t x;
2144                                 sscanf (prop->value().c_str(), "%d", &x);
2145                                 set_remote_control_id (x);
2146                         }
2147
2148                 } else if (child->name() == X_("MuteMaster")) {
2149                         _mute_master->set_state (*child, version);
2150                 }
2151         }
2152
2153         return 0;
2154 }
2155
2156 int
2157 Route::set_state_2X (const XMLNode& node, int version)
2158 {
2159         XMLNodeList nlist;
2160         XMLNodeConstIterator niter;
2161         XMLNode *child;
2162         const XMLProperty *prop;
2163
2164         /* 2X things which still remain to be handled:
2165          * default-type
2166          * automation
2167          * controlouts
2168          */
2169
2170         if (node.name() != "Route") {
2171                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2172                 return -1;
2173         }
2174
2175         if ((prop = node.property (X_("flags"))) != 0) {
2176                 string f = prop->value ();
2177                 boost::replace_all (f, "ControlOut", "MonitorOut");
2178                 _flags = Flag (string_2_enum (f, _flags));
2179         } else {
2180                 _flags = Flag (0);
2181         }
2182
2183         if ((prop = node.property (X_("phase-invert"))) != 0) {
2184                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2185                 if (string_is_affirmative (prop->value ())) {
2186                         p.set ();
2187                 }
2188                 set_phase_invert (p);
2189         }
2190
2191         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2192                 set_denormal_protection (string_is_affirmative (prop->value()));
2193         }
2194
2195         if ((prop = node.property (X_("soloed"))) != 0) {
2196                 bool yn = string_is_affirmative (prop->value());
2197
2198                 /* XXX force reset of solo status */
2199
2200                 set_solo (yn, this);
2201         }
2202
2203         if ((prop = node.property (X_("muted"))) != 0) {
2204
2205                 bool first = true;
2206                 bool muted = string_is_affirmative (prop->value());
2207
2208                 if (muted) {
2209
2210                         string mute_point;
2211
2212                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2213
2214                                 if (string_is_affirmative (prop->value())){
2215                                         mute_point = mute_point + "PreFader";
2216                                         first = false;
2217                                 }
2218                         }
2219
2220                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2221
2222                                 if (string_is_affirmative (prop->value())){
2223
2224                                         if (!first) {
2225                                                 mute_point = mute_point + ",";
2226                                         }
2227
2228                                         mute_point = mute_point + "PostFader";
2229                                         first = false;
2230                                 }
2231                         }
2232
2233                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2234
2235                                 if (string_is_affirmative (prop->value())){
2236
2237                                         if (!first) {
2238                                                 mute_point = mute_point + ",";
2239                                         }
2240
2241                                         mute_point = mute_point + "Listen";
2242                                         first = false;
2243                                 }
2244                         }
2245
2246                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2247
2248                                 if (string_is_affirmative (prop->value())){
2249
2250                                         if (!first) {
2251                                                 mute_point = mute_point + ",";
2252                                         }
2253
2254                                         mute_point = mute_point + "Main";
2255                                 }
2256                         }
2257
2258                         _mute_master->set_mute_points (mute_point);
2259                         _mute_master->set_muted_by_self (true);
2260                 }
2261         }
2262
2263         if ((prop = node.property (X_("meter-point"))) != 0) {
2264                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2265         }
2266
2267         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2268            don't mean the same thing.
2269         */
2270
2271         if ((prop = node.property (X_("order-keys"))) != 0) {
2272
2273                 int32_t n;
2274
2275                 string::size_type colon, equal;
2276                 string remaining = prop->value();
2277
2278                 while (remaining.length()) {
2279
2280                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2281                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2282                                         << endmsg;
2283                         } else {
2284                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2285                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2286                                                 << endmsg;
2287                                 } else {
2288                                         set_order_key (remaining.substr (0, equal), n);
2289                                 }
2290                         }
2291
2292                         colon = remaining.find_first_of (':');
2293
2294                         if (colon != string::npos) {
2295                                 remaining = remaining.substr (colon+1);
2296                         } else {
2297                                 break;
2298                         }
2299                 }
2300         }
2301
2302         /* IOs */
2303
2304         nlist = node.children ();
2305         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2306
2307                 child = *niter;
2308
2309                 if (child->name() == IO::state_node_name) {
2310
2311                         /* there is a note in IO::set_state_2X() about why we have to call
2312                            this directly.
2313                            */
2314
2315                         _input->set_state_2X (*child, version, true);
2316                         _output->set_state_2X (*child, version, false);
2317
2318                         if ((prop = child->property (X_("name"))) != 0) {
2319                                 Route::set_name (prop->value ());
2320                         }
2321
2322                         set_id (*child);
2323
2324                         if ((prop = child->property (X_("active"))) != 0) {
2325                                 bool yn = string_is_affirmative (prop->value());
2326                                 _active = !yn; // force switch
2327                                 set_active (yn, this);
2328                         }
2329
2330                         if ((prop = child->property (X_("gain"))) != 0) {
2331                                 gain_t val;
2332
2333                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2334                                         _amp->gain_control()->set_value (val);
2335                                 }
2336                         }
2337
2338                         /* Set up Panners in the IO */
2339                         XMLNodeList io_nlist = child->children ();
2340
2341                         XMLNodeConstIterator io_niter;
2342                         XMLNode *io_child;
2343
2344                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2345
2346                                 io_child = *io_niter;
2347
2348                                 if (io_child->name() == X_("Panner")) {
2349                                         _main_outs->panner_shell()->set_state(*io_child, version);
2350                                 } else if (io_child->name() == X_("Automation")) {
2351                                         /* IO's automation is for the fader */
2352                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2353                                 }
2354                         }
2355                 }
2356         }
2357
2358         XMLNodeList redirect_nodes;
2359
2360         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2361
2362                 child = *niter;
2363
2364                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2365                         redirect_nodes.push_back(child);
2366                 }
2367
2368         }
2369
2370         set_processor_state_2X (redirect_nodes, version);
2371
2372         Stateful::save_extra_xml (node);
2373
2374         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2375                 child = *niter;
2376
2377                 if (child->name() == X_("Comment")) {
2378
2379                         /* XXX this is a terrible API design in libxml++ */
2380
2381                         XMLNode *cmt = *(child->children().begin());
2382                         _comment = cmt->content();
2383
2384                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2385                         if (prop->value() == X_("solo")) {
2386                                 _solo_control->set_state (*child, version);
2387                         } else if (prop->value() == X_("mute")) {
2388                                 _mute_control->set_state (*child, version);
2389                         }
2390
2391                 } else if (child->name() == X_("RemoteControl")) {
2392                         if ((prop = child->property (X_("id"))) != 0) {
2393                                 int32_t x;
2394                                 sscanf (prop->value().c_str(), "%d", &x);
2395                                 set_remote_control_id (x);
2396                         }
2397
2398                 }
2399         }
2400
2401         return 0;
2402 }
2403
2404 XMLNode&
2405 Route::get_processor_state ()
2406 {
2407         XMLNode* root = new XMLNode (X_("redirects"));
2408         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2409                 root->add_child_nocopy ((*i)->state (true));
2410         }
2411
2412         return *root;
2413 }
2414
2415 void
2416 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2417 {
2418         /* We don't bother removing existing processors not in nList, as this
2419            method will only be called when creating a Route from scratch, not
2420            for undo purposes.  Just put processors in at the appropriate place
2421            in the list.
2422         */
2423
2424         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2425                 add_processor_from_xml_2X (**i, version);
2426         }
2427 }
2428
2429 void
2430 Route::set_processor_state (const XMLNode& node)
2431 {
2432         const XMLNodeList &nlist = node.children();
2433         XMLNodeConstIterator niter;
2434         ProcessorList new_order;
2435         bool must_configure = false;
2436
2437         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2438
2439                 XMLProperty* prop = (*niter)->property ("type");
2440
2441                 if (prop->value() == "amp") {
2442                         _amp->set_state (**niter, Stateful::current_state_version);
2443                         new_order.push_back (_amp);
2444                 } else if (prop->value() == "meter") {
2445                         _meter->set_state (**niter, Stateful::current_state_version);
2446                         new_order.push_back (_meter);
2447                 } else if (prop->value() == "main-outs") {
2448                         _main_outs->set_state (**niter, Stateful::current_state_version);
2449                 } else if (prop->value() == "intreturn") {
2450                         if (!_intreturn) {
2451                                 _intreturn.reset (new InternalReturn (_session));
2452                                 must_configure = true;
2453                         }
2454                         _intreturn->set_state (**niter, Stateful::current_state_version);
2455                 } else if (is_monitor() && prop->value() == "monitor") {
2456                         if (!_monitor_control) {
2457                                 _monitor_control.reset (new MonitorProcessor (_session));
2458                                 must_configure = true;
2459                         }
2460                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2461                 } else if (prop->value() == "capture") {
2462                         /* CapturingProcessor should never be restored, it's always
2463                            added explicitly when needed */
2464                 } else {
2465                         ProcessorList::iterator o;
2466
2467                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2468                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2469                                 if (id_prop && (*o)->id() == id_prop->value()) {
2470                                         (*o)->set_state (**niter, Stateful::current_state_version);
2471                                         new_order.push_back (*o);
2472                                         break;
2473                                 }
2474                         }
2475
2476                         // If the processor (*niter) is not on the route then create it
2477
2478                         if (o == _processors.end()) {
2479
2480                                 boost::shared_ptr<Processor> processor;
2481
2482                                 if (prop->value() == "intsend") {
2483
2484                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2485
2486                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2487                                            prop->value() == "lv2" ||
2488                                            prop->value() == "vst" ||
2489                                            prop->value() == "lxvst" ||
2490                                            prop->value() == "audiounit") {
2491
2492                                         processor.reset (new PluginInsert(_session));
2493
2494                                 } else if (prop->value() == "port") {
2495
2496                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2497
2498                                 } else if (prop->value() == "send") {
2499
2500                                         processor.reset (new Send (_session, _pannable, _mute_master));
2501
2502                                 } else {
2503                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2504                                         continue;
2505                                 }
2506
2507                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2508                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2509                                         processor.reset (new UnknownProcessor (_session, **niter));
2510                                 }
2511
2512                                 /* we have to note the monitor send here, otherwise a new one will be created
2513                                    and the state of this one will be lost.
2514                                 */
2515                                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2516                                 if (isend && isend->role() == Delivery::Listen) {
2517                                         _monitor_send = isend;
2518                                 }
2519
2520                                 /* it doesn't matter if invisible processors are added here, as they
2521                                    will be sorted out by setup_invisible_processors () shortly.
2522                                 */
2523
2524                                 new_order.push_back (processor);
2525                                 must_configure = true;
2526                         }
2527                 }
2528         }
2529
2530         {
2531                 Glib::RWLock::WriterLock lm (_processor_lock);
2532                 _processors = new_order;
2533
2534                 if (must_configure) {
2535                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2536                         configure_processors_unlocked (0);
2537                 }
2538
2539                 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2540
2541                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2542
2543                         boost::shared_ptr<PluginInsert> pi;
2544
2545                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2546                                 if (pi->has_no_inputs ()) {
2547                                         _have_internal_generator = true;
2548                                         break;
2549                                 }
2550                         }
2551                 }
2552         }
2553
2554         reset_instrument_info ();
2555         processors_changed (RouteProcessorChange ());
2556         set_processor_positions ();
2557 }
2558
2559 void
2560 Route::curve_reallocate ()
2561 {
2562 //      _gain_automation_curve.finish_resize ();
2563 //      _pan_automation_curve.finish_resize ();
2564 }
2565
2566 void
2567 Route::silence (framecnt_t nframes)
2568 {
2569         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2570         if (!lm.locked()) {
2571                 return;
2572         }
2573
2574         silence_unlocked (nframes);
2575 }
2576
2577 void
2578 Route::silence_unlocked (framecnt_t nframes)
2579 {
2580         /* Must be called with the processor lock held */
2581
2582         if (!_silent) {
2583
2584                 _output->silence (nframes);
2585
2586                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2587                         boost::shared_ptr<PluginInsert> pi;
2588
2589                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2590                                 // skip plugins, they don't need anything when we're not active
2591                                 continue;
2592                         }
2593
2594                         (*i)->silence (nframes);
2595                 }
2596
2597                 if (nframes == _session.get_block_size()) {
2598                         // _silent = true;
2599                 }
2600         }
2601 }
2602
2603 void
2604 Route::add_internal_return ()
2605 {
2606         if (!_intreturn) {
2607                 _intreturn.reset (new InternalReturn (_session));
2608                 add_processor (_intreturn, PreFader);
2609         }
2610 }
2611
2612 void
2613 Route::add_send_to_internal_return (InternalSend* send)
2614 {
2615         Glib::RWLock::ReaderLock rm (_processor_lock);
2616
2617         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2618                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2619
2620                 if (d) {
2621                         return d->add_send (send);
2622                 }
2623         }
2624 }
2625
2626 void
2627 Route::remove_send_from_internal_return (InternalSend* send)
2628 {
2629         Glib::RWLock::ReaderLock rm (_processor_lock);
2630
2631         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2632                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2633
2634                 if (d) {
2635                         return d->remove_send (send);
2636                 }
2637         }
2638 }
2639
2640 void
2641 Route::enable_monitor_send ()
2642 {
2643         /* Caller must hold process lock */
2644         assert (!AudioEngine::instance()->process_lock().trylock());
2645
2646         /* master never sends to monitor section via the normal mechanism */
2647         assert (!is_master ());
2648
2649         /* make sure we have one */
2650         if (!_monitor_send) {
2651                 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2652                 _monitor_send->set_display_to_user (false);
2653         }
2654
2655         /* set it up */
2656         configure_processors (0);
2657 }
2658
2659 /** Add an aux send to a route.
2660  *  @param route route to send to.
2661  *  @param before Processor to insert before, or 0 to insert at the end.
2662  */
2663 int
2664 Route::add_aux_send (boost::shared_ptr<Route> route, boost::shared_ptr<Processor> before)
2665 {
2666         assert (route != _session.monitor_out ());
2667
2668         {
2669                 Glib::RWLock::ReaderLock rm (_processor_lock);
2670
2671                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2672
2673                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2674
2675                         if (d && d->target_route() == route) {
2676                                 /* already listening via the specified IO: do nothing */
2677                                 return 0;
2678                         }
2679                 }
2680         }
2681
2682         try {
2683
2684                 boost::shared_ptr<InternalSend> listener;
2685
2686                 {
2687                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2688                         listener.reset (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2689                 }
2690
2691                 add_processor (listener, before);
2692
2693         } catch (failed_constructor& err) {
2694                 return -1;
2695         }
2696
2697         return 0;
2698 }
2699
2700 void
2701 Route::remove_aux_or_listen (boost::shared_ptr<Route> route)
2702 {
2703         ProcessorStreams err;
2704         ProcessorList::iterator tmp;
2705
2706         {
2707                 Glib::RWLock::ReaderLock rl(_processor_lock);
2708
2709                 /* have to do this early because otherwise processor reconfig
2710                  * will put _monitor_send back in the list
2711                  */
2712
2713                 if (route == _session.monitor_out()) {
2714                         _monitor_send.reset ();
2715                 }
2716
2717           again:
2718                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2719
2720                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2721
2722                         if (d && d->target_route() == route) {
2723                                 rl.release ();
2724                                 remove_processor (*x, &err, false);
2725                                 rl.acquire ();
2726
2727                                 /* list could have been demolished while we dropped the lock
2728                                    so start over.
2729                                 */
2730
2731                                 goto again;
2732                         }
2733                 }
2734         }
2735 }
2736
2737 void
2738 Route::set_comment (string cmt, void *src)
2739 {
2740         _comment = cmt;
2741         comment_changed (src);
2742         _session.set_dirty ();
2743 }
2744
2745 bool
2746 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2747 {
2748         FeedRecord fr (other, via_sends_only);
2749
2750         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2751
2752         if (!result.second) {
2753
2754                 /* already a record for "other" - make sure sends-only information is correct */
2755                 if (!via_sends_only && result.first->sends_only) {
2756                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2757                         frp->sends_only = false;
2758                 }
2759         }
2760
2761         return result.second;
2762 }
2763
2764 void
2765 Route::clear_fed_by ()
2766 {
2767         _fed_by.clear ();
2768 }
2769
2770 bool
2771 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2772 {
2773         const FedBy& fed_by (other->fed_by());
2774
2775         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2776                 boost::shared_ptr<Route> sr = f->r.lock();
2777
2778                 if (sr && (sr.get() == this)) {
2779
2780                         if (via_sends_only) {
2781                                 *via_sends_only = f->sends_only;
2782                         }
2783
2784                         return true;
2785                 }
2786         }
2787
2788         return false;
2789 }
2790
2791 bool
2792 Route::direct_feeds_according_to_reality (boost::shared_ptr<Route> other, bool* via_send_only)
2793 {
2794         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2795
2796         if (_output->connected_to (other->input())) {
2797                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2798                 if (via_send_only) {
2799                         *via_send_only = false;
2800                 }
2801
2802                 return true;
2803         }
2804
2805
2806         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2807
2808                 boost::shared_ptr<IOProcessor> iop;
2809
2810                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2811                         if (iop->feeds (other)) {
2812                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2813                                 if (via_send_only) {
2814                                         *via_send_only = true;
2815                                 }
2816                                 return true;
2817                         } else {
2818                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2819                         }
2820                 } else {
2821                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2822                 }
2823
2824         }
2825
2826         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2827         return false;
2828 }
2829
2830 bool
2831 Route::direct_feeds_according_to_graph (boost::shared_ptr<Route> other, bool* via_send_only)
2832 {
2833         return _session._current_route_graph.has (shared_from_this (), other, via_send_only);
2834 }
2835
2836 /** Called from the (non-realtime) butler thread when the transport is stopped */
2837 void
2838 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2839 {
2840         framepos_t now = _session.transport_frame();
2841
2842         {
2843                 Glib::RWLock::ReaderLock lm (_processor_lock);
2844
2845                 if (!did_locate) {
2846                         automation_snapshot (now, true);
2847                 }
2848
2849                 Automatable::transport_stopped (now);
2850
2851                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2852
2853                         if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2854                                 (*i)->flush ();
2855                         }
2856
2857                         (*i)->transport_stopped (now);
2858                 }
2859         }
2860
2861         _roll_delay = _initial_delay;
2862 }
2863
2864 void
2865 Route::input_change_handler (IOChange change, void * /*src*/)
2866 {
2867         bool need_to_queue_solo_change = true;
2868
2869         if ((change.type & IOChange::ConfigurationChanged)) {
2870                 /* This is called with the process lock held if change
2871                    contains ConfigurationChanged
2872                 */
2873                 need_to_queue_solo_change = false;
2874                 configure_processors (0);
2875                 _phase_invert.resize (_input->n_ports().n_audio ());
2876                 io_changed (); /* EMIT SIGNAL */
2877         }
2878
2879         if (!_input->connected() && _soloed_by_others_upstream) {
2880                 if (need_to_queue_solo_change) {
2881                         _session.cancel_solo_after_disconnect (shared_from_this(), true);
2882                 } else {
2883                         cancel_solo_after_disconnect (true);
2884                 }
2885         }
2886 }
2887
2888 void
2889 Route::output_change_handler (IOChange change, void * /*src*/)
2890 {
2891         bool need_to_queue_solo_change = true;
2892
2893         if ((change.type & IOChange::ConfigurationChanged)) {
2894                 /* This is called with the process lock held if change
2895                    contains ConfigurationChanged
2896                 */
2897                 need_to_queue_solo_change = false;
2898         }
2899
2900         if (!_output->connected() && _soloed_by_others_downstream) {
2901                 if (need_to_queue_solo_change) {
2902                         _session.cancel_solo_after_disconnect (shared_from_this(), false);
2903                 } else {
2904                         cancel_solo_after_disconnect (false);
2905                 }
2906         }
2907 }
2908
2909 void
2910 Route::cancel_solo_after_disconnect (bool upstream)
2911 {
2912         if (upstream) {
2913                 _soloed_by_others_upstream = 0;
2914         } else {
2915                 _soloed_by_others_downstream = 0;
2916         }
2917         set_mute_master_solo ();
2918         solo_changed (false, this);
2919 }
2920
2921 uint32_t
2922 Route::pans_required () const
2923 {
2924         if (n_outputs().n_audio() < 2) {
2925                 return 0;
2926         }
2927
2928         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2929 }
2930
2931 int
2932 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
2933 {
2934         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2935         if (!lm.locked()) {
2936                 return 0;
2937         }
2938
2939         if (n_outputs().n_total() == 0) {
2940                 return 0;
2941         }
2942
2943         if (!_active || n_inputs() == ChanCount::ZERO)  {
2944                 silence_unlocked (nframes);
2945                 return 0;
2946         }
2947         if (session_state_changing) {
2948                 if (_session.transport_speed() != 0.0f) {
2949                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2950                            so we cannot use them. Be silent till this is over.
2951
2952                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2953                         */
2954                         silence_unlocked (nframes);
2955                         return 0;
2956                 }
2957                 /* we're really not rolling, so we're either delivery silence or actually
2958                    monitoring, both of which are safe to do while session_state_changing is true.
2959                 */
2960         }
2961
2962         _amp->apply_gain_automation (false);
2963         passthru (start_frame, end_frame, nframes, 0);
2964
2965         return 0;
2966 }
2967
2968 int
2969 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
2970 {
2971         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2972         if (!lm.locked()) {
2973                 return 0;
2974         }
2975
2976         automation_snapshot (_session.transport_frame(), false);
2977
2978         if (n_outputs().n_total() == 0) {
2979                 return 0;
2980         }
2981
2982         if (!_active || n_inputs().n_total() == 0) {
2983                 silence_unlocked (nframes);
2984                 return 0;
2985         }
2986
2987         framepos_t unused = 0;
2988
2989         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2990                 return 0;
2991         }
2992
2993         _silent = false;
2994
2995         passthru (start_frame, end_frame, nframes, declick);
2996
2997         return 0;
2998 }
2999
3000 int
3001 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
3002 {
3003         silence (nframes);
3004         return 0;
3005 }
3006
3007 void
3008 Route::flush_processors ()
3009 {
3010         /* XXX shouldn't really try to take this lock, since
3011            this is called from the RT audio thread.
3012         */
3013
3014         Glib::RWLock::ReaderLock lm (_processor_lock);
3015
3016         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3017                 (*i)->flush ();
3018         }
3019 }
3020
3021 void
3022 Route::set_meter_point (MeterPoint p, bool force)
3023 {
3024         /* CAN BE CALLED FROM PROCESS CONTEXT */
3025
3026         if (_meter_point == p && !force) {
3027                 return;
3028         }
3029
3030         bool meter_was_visible_to_user = _meter->display_to_user ();
3031
3032         {
3033                 Glib::RWLock::WriterLock lm (_processor_lock);
3034
3035                 maybe_note_meter_position ();
3036
3037                 _meter_point = p;
3038
3039                 if (_meter_point != MeterCustom) {
3040
3041                         _meter->set_display_to_user (false);
3042
3043                         setup_invisible_processors ();
3044
3045                 } else {
3046
3047                         _meter->set_display_to_user (true);
3048
3049                         /* If we have a previous position for the custom meter, try to put it there */
3050                         if (_custom_meter_position_noted) {
3051                                 boost::shared_ptr<Processor> after = _processor_after_last_custom_meter.lock ();
3052
3053                                 if (after) {
3054                                         ProcessorList::iterator i = find (_processors.begin(), _processors.end(), after);
3055                                         if (i != _processors.end ()) {
3056                                                 _processors.remove (_meter);
3057                                                 _processors.insert (i, _meter);
3058                                         }
3059                                 } else if (_last_custom_meter_was_at_end) {
3060                                         _processors.remove (_meter);
3061                                         _processors.push_back (_meter);
3062                                 }
3063                         }
3064                 }
3065
3066                 /* Set up the meter for its new position */
3067
3068                 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
3069
3070                 ChanCount m_in;
3071
3072                 if (loc == _processors.begin()) {
3073                         m_in = _input->n_ports();
3074                 } else {
3075                         ProcessorList::iterator before = loc;
3076                         --before;
3077                         m_in = (*before)->output_streams ();
3078                 }
3079
3080                 _meter->reflect_inputs (m_in);
3081
3082                 /* we do not need to reconfigure the processors, because the meter
3083                    (a) is always ready to handle processor_max_streams
3084                    (b) is always an N-in/N-out processor, and thus moving
3085                    it doesn't require any changes to the other processors.
3086                 */
3087         }
3088
3089         meter_change (); /* EMIT SIGNAL */
3090
3091         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3092
3093         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3094 }
3095
3096 void
3097 Route::listen_position_changed ()
3098 {
3099         {
3100                 Glib::RWLock::WriterLock lm (_processor_lock);
3101                 ProcessorState pstate (this);
3102
3103                 {
3104                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3105
3106                         if (configure_processors_unlocked (0)) {
3107                                 pstate.restore ();
3108                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
3109                                 return;
3110                         }
3111                 }
3112         }
3113
3114         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3115         _session.set_dirty ();
3116 }
3117
3118 boost::shared_ptr<CapturingProcessor>
3119 Route::add_export_point()
3120 {
3121         if (!_capturing_processor) {
3122
3123                 _capturing_processor.reset (new CapturingProcessor (_session));
3124                 _capturing_processor->activate ();
3125
3126                 {
3127                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3128                         configure_processors (0);
3129                 }
3130
3131         }
3132
3133         return _capturing_processor;
3134 }
3135
3136 framecnt_t
3137 Route::update_signal_latency ()
3138 {
3139         framecnt_t l = _output->user_latency();
3140
3141         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3142                 if ((*i)->active ()) {
3143                         l += (*i)->signal_latency ();
3144                 }
3145         }
3146
3147         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3148
3149         if (_signal_latency != l) {
3150                 _signal_latency = l;
3151                 signal_latency_changed (); /* EMIT SIGNAL */
3152         }
3153
3154         return _signal_latency;
3155 }
3156
3157 void
3158 Route::set_user_latency (framecnt_t nframes)
3159 {
3160         _output->set_user_latency (nframes);
3161         _session.update_latency_compensation ();
3162 }
3163
3164 void
3165 Route::set_latency_compensation (framecnt_t longest_session_latency)
3166 {
3167         framecnt_t old = _initial_delay;
3168
3169         if (_signal_latency < longest_session_latency) {
3170                 _initial_delay = longest_session_latency - _signal_latency;
3171         } else {
3172                 _initial_delay = 0;
3173         }
3174
3175         DEBUG_TRACE (DEBUG::Latency, string_compose (
3176                              "%1: compensate for maximum latency of %2,"
3177                              "given own latency of %3, using initial delay of %4\n",
3178                              name(), longest_session_latency, _signal_latency, _initial_delay));
3179
3180         if (_initial_delay != old) {
3181                 initial_delay_changed (); /* EMIT SIGNAL */
3182         }
3183
3184         if (_session.transport_stopped()) {
3185                 _roll_delay = _initial_delay;
3186         }
3187 }
3188
3189 void
3190 Route::automation_snapshot (framepos_t now, bool force)
3191 {
3192         if (_pannable) {
3193                 _pannable->automation_snapshot (now, force);
3194         }
3195
3196         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3197                 (*i)->automation_snapshot (now, force);
3198         }
3199 }
3200
3201 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3202         : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3203                              boost::shared_ptr<AutomationList>(), name)
3204         , _route (r)
3205 {
3206         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3207         set_list (gl);
3208 }
3209
3210 void
3211 Route::SoloControllable::set_value (double val)
3212 {
3213         bool bval = ((val >= 0.5f) ? true: false);
3214
3215         boost::shared_ptr<RouteList> rl (new RouteList);
3216
3217         boost::shared_ptr<Route> r = _route.lock ();
3218         if (!r) {
3219                 return;
3220         }
3221
3222         rl->push_back (r);
3223
3224         if (Config->get_solo_control_is_listen_control()) {
3225                 _session.set_listen (rl, bval);
3226         } else {
3227                 _session.set_solo (rl, bval);
3228         }
3229 }
3230
3231 double
3232 Route::SoloControllable::get_value () const
3233 {
3234         boost::shared_ptr<Route> r = _route.lock ();
3235         if (!r) {
3236                 return 0;
3237         }
3238
3239         if (Config->get_solo_control_is_listen_control()) {
3240                 return r->listening_via_monitor() ? 1.0f : 0.0f;
3241         } else {
3242                 return r->self_soloed() ? 1.0f : 0.0f;
3243         }
3244 }
3245
3246 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3247         : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3248                              boost::shared_ptr<AutomationList>(), name)
3249         , _route (r)
3250 {
3251         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3252         set_list (gl);
3253 }
3254
3255 void
3256 Route::MuteControllable::set_value (double val)
3257 {
3258         bool bval = ((val >= 0.5f) ? true: false);
3259
3260         boost::shared_ptr<RouteList> rl (new RouteList);
3261
3262         boost::shared_ptr<Route> r = _route.lock ();
3263         if (!r) {
3264                 return;
3265         }
3266
3267         rl->push_back (r);
3268         _session.set_mute (rl, bval);
3269 }
3270
3271 double
3272 Route::MuteControllable::get_value () const
3273 {
3274         boost::shared_ptr<Route> r = _route.lock ();
3275         if (!r) {
3276                 return 0;
3277         }
3278
3279         return r->muted() ? 1.0f : 0.0f;
3280 }
3281
3282 void
3283 Route::set_block_size (pframes_t nframes)
3284 {
3285         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3286                 (*i)->set_block_size (nframes);
3287         }
3288
3289         _session.ensure_buffers (n_process_buffers ());
3290 }
3291
3292 void
3293 Route::protect_automation ()
3294 {
3295         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3296                 (*i)->protect_automation();
3297 }
3298
3299 /** @param declick 1 to set a pending declick fade-in,
3300  *                -1 to set a pending declick fade-out
3301  */
3302 void
3303 Route::set_pending_declick (int declick)
3304 {
3305         if (_declickable) {
3306                 /* this call is not allowed to turn off a pending declick */
3307                 if (declick) {
3308                         _pending_declick = declick;
3309                 }
3310         } else {
3311                 _pending_declick = 0;
3312         }
3313 }
3314
3315 /** Shift automation forwards from a particular place, thereby inserting time.
3316  *  Adds undo commands for any shifts that are performed.
3317  *
3318  * @param pos Position to start shifting from.
3319  * @param frames Amount to shift forwards by.
3320  */
3321
3322 void
3323 Route::shift (framepos_t pos, framecnt_t frames)
3324 {
3325         /* gain automation */
3326         {
3327                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3328
3329                 XMLNode &before = gc->alist()->get_state ();
3330                 gc->alist()->shift (pos, frames);
3331                 XMLNode &after = gc->alist()->get_state ();
3332                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3333         }
3334
3335         /* pan automation */
3336         if (_pannable) {
3337                 ControlSet::Controls& c (_pannable->controls());
3338
3339                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3340                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3341                         if (pc) {
3342                                 boost::shared_ptr<AutomationList> al = pc->alist();
3343                                 XMLNode& before = al->get_state ();
3344                                 al->shift (pos, frames);
3345                                 XMLNode& after = al->get_state ();
3346                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3347                         }
3348                 }
3349         }
3350
3351         /* redirect automation */
3352         {
3353                 Glib::RWLock::ReaderLock lm (_processor_lock);
3354                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3355
3356                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3357
3358                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3359                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3360                                 if (ac) {
3361                                         boost::shared_ptr<AutomationList> al = ac->alist();
3362                                         XMLNode &before = al->get_state ();
3363                                         al->shift (pos, frames);
3364                                         XMLNode &after = al->get_state ();
3365                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3366                                 }
3367                         }
3368                 }
3369         }
3370 }
3371
3372
3373 int
3374 Route::save_as_template (const string& path, const string& name)
3375 {
3376         XMLNode& node (state (false));
3377         XMLTree tree;
3378
3379         IO::set_name_in_state (*node.children().front(), name);
3380
3381         tree.set_root (&node);
3382         return tree.write (path.c_str());
3383 }
3384
3385
3386 bool
3387 Route::set_name (const string& str)
3388 {
3389         bool ret;
3390         string ioproc_name;
3391         string name;
3392
3393         name = Route::ensure_track_or_route_name (str, _session);
3394         SessionObject::set_name (name);
3395
3396         ret = (_input->set_name(name) && _output->set_name(name));
3397
3398         if (ret) {
3399                 /* rename the main outs. Leave other IO processors
3400                  * with whatever name they already have, because its
3401                  * just fine as it is (it will not contain the route
3402                  * name if its a port insert, port send or port return).
3403                  */
3404
3405                 if (_main_outs) {
3406                         if (_main_outs->set_name (name)) {
3407                                 /* XXX returning false here is stupid because
3408                                    we already changed the route name.
3409                                 */
3410                                 return false;
3411                         }
3412                 }
3413         }
3414
3415         return ret;
3416 }
3417
3418 /** Set the name of a route in an XML description.
3419  *  @param node XML <Route> node to set the name in.
3420  *  @param name New name.
3421  */
3422 void
3423 Route::set_name_in_state (XMLNode& node, string const & name)
3424 {
3425         node.add_property (X_("name"), name);
3426
3427         XMLNodeList children = node.children();
3428         for (XMLNodeIterator i = children.begin(); i != children.end(); ++i) {
3429
3430                 if ((*i)->name() == X_("IO")) {
3431
3432                         IO::set_name_in_state (**i, name);
3433
3434                 } else if ((*i)->name() == X_("Processor")) {
3435
3436                         XMLProperty* role = (*i)->property (X_("role"));
3437                         if (role && role->value() == X_("Main")) {
3438                                 (*i)->add_property (X_("name"), name);
3439                         }
3440
3441                 } else if ((*i)->name() == X_("Diskstream")) {
3442
3443                         (*i)->add_property (X_("playlist"), string_compose ("%1.1", name).c_str());
3444                         (*i)->add_property (X_("name"), name);
3445
3446                 }
3447         }
3448 }
3449
3450 boost::shared_ptr<Send>
3451 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3452 {
3453         Glib::RWLock::ReaderLock lm (_processor_lock);
3454
3455         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3456                 boost::shared_ptr<InternalSend> send;
3457
3458                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3459                         if (send->target_route() == target) {
3460                                 return send;
3461                         }
3462                 }
3463         }
3464
3465         return boost::shared_ptr<Send>();
3466 }
3467
3468 /** @param c Audio channel index.
3469  *  @param yn true to invert phase, otherwise false.
3470  */
3471 void
3472 Route::set_phase_invert (uint32_t c, bool yn)
3473 {
3474         if (_phase_invert[c] != yn) {
3475                 _phase_invert[c] = yn;
3476                 phase_invert_changed (); /* EMIT SIGNAL */
3477                 _session.set_dirty ();
3478         }
3479 }
3480
3481 void
3482 Route::set_phase_invert (boost::dynamic_bitset<> p)
3483 {
3484         if (_phase_invert != p) {
3485                 _phase_invert = p;
3486                 phase_invert_changed (); /* EMIT SIGNAL */
3487                 _session.set_dirty ();
3488         }
3489 }
3490
3491 bool
3492 Route::phase_invert (uint32_t c) const
3493 {
3494         return _phase_invert[c];
3495 }
3496
3497 boost::dynamic_bitset<>
3498 Route::phase_invert () const
3499 {
3500         return _phase_invert;
3501 }
3502
3503 void
3504 Route::set_denormal_protection (bool yn)
3505 {
3506         if (_denormal_protection != yn) {
3507                 _denormal_protection = yn;
3508                 denormal_protection_changed (); /* EMIT SIGNAL */
3509         }
3510 }
3511
3512 bool
3513 Route::denormal_protection () const
3514 {
3515         return _denormal_protection;
3516 }
3517
3518 void
3519 Route::set_active (bool yn, void* src)
3520 {
3521         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3522                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3523                 return;
3524         }
3525
3526         if (_active != yn) {
3527                 _active = yn;
3528                 _input->set_active (yn);
3529                 _output->set_active (yn);
3530                 active_changed (); // EMIT SIGNAL
3531         }
3532 }
3533
3534 void
3535 Route::meter ()
3536 {
3537         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3538
3539         assert (_meter);
3540
3541         _meter->meter ();
3542
3543         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3544
3545                 boost::shared_ptr<Send> s;
3546                 boost::shared_ptr<Return> r;
3547
3548                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3549                         s->meter()->meter();
3550                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3551                         r->meter()->meter ();
3552                 }
3553         }
3554 }
3555
3556 boost::shared_ptr<Pannable>
3557 Route::pannable() const
3558 {
3559         return _pannable;
3560 }
3561
3562 boost::shared_ptr<Panner>
3563 Route::panner() const
3564 {
3565         /* may be null ! */
3566         return _main_outs->panner_shell()->panner();
3567 }
3568
3569 boost::shared_ptr<PannerShell>
3570 Route::panner_shell() const
3571 {
3572         return _main_outs->panner_shell();
3573 }
3574
3575 boost::shared_ptr<AutomationControl>
3576 Route::gain_control() const
3577 {
3578         return _amp->gain_control();
3579 }
3580
3581 boost::shared_ptr<AutomationControl>
3582 Route::get_control (const Evoral::Parameter& param)
3583 {
3584         /* either we own the control or .... */
3585
3586         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3587
3588         if (!c) {
3589
3590                 /* maybe one of our processors does or ... */
3591
3592                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3593                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3594                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3595                                 break;
3596                         }
3597                 }
3598         }
3599
3600         if (!c) {
3601
3602                 /* nobody does so we'll make a new one */
3603
3604                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3605                 add_control(c);
3606         }
3607
3608         return c;
3609 }
3610
3611 boost::shared_ptr<Processor>
3612 Route::nth_plugin (uint32_t n)
3613 {
3614         Glib::RWLock::ReaderLock lm (_processor_lock);
3615         ProcessorList::iterator i;
3616
3617         for (i = _processors.begin(); i != _processors.end(); ++i) {
3618                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3619                         if (n-- == 0) {
3620                                 return *i;
3621                         }
3622                 }
3623         }
3624
3625         return boost::shared_ptr<Processor> ();
3626 }
3627
3628 boost::shared_ptr<Processor>
3629 Route::nth_send (uint32_t n)
3630 {
3631         Glib::RWLock::ReaderLock lm (_processor_lock);
3632         ProcessorList::iterator i;
3633
3634         for (i = _processors.begin(); i != _processors.end(); ++i) {
3635                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3636                         if (n-- == 0) {
3637                                 return *i;
3638                         }
3639                 }
3640         }
3641
3642         return boost::shared_ptr<Processor> ();
3643 }
3644
3645 bool
3646 Route::has_io_processor_named (const string& name)
3647 {
3648         Glib::RWLock::ReaderLock lm (_processor_lock);
3649         ProcessorList::iterator i;
3650
3651         for (i = _processors.begin(); i != _processors.end(); ++i) {
3652                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3653                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3654                         if ((*i)->name() == name) {
3655                                 return true;
3656                         }
3657                 }
3658         }
3659
3660         return false;
3661 }
3662
3663 MuteMaster::MutePoint
3664 Route::mute_points () const
3665 {
3666         return _mute_master->mute_points ();
3667 }
3668
3669 void
3670 Route::set_processor_positions ()
3671 {
3672         Glib::RWLock::ReaderLock lm (_processor_lock);
3673
3674         bool had_amp = false;
3675         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3676                 (*i)->set_pre_fader (!had_amp);
3677                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3678                         had_amp = true;
3679                 }
3680         }
3681 }
3682
3683 /** Called when there is a proposed change to the input port count */
3684 bool
3685 Route::input_port_count_changing (ChanCount to)
3686 {
3687         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3688         if (c.empty()) {
3689                 /* The processors cannot be configured with the new input arrangement, so
3690                    block the change.
3691                 */
3692                 return true;
3693         }
3694
3695         /* The change is ok */
3696         return false;
3697 }
3698
3699 list<string>
3700 Route::unknown_processors () const
3701 {
3702         list<string> p;
3703
3704         Glib::RWLock::ReaderLock lm (_processor_lock);
3705         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3706                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3707                         p.push_back ((*i)->name ());
3708                 }
3709         }
3710
3711         return p;
3712 }
3713
3714
3715 framecnt_t
3716 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3717 {
3718         /* we assume that all our input ports feed all our output ports. its not
3719            universally true, but the alternative is way too corner-case to worry about.
3720         */
3721
3722         jack_latency_range_t all_connections;
3723
3724         if (from.empty()) {
3725                 all_connections.min = 0;
3726                 all_connections.max = 0;
3727         } else {
3728                 all_connections.min = ~((jack_nframes_t) 0);
3729                 all_connections.max = 0;
3730
3731                 /* iterate over all "from" ports and determine the latency range for all of their
3732                    connections to the "outside" (outside of this Route).
3733                 */
3734
3735                 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3736
3737                         jack_latency_range_t range;
3738
3739                         p->get_connected_latency_range (range, playback);
3740
3741                         all_connections.min = min (all_connections.min, range.min);
3742                         all_connections.max = max (all_connections.max, range.max);
3743                 }
3744         }
3745
3746         /* set the "from" port latencies to the max/min range of all their connections */
3747
3748         for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3749                 p->set_private_latency_range (all_connections, playback);
3750         }
3751
3752         /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3753
3754         all_connections.min += our_latency;
3755         all_connections.max += our_latency;
3756
3757         for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3758                 p->set_private_latency_range (all_connections, playback);
3759         }
3760
3761         return all_connections.max;
3762 }
3763
3764 framecnt_t
3765 Route::set_private_port_latencies (bool playback) const
3766 {
3767         framecnt_t own_latency = 0;
3768
3769         /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3770            OR LATENCY CALLBACK.
3771
3772            This is called (early) from the latency callback. It computes the REAL
3773            latency associated with each port and stores the result as the "private"
3774            latency of the port. A later call to Route::set_public_port_latencies()
3775            sets all ports to the same value to reflect the fact that we do latency
3776            compensation and so all signals are delayed by the same amount as they
3777            flow through ardour.
3778         */
3779
3780         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3781                 if ((*i)->active ()) {
3782                         own_latency += (*i)->signal_latency ();
3783                 }
3784         }
3785
3786         if (playback) {
3787                 /* playback: propagate latency from "outside the route" to outputs to inputs */
3788                 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3789         } else {
3790                 /* capture: propagate latency from "outside the route" to inputs to outputs */
3791                 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3792         }
3793 }
3794
3795 void
3796 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3797 {
3798         /* this is called to set the JACK-visible port latencies, which take
3799            latency compensation into account.
3800         */
3801
3802         jack_latency_range_t range;
3803
3804         range.min = value;
3805         range.max = value;
3806
3807         {
3808                 const PortSet& ports (_input->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                 const PortSet& ports (_output->ports());
3816                 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3817                         p->set_public_latency_range (range, playback);
3818                 }
3819         }
3820 }
3821
3822 /** Put the invisible processors in the right place in _processors.
3823  *  Must be called with a writer lock on _processor_lock held.
3824  */
3825 void
3826 Route::setup_invisible_processors ()
3827 {
3828 #ifndef NDEBUG
3829         Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3830         assert (!lm.locked ());
3831 #endif
3832
3833         if (!_main_outs) {
3834                 /* too early to be doing this stuff */
3835                 return;
3836         }
3837
3838         /* we'll build this new list here and then use it */
3839
3840         ProcessorList new_processors;
3841
3842         /* find visible processors */
3843
3844         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3845                 if ((*i)->display_to_user ()) {
3846                         new_processors.push_back (*i);
3847                 }
3848         }
3849
3850         /* find the amp */
3851
3852         ProcessorList::iterator amp = new_processors.begin ();
3853         while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3854                 ++amp;
3855         }
3856
3857         assert (amp != _processors.end ());
3858
3859         /* and the processor after the amp */
3860
3861         ProcessorList::iterator after_amp = amp;
3862         ++after_amp;
3863
3864         /* METER */
3865
3866         if (_meter) {
3867                 switch (_meter_point) {
3868                 case MeterInput:
3869                         assert (!_meter->display_to_user ());
3870                         new_processors.push_front (_meter);
3871                         break;
3872                 case MeterPreFader:
3873                         assert (!_meter->display_to_user ());
3874                         new_processors.insert (amp, _meter);
3875                         break;
3876                 case MeterPostFader:
3877                         /* do nothing here */
3878                         break;
3879                 case MeterOutput:
3880                         /* do nothing here */
3881                         break;
3882                 case MeterCustom:
3883                         /* the meter is visible, so we don't touch it here */
3884                         break;
3885                 }
3886         }
3887
3888         /* MAIN OUTS */
3889
3890         assert (_main_outs);
3891         assert (!_main_outs->display_to_user ());
3892         new_processors.push_back (_main_outs);
3893
3894         /* iterator for the main outs */
3895
3896         ProcessorList::iterator main = new_processors.end();
3897         --main;
3898
3899         /* OUTPUT METERING */
3900
3901         if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3902                 assert (!_meter->display_to_user ());
3903
3904                 /* add the processor just before or just after the main outs */
3905
3906                 ProcessorList::iterator meter_point = main;
3907
3908                 if (_meter_point == MeterOutput) {
3909                         ++meter_point;
3910                 }
3911                 new_processors.insert (meter_point, _meter);
3912         }
3913
3914         /* MONITOR SEND */
3915
3916         if (_monitor_send && !is_monitor ()) {
3917                 assert (!_monitor_send->display_to_user ());
3918                 if (Config->get_solo_control_is_listen_control()) {
3919                         switch (Config->get_listen_position ()) {
3920                         case PreFaderListen:
3921                                 switch (Config->get_pfl_position ()) {
3922                                 case PFLFromBeforeProcessors:
3923                                         new_processors.push_front (_monitor_send);
3924                                         break;
3925                                 case PFLFromAfterProcessors:
3926                                         new_processors.insert (amp, _monitor_send);
3927                                         break;
3928                                 }
3929                                 _monitor_send->set_can_pan (false);
3930                                 break;
3931                         case AfterFaderListen:
3932                                 switch (Config->get_afl_position ()) {
3933                                 case AFLFromBeforeProcessors:
3934                                         new_processors.insert (after_amp, _monitor_send);
3935                                         break;
3936                                 case AFLFromAfterProcessors:
3937                                         new_processors.insert (new_processors.end(), _monitor_send);
3938                                         break;
3939                                 }
3940                                 _monitor_send->set_can_pan (true);
3941                                 break;
3942                         }
3943                 }  else {
3944                         new_processors.insert (new_processors.end(), _monitor_send);
3945                         _monitor_send->set_can_pan (false);
3946                 }
3947         }
3948
3949         /* MONITOR CONTROL */
3950
3951         if (_monitor_control && is_monitor ()) {
3952                 assert (!_monitor_control->display_to_user ());
3953                 new_processors.push_front (_monitor_control);
3954         }
3955
3956         /* INTERNAL RETURN */
3957
3958         /* doing this here means that any monitor control will come just after
3959            the return.
3960         */
3961
3962         if (_intreturn) {
3963                 assert (!_intreturn->display_to_user ());
3964                 new_processors.push_front (_intreturn);
3965         }
3966
3967         /* EXPORT PROCESSOR */
3968
3969         if (_capturing_processor) {
3970                 assert (!_capturing_processor->display_to_user ());
3971                 new_processors.push_front (_capturing_processor);
3972         }
3973
3974         _processors = new_processors;
3975
3976         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3977         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3978                 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3979         }
3980 }
3981
3982 void
3983 Route::unpan ()
3984 {
3985         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3986         Glib::RWLock::ReaderLock lp (_processor_lock);
3987
3988         _pannable.reset ();
3989
3990         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3991                 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);
3992                 if (d) {
3993                         d->unpan ();
3994                 }
3995         }
3996 }
3997
3998 /** If the meter point is `Custom', make a note of where the meter is.
3999  *  This is so that if the meter point is subsequently set to something else,
4000  *  and then back to custom, we can put the meter back where it was last time
4001  *  custom was enabled.
4002  *
4003  *  Must be called with the _processor_lock held.
4004  */
4005 void
4006 Route::maybe_note_meter_position ()
4007 {
4008         if (_meter_point != MeterCustom) {
4009                 return;
4010         }
4011
4012         _custom_meter_position_noted = true;
4013         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
4014                 if (boost::dynamic_pointer_cast<PeakMeter> (*i)) {
4015                         ProcessorList::iterator j = i;
4016                         ++j;
4017                         if (j != _processors.end ()) {
4018                                 _processor_after_last_custom_meter = *j;
4019                                 _last_custom_meter_was_at_end = false;
4020                         } else {
4021                                 _last_custom_meter_was_at_end = true;
4022                         }
4023                 }
4024         }
4025 }
4026
4027 boost::shared_ptr<Processor>
4028 Route::processor_by_id (PBD::ID id) const
4029 {
4030         Glib::RWLock::ReaderLock lm (_processor_lock);
4031         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4032                 if ((*i)->id() == id) {
4033                         return *i;
4034                 }
4035         }
4036
4037         return boost::shared_ptr<Processor> ();
4038 }
4039
4040 /** @return the monitoring state, or in other words what data we are pushing
4041  *  into the route (data from the inputs, data from disk or silence)
4042  */
4043 MonitorState
4044 Route::monitoring_state () const
4045 {
4046         return MonitoringInput;
4047 }
4048
4049 /** @return what we should be metering; either the data coming from the input
4050  *  IO or the data that is flowing through the route.
4051  */
4052 MeterState
4053 Route::metering_state () const
4054 {
4055         return MeteringRoute;
4056 }
4057
4058 bool
4059 Route::has_external_redirects () const
4060 {
4061         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4062
4063                 /* ignore inactive processors and obviously ignore the main
4064                  * outs since everything has them and we don't care.
4065                  */
4066
4067                 if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
4068                         return true;;
4069                 }
4070         }
4071
4072         return false;
4073 }
4074
4075 boost::shared_ptr<Processor>
4076 Route::the_instrument () const
4077 {
4078         Glib::RWLock::WriterLock lm (_processor_lock);
4079         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
4080                 if (boost::dynamic_pointer_cast<PluginInsert>(*i)) {
4081                         if ((*i)->input_streams().n_midi() > 0 &&
4082                             (*i)->output_streams().n_audio() > 0) {
4083                                 return (*i);
4084                         }
4085                 }
4086         }
4087         return boost::shared_ptr<Processor>();
4088 }