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