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