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