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