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