libs/ardour/route.cc

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