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