libs/ardour/route.cc

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