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