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 #include <cmath>
  21 #include <fstream>
  22 #include <cassert>
  23 #include <algorithm>
  24
  25 #include "pbd/xml++.h"
  26 #include "pbd/enumwriter.h"
  27 #include "pbd/memento_command.h"
  28 #include "pbd/stacktrace.h"
  29 #include "pbd/convert.h"
  30 #include "pbd/boost_debug.h"
  31
  32 #include "evoral/Curve.hpp"
  33
  34 #include "ardour/amp.h"
  35 #include "ardour/audio_port.h"
  36 #include "ardour/audioengine.h"
  37 #include "ardour/buffer.h"
  38 #include "ardour/buffer_set.h"
  39 #include "ardour/configuration.h"
  40 #include "ardour/cycle_timer.h"
  41 #include "ardour/debug.h"
  42 #include "ardour/delivery.h"
  43 #include "ardour/dB.h"
  44 #include "ardour/internal_send.h"
  45 #include "ardour/internal_return.h"
  46 #include "ardour/ladspa_plugin.h"
  47 #include "ardour/meter.h"
  48 #include "ardour/mix.h"
  49 #include "ardour/monitor_processor.h"
  50 #include "ardour/pannable.h"
  51 #include "ardour/panner.h"
  52 #include "ardour/panner_shell.h"
  53 #include "ardour/plugin_insert.h"
  54 #include "ardour/port.h"
  55 #include "ardour/port_insert.h"
  56 #include "ardour/processor.h"
  57 #include "ardour/profile.h"
  58 #include "ardour/route.h"
  59 #include "ardour/route_group.h"
  60 #include "ardour/send.h"
  61 #include "ardour/session.h"
  62 #include "ardour/timestamps.h"
  63 #include "ardour/utils.h"
  64 #include "ardour/graph.h"
  65 #include "ardour/unknown_processor.h"
  66 #include "ardour/capturing_processor.h"
  67
  68 #include "i18n.h"
  69
  70 using namespace std;
  71 using namespace ARDOUR;
  72 using namespace PBD;
  73
  74 uint32_t Route::order_key_cnt = 0;
  75 PBD::Signal1<void,string const&> Route::SyncOrderKeys;
  76 PBD::Signal0<void> Route::RemoteControlIDChange;
  77
  78 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
  79         : SessionObject (sess, name)
  80         , Automatable (sess)
  81         , GraphNode( sess.route_graph )
  82         , _active (true)
  83         , _initial_delay (0)
  84         , _roll_delay (0)
  85         , _flags (flg)
  86         , _pending_declick (true)
  87         , _meter_point (MeterPostFader)
  88         , _self_solo (false)
  89         , _soloed_by_others_upstream (0)
  90         , _soloed_by_others_downstream (0)
  91         , _solo_isolated (0)
  92         , _denormal_protection (false)
  93         , _recordable (true)
  94         , _silent (false)
  95         , _declickable (false)
  96         , _solo_control (new SoloControllable (X_("solo"), *this))
  97         , _mute_control (new MuteControllable (X_("mute"), *this))
  98         , _mute_master (new MuteMaster (sess, name))
  99         , _have_internal_generator (false)
 100         , _solo_safe (false)
 101         , _default_type (default_type)
 102         , _remote_control_id (0)
 103         , _in_configure_processors (false)
 104 {
 105         processor_max_streams.reset();
 106         order_keys[N_("signal")] = order_key_cnt++;
 107 }
 108
 109 int
 110 Route::init ()
 111 {
 112         /* add standard controls */
 113
 114         _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
 115         _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
 116
 117         add_control (_solo_control);
 118         add_control (_mute_control);
 119
 120         /* panning */
 121
 122         Pannable* p = new Pannable (_session);
 123         boost_debug_shared_ptr_mark_interesting (p, "Pannable");
 124         _pannable.reset (p);
 125
 126         /* input and output objects */
 127
 128         _input.reset (new IO (_session, _name, IO::Input, _default_type));
 129         _output.reset (new IO (_session, _name, IO::Output, _default_type));
 130
 131         _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
 132         _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
 133
 134         _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
 135
 136         /* add amp processor  */
 137
 138         _amp.reset (new Amp (_session));
 139         add_processor (_amp, PostFader);
 140
 141         /* add standard processors: meter, main outs, monitor out */
 142
 143         _meter.reset (new PeakMeter (_session));
 144         _meter->set_display_to_user (false);
 145
 146         add_processor (_meter, PostFader);
 147
 148         _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
 149
 150         add_processor (_main_outs, PostFader);
 151
 152         if (is_monitor()) {
 153                 /* where we listen to tracks */
 154                 _intreturn.reset (new InternalReturn (_session));
 155                 add_processor (_intreturn, PreFader);
 156
 157                 ProcessorList::iterator i;
 158
 159                 for (i = _processors.begin(); i != _processors.end(); ++i) {
 160                         if (*i == _intreturn) {
 161                                 ++i;
 162                                 break;
 163                         }
 164                 }
 165
 166                 /* the thing that provides proper control over a control/monitor/listen bus
 167                    (such as per-channel cut, dim, solo, invert, etc).
 168                    It always goes right after the internal return;
 169                  */
 170                 _monitor_control.reset (new MonitorProcessor (_session));
 171                 add_processor (_monitor_control, i);
 172
 173                 /* no panning on the monitor main outs */
 174
 175 #ifdef PANNER_HACKS
 176                 _main_outs->panner()->set_bypassed (true);
 177 #endif
 178         }
 179
 180         if (is_master() || is_monitor() || is_hidden()) {
 181                 _mute_master->set_solo_ignore (true);
 182         }
 183
 184         /* now that we have _meter, its safe to connect to this */
 185
 186         Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
 187
 188         return 0;
 189 }
 190
 191 Route::~Route ()
 192 {
 193         DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
 194
 195         /* do this early so that we don't get incoming signals as we are going through destruction
 196          */
 197
 198         drop_connections ();
 199
 200         /* don't use clear_processors here, as it depends on the session which may
 201            be half-destroyed by now
 202         */
 203
 204         Glib::RWLock::WriterLock lm (_processor_lock);
 205         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 206                 (*i)->drop_references ();
 207         }
 208
 209         _processors.clear ();
 210 }
 211
 212 void
 213 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
 214 {
 215         if (id != _remote_control_id) {
 216                 _remote_control_id = id;
 217                 RemoteControlIDChanged ();
 218                 if (notify_class_listeners) {
 219                         RemoteControlIDChange ();
 220                 }
 221         }
 222 }
 223
 224 uint32_t
 225 Route::remote_control_id() const
 226 {
 227         return _remote_control_id;
 228 }
 229
 230 int32_t
 231 Route::order_key (std::string const & name) const
 232 {
 233         OrderKeys::const_iterator i = order_keys.find (name);
 234         if (i == order_keys.end()) {
 235                 return -1;
 236         }
 237
 238         return i->second;
 239 }
 240
 241 void
 242 Route::set_order_key (std::string const & name, int32_t n)
 243 {
 244         bool changed = false;
 245
 246         /* This method looks more complicated than it should, but
 247            it's important that we don't emit order_key_changed unless
 248            it actually has, as expensive things happen on receipt of that
 249            signal.
 250         */
 251
 252         if (order_keys.find(name) == order_keys.end() || order_keys[name] != n) {
 253                 order_keys[name] = n;
 254                 changed = true;
 255         }
 256
 257         if (Config->get_sync_all_route_ordering()) {
 258                 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
 259                         if (x->second != n) {
 260                                 x->second = n;
 261                                 changed = true;
 262                         }
 263                 }
 264         }
 265
 266         if (changed) {
 267                 order_key_changed (); /* EMIT SIGNAL */
 268                 _session.set_dirty ();
 269         }
 270 }
 271
 272 /** Set all order keys to be the same as that for `base', if such a key
 273  *  exists in this route.
 274  *  @param base Base key.
 275  */
 276 void
 277 Route::sync_order_keys (std::string const & base)
 278 {
 279         if (order_keys.empty()) {
 280                 return;
 281         }
 282
 283         OrderKeys::iterator i;
 284         int32_t key;
 285
 286         if ((i = order_keys.find (base)) == order_keys.end()) {
 287                 /* key doesn't exist, use the first existing key (during session initialization) */
 288                 i = order_keys.begin();
 289                 key = i->second;
 290                 ++i;
 291         } else {
 292                 /* key exists - use it and reset all others (actually, itself included) */
 293                 key = i->second;
 294                 i = order_keys.begin();
 295         }
 296
 297         bool changed = false;
 298
 299         for (; i != order_keys.end(); ++i) {
 300                 if (i->second != key) {
 301                         i->second = key;
 302                         changed = true;
 303                 }
 304         }
 305
 306         if (changed) {
 307                 order_key_changed (); /* EMIT SIGNAL */
 308         }
 309 }
 310
 311 string
 312 Route::ensure_track_or_route_name(string name, Session &session)
 313 {
 314         string newname = name;
 315
 316         while (!session.io_name_is_legal (newname)) {
 317                 newname = bump_name_once (newname, '.');
 318         }
 319
 320         return newname;
 321 }
 322
 323
 324 void
 325 Route::inc_gain (gain_t fraction, void *src)
 326 {
 327         _amp->inc_gain (fraction, src);
 328 }
 329
 330 void
 331 Route::set_gain (gain_t val, void *src)
 332 {
 333         if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
 334
 335                 if (_route_group->is_relative()) {
 336
 337                         gain_t usable_gain = _amp->gain();
 338                         if (usable_gain < 0.000001f) {
 339                                 usable_gain = 0.000001f;
 340                         }
 341
 342                         gain_t delta = val;
 343                         if (delta < 0.000001f) {
 344                                 delta = 0.000001f;
 345                         }
 346
 347                         delta -= usable_gain;
 348
 349                         if (delta == 0.0f)
 350                                 return;
 351
 352                         gain_t factor = delta / usable_gain;
 353
 354                         if (factor > 0.0f) {
 355                                 factor = _route_group->get_max_factor(factor);
 356                                 if (factor == 0.0f) {
 357                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 358                                         return;
 359                                 }
 360                         } else {
 361                                 factor = _route_group->get_min_factor(factor);
 362                                 if (factor == 0.0f) {
 363                                         _amp->gain_control()->Changed(); /* EMIT SIGNAL */
 364                                         return;
 365                                 }
 366                         }
 367
 368                         _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
 369
 370                 } else {
 371
 372                         _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
 373                 }
 374
 375                 return;
 376         }
 377
 378         if (val == _amp->gain()) {
 379                 return;
 380         }
 381
 382         _amp->set_gain (val, src);
 383 }
 384
 385 /** Process this route for one (sub) cycle (process thread)
 386  *
 387  * @param bufs Scratch buffers to use for the signal path
 388  * @param start_frame Initial transport frame
 389  * @param end_frame Final transport frame
 390  * @param nframes Number of frames to output (to ports)
 391  *
 392  * Note that (end_frame - start_frame) may not be equal to nframes when the
 393  * transport speed isn't 1.0 (eg varispeed).
 394  */
 395 void
 396 Route::process_output_buffers (BufferSet& bufs,
 397                                framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
 398                                bool /*with_processors*/, int declick,
 399                                bool gain_automation_ok)
 400 {
 401         bool monitor;
 402
 403         bufs.is_silent (false);
 404
 405         switch (Config->get_monitoring_model()) {
 406         case HardwareMonitoring:
 407         case ExternalMonitoring:
 408                 monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
 409                 break;
 410         default:
 411                 monitor = true;
 412         }
 413
 414         if (!declick) {
 415                 declick = _pending_declick;
 416         }
 417
 418         /* figure out if we're going to use gain automation */
 419         if (gain_automation_ok) {
 420                 _amp->setup_gain_automation (start_frame, end_frame, nframes);
 421         } else {
 422                 _amp->apply_gain_automation (false);
 423         }
 424
 425         /* tell main outs what to do about monitoring */
 426         _main_outs->no_outs_cuz_we_no_monitor (!monitor);
 427
 428
 429         /* -------------------------------------------------------------------------------------------
 430            GLOBAL DECLICK (for transport changes etc.)
 431            ----------------------------------------------------------------------------------------- */
 432
 433         if (declick > 0) {
 434                 Amp::declick (bufs, nframes, 1);
 435         } else if (declick < 0) {
 436                 Amp::declick (bufs, nframes, -1);
 437         }
 438
 439         _pending_declick = 0;
 440
 441         /* -------------------------------------------------------------------------------------------
 442            DENORMAL CONTROL/PHASE INVERT
 443            ----------------------------------------------------------------------------------------- */
 444
 445         if (_phase_invert.any ()) {
 446
 447                 int chn = 0;
 448
 449                 if (_denormal_protection || Config->get_denormal_protection()) {
 450
 451                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 452                                 Sample* const sp = i->data();
 453
 454                                 if (_phase_invert[chn]) {
 455                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 456                                                 sp[nx]  = -sp[nx];
 457                                                 sp[nx] += 1.0e-27f;
 458                                         }
 459                                 } else {
 460                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 461                                                 sp[nx] += 1.0e-27f;
 462                                         }
 463                                 }
 464                         }
 465
 466                 } else {
 467
 468                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
 469                                 Sample* const sp = i->data();
 470
 471                                 if (_phase_invert[chn]) {
 472                                         for (pframes_t nx = 0; nx < nframes; ++nx) {
 473                                                 sp[nx] = -sp[nx];
 474                                         }
 475                                 }
 476                         }
 477                 }
 478
 479         } else {
 480
 481                 if (_denormal_protection || Config->get_denormal_protection()) {
 482
 483                         for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
 484                                 Sample* const sp = i->data();
 485                                 for (pframes_t nx = 0; nx < nframes; ++nx) {
 486                                         sp[nx] += 1.0e-27f;
 487                                 }
 488                         }
 489
 490                 }
 491         }
 492
 493         /* -------------------------------------------------------------------------------------------
 494            and go ....
 495            ----------------------------------------------------------------------------------------- */
 496
 497         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 498
 499                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
 500                         break;
 501                 }
 502
 503                 if (bufs.count() != (*i)->input_streams()) {
 504                         cerr << _name << " bufs = " << bufs.count()
 505                              << " input for " << (*i)->name() << " = " << (*i)->input_streams()
 506                              << endl;
 507                 }
 508                 assert (bufs.count() == (*i)->input_streams());
 509
 510                 /* should we NOT run plugins here if the route is inactive?
 511                    do we catch route != active somewhere higher?
 512                 */
 513
 514                 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
 515                 bufs.set_count ((*i)->output_streams());
 516         }
 517 }
 518
 519 ChanCount
 520 Route::n_process_buffers ()
 521 {
 522         return max (_input->n_ports(), processor_max_streams);
 523 }
 524
 525 void
 526 Route::passthru (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 527 {
 528         BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 529
 530         _silent = false;
 531
 532         assert (bufs.available() >= input_streams());
 533
 534         if (_input->n_ports() == ChanCount::ZERO) {
 535                 silence_unlocked (nframes);
 536         }
 537
 538         bufs.set_count (input_streams());
 539
 540         if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
 541
 542                 /* control/monitor bus ignores input ports when something is
 543                    feeding the listen "stream". data will "arrive" into the
 544                    route from the intreturn processor element.
 545                 */
 546                 bufs.silence (nframes, 0);
 547
 548         } else {
 549
 550                 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 551
 552                         BufferSet::iterator o = bufs.begin(*t);
 553                         PortSet& ports (_input->ports());
 554
 555                         for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
 556                                 o->read_from (i->get_buffer(nframes), nframes);
 557                         }
 558                 }
 559         }
 560
 561         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 562         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, true);
 563 }
 564
 565 void
 566 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
 567 {
 568         BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
 569         bufs.set_count (_input->n_ports());
 570         write_out_of_band_data (bufs, start_frame, end_frame, nframes);
 571         process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, false);
 572 }
 573
 574 void
 575 Route::set_listen (bool yn, void* src)
 576 {
 577         if (_solo_safe) {
 578                 return;
 579         }
 580
 581         if (_monitor_send) {
 582                 if (yn != _monitor_send->active()) {
 583                         if (yn) {
 584                                 _monitor_send->activate ();
 585                                 _mute_master->set_soloed (true);
 586                         } else {
 587                                 _monitor_send->deactivate ();
 588                                 _mute_master->set_soloed (false);
 589                         }
 590
 591                         listen_changed (src); /* EMIT SIGNAL */
 592                 }
 593         }
 594 }
 595
 596 bool
 597 Route::listening () const
 598 {
 599         if (_monitor_send) {
 600                 return _monitor_send->active ();
 601         } else {
 602                 return false;
 603         }
 604 }
 605
 606 void
 607 Route::set_solo_safe (bool yn, void *src)
 608 {
 609         if (_solo_safe != yn) {
 610                 _solo_safe = yn;
 611                 solo_safe_changed (src);
 612         }
 613 }
 614
 615 bool
 616 Route::solo_safe() const
 617 {
 618         return _solo_safe;
 619 }
 620
 621 void
 622 Route::set_solo (bool yn, void *src)
 623 {
 624         if (_solo_safe) {
 625                 return;
 626         }
 627
 628         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 629                 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
 630                 return;
 631         }
 632
 633         if (self_soloed() != yn) {
 634                 set_self_solo (yn);
 635                 set_mute_master_solo ();
 636                 solo_changed (true, src); /* EMIT SIGNAL */
 637                 _solo_control->Changed (); /* EMIT SIGNAL */
 638         }
 639 }
 640
 641 void
 642 Route::set_self_solo (bool yn)
 643 {
 644         _self_solo = yn;
 645 }
 646
 647 void
 648 Route::mod_solo_by_others_upstream (int32_t delta)
 649 {
 650         if (_solo_safe) {
 651                 return;
 652         }
 653
 654         uint32_t old_sbu = _soloed_by_others_upstream;
 655
 656         if (delta < 0) {
 657                 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
 658                         _soloed_by_others_upstream += delta;
 659                 } else {
 660                         _soloed_by_others_upstream = 0;
 661                 }
 662         } else {
 663                 _soloed_by_others_upstream += delta;
 664         }
 665
 666         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
 667                                                   name(), delta, _soloed_by_others_upstream, old_sbu,
 668                                                   _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
 669
 670         /* push the inverse solo change to everything that feeds us.
 671
 672            This is important for solo-within-group. When we solo 1 track out of N that
 673            feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
 674            on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
 675            tracks that feed it. This will silence them if they were audible because
 676            of a bus solo, but the newly soloed track will still be audible (because
 677            it is self-soloed).
 678
 679            but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
 680            not in reverse.
 681          */
 682
 683         if ((_self_solo || _soloed_by_others_downstream) &&
 684             ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
 685              (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
 686
 687                 if (delta > 0 || !Config->get_exclusive_solo()) {
 688                         DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
 689                         for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
 690                                 boost::shared_ptr<Route> sr = i->r.lock();
 691                                 if (sr) {
 692                                         sr->mod_solo_by_others_downstream (-delta);
 693                                 }
 694                         }
 695                 }
 696         }
 697
 698         set_mute_master_solo ();
 699         solo_changed (false, this);
 700 }
 701
 702 void
 703 Route::mod_solo_by_others_downstream (int32_t delta)
 704 {
 705         if (_solo_safe) {
 706                 return;
 707         }
 708
 709         if (delta < 0) {
 710                 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
 711                         _soloed_by_others_downstream += delta;
 712                 } else {
 713                         _soloed_by_others_downstream = 0;
 714                 }
 715         } else {
 716                 _soloed_by_others_downstream += delta;
 717         }
 718
 719         DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
 720
 721         set_mute_master_solo ();
 722         solo_changed (false, this);
 723 }
 724
 725 void
 726 Route::set_mute_master_solo ()
 727 {
 728         _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
 729 }
 730
 731 void
 732 Route::set_solo_isolated (bool yn, void *src)
 733 {
 734         if (is_master() || is_monitor() || is_hidden()) {
 735                 return;
 736         }
 737
 738         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
 739                 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
 740                 return;
 741         }
 742
 743         /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
 744
 745         boost::shared_ptr<RouteList> routes = _session.get_routes ();
 746         for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
 747
 748                 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
 749                         continue;
 750                 }
 751
 752                 bool sends_only;
 753                 bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
 754
 755                 if (does_feed && !sends_only) {
 756                         (*i)->set_solo_isolated (yn, (*i)->route_group());
 757                 }
 758         }
 759
 760         /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
 761
 762         bool changed = false;
 763
 764         if (yn) {
 765                 if (_solo_isolated == 0) {
 766                         _mute_master->set_solo_ignore (true);
 767                         changed = true;
 768                 }
 769                 _solo_isolated++;
 770         } else {
 771                 if (_solo_isolated > 0) {
 772                         _solo_isolated--;
 773                         if (_solo_isolated == 0) {
 774                                 _mute_master->set_solo_ignore (false);
 775                                 changed = true;
 776                         }
 777                 }
 778         }
 779
 780         if (changed) {
 781                 solo_isolated_changed (src);
 782         }
 783 }
 784
 785 bool
 786 Route::solo_isolated () const
 787 {
 788         return _solo_isolated > 0;
 789 }
 790
 791 void
 792 Route::set_mute_points (MuteMaster::MutePoint mp)
 793 {
 794         _mute_master->set_mute_points (mp);
 795         mute_points_changed (); /* EMIT SIGNAL */
 796
 797         if (_mute_master->muted_by_self()) {
 798                 mute_changed (this); /* EMIT SIGNAL */
 799                 _mute_control->Changed (); /* EMIT SIGNAL */
 800         }
 801 }
 802
 803 void
 804 Route::set_mute (bool yn, void *src)
 805 {
 806         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
 807                 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
 808                 return;
 809         }
 810
 811         if (muted() != yn) {
 812                 _mute_master->set_muted_by_self (yn);
 813                 mute_changed (src); /* EMIT SIGNAL */
 814                 _mute_control->Changed (); /* EMIT SIGNAL */
 815         }
 816 }
 817
 818 bool
 819 Route::muted () const
 820 {
 821         return _mute_master->muted_by_self();
 822 }
 823
 824 #if 0
 825 static void
 826 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
 827 {
 828         cerr << name << " {" << endl;
 829         for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
 830                         p != procs.end(); ++p) {
 831                 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
 832         }
 833         cerr << "}" << endl;
 834 }
 835 #endif
 836
 837 int
 838 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
 839 {
 840         ProcessorList::iterator loc;
 841
 842         /* XXX this is not thread safe - we don't hold the lock across determining the iter
 843            to add before and actually doing the insertion. dammit.
 844         */
 845
 846         if (placement == PreFader) {
 847                 /* generic pre-fader: insert immediately before the amp */
 848                 loc = find (_processors.begin(), _processors.end(), _amp);
 849         } else {
 850                 /* generic post-fader: insert right before the main outs */
 851                 loc = find (_processors.begin(), _processors.end(), _main_outs);
 852         }
 853
 854         return add_processor (processor, loc, err);
 855 }
 856
 857
 858 /** Add a processor to the route.
 859  * @a iter must point to an iterator in _processors and the new
 860  * processor will be inserted immediately before this location.  Otherwise,
 861  * @a position is used.
 862  */
 863 int
 864 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
 865 {
 866         ChanCount old_pms = processor_max_streams;
 867
 868         if (!_session.engine().connected() || !processor) {
 869                 return 1;
 870         }
 871
 872         {
 873                 Glib::RWLock::WriterLock lm (_processor_lock);
 874
 875                 boost::shared_ptr<PluginInsert> pi;
 876                 boost::shared_ptr<PortInsert> porti;
 877
 878                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
 879
 880                 if (processor == _amp || processor == _meter || processor == _main_outs) {
 881                         // Ensure only one of these are in the list at any time
 882                         if (loc != _processors.end()) {
 883                                 if (iter == loc) { // Already in place, do nothing
 884                                         return 0;
 885                                 } else { // New position given, relocate
 886                                         _processors.erase (loc);
 887                                 }
 888                         }
 889
 890                 } else {
 891                         if (loc != _processors.end()) {
 892                                 cerr << "ERROR: Processor added to route twice!" << endl;
 893                                 return 1;
 894                         }
 895
 896                         loc = iter;
 897                 }
 898
 899                 _processors.insert (loc, processor);
 900
 901                 // Set up processor list channels.  This will set processor->[input|output]_streams(),
 902                 // configure redirect ports properly, etc.
 903
 904                 {
 905                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
 906
 907                         if (configure_processors_unlocked (err)) {
 908                                 ProcessorList::iterator ploc = loc;
 909                                 --ploc;
 910                                 _processors.erase(ploc);
 911                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
 912                                 cerr << "configure failed\n";
 913                                 return -1;
 914                         }
 915                 }
 916
 917                 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
 918
 919                         if (pi->natural_input_streams() == ChanCount::ZERO) {
 920                                 /* generator plugin */
 921                                 _have_internal_generator = true;
 922                         }
 923
 924                 }
 925
 926                 /* is this the monitor send ? if so, make sure we keep track of it */
 927
 928                 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
 929
 930                 if (isend && _session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
 931                         _monitor_send = isend;
 932                 }
 933
 934                 if (activation_allowed && (processor != _monitor_send)) {
 935                         processor->activate ();
 936                 }
 937
 938                 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
 939
 940                 _output->set_user_latency (0);
 941         }
 942
 943         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
 944         set_processor_positions ();
 945
 946         return 0;
 947 }
 948
 949 bool
 950 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
 951 {
 952         const XMLProperty *prop;
 953
 954         try {
 955                 boost::shared_ptr<Processor> processor;
 956
 957                 /* bit of a hack: get the `placement' property from the <Redirect> tag here
 958                    so that we can add the processor in the right place (pre/post-fader)
 959                 */
 960
 961                 XMLNodeList const & children = node.children ();
 962                 XMLNodeList::const_iterator i = children.begin ();
 963
 964                 while (i != children.end() && (*i)->name() != X_("Redirect")) {
 965                         ++i;
 966                 }
 967
 968                 Placement placement = PreFader;
 969
 970                 if (i != children.end()) {
 971                         if ((prop = (*i)->property (X_("placement"))) != 0) {
 972                                 placement = Placement (string_2_enum (prop->value(), placement));
 973                         }
 974                 }
 975
 976                 if (node.name() == "Insert") {
 977
 978                         if ((prop = node.property ("type")) != 0) {
 979
 980                                 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
 981                                                 prop->value() == "lv2" ||
 982                                                 prop->value() == "vst" ||
 983                                                 prop->value() == "audiounit") {
 984
 985                                         processor.reset (new PluginInsert (_session));
 986
 987                                 } else {
 988
 989                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
 990                                 }
 991
 992                         }
 993
 994                 } else if (node.name() == "Send") {
 995
 996                         processor.reset (new Send (_session, _pannable, _mute_master));
 997
 998                 } else {
 999
1000                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1001                         return false;
1002                 }
1003
1004                 if (processor->set_state (node, version)) {
1005                         return false;
1006                 }
1007
1008                 return (add_processor (processor, placement) == 0);
1009         }
1010
1011         catch (failed_constructor &err) {
1012                 warning << _("processor could not be created. Ignored.") << endmsg;
1013                 return false;
1014         }
1015 }
1016
1017 int
1018 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1019 {
1020         /* NOTE: this is intended to be used ONLY when copying
1021            processors from another Route. Hence the subtle
1022            differences between this and ::add_processor()
1023         */
1024
1025         ProcessorList::iterator loc;
1026
1027         if (before) {
1028                 loc = find(_processors.begin(), _processors.end(), before);
1029         } else {
1030                 /* nothing specified - at end but before main outs */
1031                 loc = find (_processors.begin(), _processors.end(), _main_outs);
1032         }
1033
1034         ChanCount old_pms = processor_max_streams;
1035
1036         if (!_session.engine().connected()) {
1037                 return 1;
1038         }
1039
1040         if (others.empty()) {
1041                 return 0;
1042         }
1043
1044         {
1045                 Glib::RWLock::WriterLock lm (_processor_lock);
1046
1047                 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
1048
1049                 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1050
1051                         // Ensure meter only appears in the list once
1052                         if (*i == _meter) {
1053                                 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
1054                                 if (m != _processors.end()) {
1055                                         _processors.erase(m);
1056                                 }
1057                         }
1058
1059                         boost::shared_ptr<PluginInsert> pi;
1060
1061                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1062                                 pi->set_count (1);
1063
1064                                 ChanCount m = max (pi->input_streams(), pi->output_streams());
1065
1066                                 if (m > potential_max_streams) {
1067                                         potential_max_streams = m;
1068                                 }
1069                         }
1070
1071                         ProcessorList::iterator inserted = _processors.insert (loc, *i);
1072
1073                         if ((*i)->active()) {
1074                                 (*i)->activate ();
1075                         }
1076
1077                         {
1078                                 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1079                                 if (configure_processors_unlocked (err)) {
1080                                         _processors.erase (inserted);
1081                                         configure_processors_unlocked (0); // it worked before we tried to add it ...
1082                                         return -1;
1083                                 }
1084                         }
1085
1086                         (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
1087                 }
1088
1089                 _output->set_user_latency (0);
1090         }
1091
1092         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1093         set_processor_positions ();
1094
1095         return 0;
1096 }
1097
1098 void
1099 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1100 {
1101         if (p == PreFader) {
1102                 start = _processors.begin();
1103                 end = find(_processors.begin(), _processors.end(), _amp);
1104         } else {
1105                 start = find(_processors.begin(), _processors.end(), _amp);
1106                 ++start;
1107                 end = _processors.end();
1108         }
1109 }
1110
1111 /** Turn off all processors with a given placement
1112  * @param p Placement of processors to disable
1113  */
1114 void
1115 Route::disable_processors (Placement p)
1116 {
1117         Glib::RWLock::ReaderLock lm (_processor_lock);
1118
1119         ProcessorList::iterator start, end;
1120         placement_range(p, start, end);
1121
1122         for (ProcessorList::iterator i = start; i != end; ++i) {
1123                 (*i)->deactivate ();
1124         }
1125
1126         _session.set_dirty ();
1127 }
1128
1129 /** Turn off all redirects
1130  */
1131 void
1132 Route::disable_processors ()
1133 {
1134         Glib::RWLock::ReaderLock lm (_processor_lock);
1135
1136         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1137                 (*i)->deactivate ();
1138         }
1139
1140         _session.set_dirty ();
1141 }
1142
1143 /** Turn off all redirects with a given placement
1144  * @param p Placement of redirects to disable
1145  */
1146 void
1147 Route::disable_plugins (Placement p)
1148 {
1149         Glib::RWLock::ReaderLock lm (_processor_lock);
1150
1151         ProcessorList::iterator start, end;
1152         placement_range(p, start, end);
1153
1154         for (ProcessorList::iterator i = start; i != end; ++i) {
1155                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1156                         (*i)->deactivate ();
1157                 }
1158         }
1159
1160         _session.set_dirty ();
1161 }
1162
1163 /** Turn off all plugins
1164  */
1165 void
1166 Route::disable_plugins ()
1167 {
1168         Glib::RWLock::ReaderLock lm (_processor_lock);
1169
1170         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1171                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1172                         (*i)->deactivate ();
1173                 }
1174         }
1175
1176         _session.set_dirty ();
1177 }
1178
1179
1180 void
1181 Route::ab_plugins (bool forward)
1182 {
1183         Glib::RWLock::ReaderLock lm (_processor_lock);
1184
1185         if (forward) {
1186
1187                 /* forward = turn off all active redirects, and mark them so that the next time
1188                    we go the other way, we will revert them
1189                 */
1190
1191                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1192                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1193                                 continue;
1194                         }
1195
1196                         if ((*i)->active()) {
1197                                 (*i)->deactivate ();
1198                                 (*i)->set_next_ab_is_active (true);
1199                         } else {
1200                                 (*i)->set_next_ab_is_active (false);
1201                         }
1202                 }
1203
1204         } else {
1205
1206                 /* backward = if the redirect was marked to go active on the next ab, do so */
1207
1208                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1209
1210                         if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1211                                 continue;
1212                         }
1213
1214                         if ((*i)->get_next_ab_is_active()) {
1215                                 (*i)->activate ();
1216                         } else {
1217                                 (*i)->deactivate ();
1218                         }
1219                 }
1220         }
1221
1222         _session.set_dirty ();
1223 }
1224
1225
1226 /** Remove processors with a given placement.
1227  * @param p Placement of processors to remove.
1228  */
1229 void
1230 Route::clear_processors (Placement p)
1231 {
1232         const ChanCount old_pms = processor_max_streams;
1233
1234         if (!_session.engine().connected()) {
1235                 return;
1236         }
1237
1238         bool already_deleting = _session.deletion_in_progress();
1239         if (!already_deleting) {
1240                 _session.set_deletion_in_progress();
1241         }
1242
1243         {
1244                 Glib::RWLock::WriterLock lm (_processor_lock);
1245                 ProcessorList new_list;
1246                 ProcessorStreams err;
1247                 bool seen_amp = false;
1248
1249                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1250
1251                         if (*i == _amp) {
1252                                 seen_amp = true;
1253                         }
1254
1255                         if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1256
1257                                 /* you can't remove these */
1258
1259                                 new_list.push_back (*i);
1260
1261                         } else {
1262                                 if (seen_amp) {
1263
1264                                         switch (p) {
1265                                         case PreFader:
1266                                                 new_list.push_back (*i);
1267                                                 break;
1268                                         case PostFader:
1269                                                 (*i)->drop_references ();
1270                                                 break;
1271                                         }
1272
1273                                 } else {
1274
1275                                         switch (p) {
1276                                         case PreFader:
1277                                                 (*i)->drop_references ();
1278                                                 break;
1279                                         case PostFader:
1280                                                 new_list.push_back (*i);
1281                                                 break;
1282                                         }
1283                                 }
1284                         }
1285                 }
1286
1287                 _processors = new_list;
1288
1289                 {
1290                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1291                         configure_processors_unlocked (&err); // this can't fail
1292                 }
1293         }
1294
1295         processor_max_streams.reset();
1296         _have_internal_generator = false;
1297         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1298         set_processor_positions ();
1299
1300         if (!already_deleting) {
1301                 _session.clear_deletion_in_progress();
1302         }
1303 }
1304
1305 int
1306 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1307 {
1308         /* these can never be removed */
1309
1310         if (processor == _amp || processor == _meter || processor == _main_outs) {
1311                 return 0;
1312         }
1313
1314         ChanCount old_pms = processor_max_streams;
1315
1316         if (!_session.engine().connected()) {
1317                 return 1;
1318         }
1319
1320         processor_max_streams.reset();
1321
1322         {
1323                 Glib::RWLock::WriterLock lm (_processor_lock);
1324                 ProcessorList::iterator i;
1325                 bool removed = false;
1326
1327                 for (i = _processors.begin(); i != _processors.end(); ) {
1328                         if (*i == processor) {
1329
1330                                 /* move along, see failure case for configure_processors()
1331                                    where we may need to reconfigure the processor.
1332                                 */
1333
1334                                 /* stop redirects that send signals to JACK ports
1335                                    from causing noise as a result of no longer being
1336                                    run.
1337                                 */
1338
1339                                 boost::shared_ptr<IOProcessor> iop;
1340
1341                                 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1342                                         if (iop->input()) {
1343                                                 iop->input()->disconnect (this);
1344                                         }
1345                                         if (iop->output()) {
1346                                                 iop->output()->disconnect (this);
1347                                         }
1348                                 }
1349
1350                                 i = _processors.erase (i);
1351                                 removed = true;
1352                                 break;
1353
1354                         } else {
1355                                 ++i;
1356                         }
1357
1358                         _output->set_user_latency (0);
1359                 }
1360
1361                 if (!removed) {
1362                         /* what? */
1363                         return 1;
1364                 }
1365
1366                 {
1367                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1368
1369                         if (configure_processors_unlocked (err)) {
1370                                 /* get back to where we where */
1371                                 _processors.insert (i, processor);
1372                                 /* we know this will work, because it worked before :) */
1373                                 configure_processors_unlocked (0);
1374                                 return -1;
1375                         }
1376                 }
1377
1378                 _have_internal_generator = false;
1379
1380                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1381                         boost::shared_ptr<PluginInsert> pi;
1382
1383                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1384                                 if (pi->is_generator()) {
1385                                         _have_internal_generator = true;
1386                                         break;
1387                                 }
1388                         }
1389                 }
1390         }
1391
1392         processor->drop_references ();
1393         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1394         set_processor_positions ();
1395
1396         return 0;
1397 }
1398
1399 int
1400 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1401 {
1402         ProcessorList deleted;
1403
1404         if (!_session.engine().connected()) {
1405                 return 1;
1406         }
1407
1408         processor_max_streams.reset();
1409
1410         {
1411                 Glib::RWLock::WriterLock lm (_processor_lock);
1412                 ProcessorList::iterator i;
1413                 boost::shared_ptr<Processor> processor;
1414
1415                 ProcessorList as_we_were = _processors;
1416
1417                 for (i = _processors.begin(); i != _processors.end(); ) {
1418
1419                         processor = *i;
1420
1421                         /* these can never be removed */
1422
1423                         if (processor == _amp || processor == _meter || processor == _main_outs) {
1424                                 ++i;
1425                                 continue;
1426                         }
1427
1428                         /* see if its in the list of processors to delete */
1429
1430                         if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1431                                 ++i;
1432                                 continue;
1433                         }
1434
1435                         /* stop IOProcessors that send to JACK ports
1436                            from causing noise as a result of no longer being
1437                            run.
1438                         */
1439
1440                         boost::shared_ptr<IOProcessor> iop;
1441
1442                         if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1443                                 iop->disconnect ();
1444                         }
1445
1446                         deleted.push_back (processor);
1447                         i = _processors.erase (i);
1448                 }
1449
1450                 if (deleted.empty()) {
1451                         /* none of those in the requested list were found */
1452                         return 0;
1453                 }
1454
1455                 _output->set_user_latency (0);
1456
1457                 {
1458                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1459
1460                         if (configure_processors_unlocked (err)) {
1461                                 /* get back to where we where */
1462                                 _processors = as_we_were;
1463                                 /* we know this will work, because it worked before :) */
1464                                 configure_processors_unlocked (0);
1465                                 return -1;
1466                         }
1467                 }
1468
1469                 _have_internal_generator = false;
1470
1471                 for (i = _processors.begin(); i != _processors.end(); ++i) {
1472                         boost::shared_ptr<PluginInsert> pi;
1473
1474                         if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1475                                 if (pi->is_generator()) {
1476                                         _have_internal_generator = true;
1477                                         break;
1478                                 }
1479                         }
1480                 }
1481         }
1482
1483         /* now try to do what we need to so that those that were removed will be deleted */
1484
1485         for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1486                 (*i)->drop_references ();
1487         }
1488
1489         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1490         set_processor_positions ();
1491
1492         return 0;
1493 }
1494
1495 /** Caller must hold process lock */
1496 int
1497 Route::configure_processors (ProcessorStreams* err)
1498 {
1499         assert (!AudioEngine::instance()->process_lock().trylock());
1500
1501         if (!_in_configure_processors) {
1502                 Glib::RWLock::WriterLock lm (_processor_lock);
1503                 return configure_processors_unlocked (err);
1504         }
1505         return 0;
1506 }
1507
1508 ChanCount
1509 Route::input_streams () const
1510 {
1511         return _input->n_ports ();
1512 }
1513
1514 list<pair<ChanCount, ChanCount> >
1515 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1516 {
1517         Glib::RWLock::ReaderLock lm (_processor_lock);
1518
1519         return try_configure_processors_unlocked (in, err);
1520 }
1521
1522 list<pair<ChanCount, ChanCount> >
1523 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1524 {
1525         // Check each processor in order to see if we can configure as requested
1526         ChanCount out;
1527         list<pair<ChanCount, ChanCount> > configuration;
1528         uint32_t index = 0;
1529
1530         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1531         DEBUG_TRACE (DEBUG::Processors, "{\n");
1532
1533         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1534
1535                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1536                         DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1537                         break;
1538                 }
1539
1540                 if ((*p)->can_support_io_configuration(in, out)) {
1541                         DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1542                         configuration.push_back(make_pair(in, out));
1543                         in = out;
1544                 } else {
1545                         if (err) {
1546                                 err->index = index;
1547                                 err->count = in;
1548                         }
1549                         DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1550                         DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1551                         DEBUG_TRACE (DEBUG::Processors, "}\n");
1552                         return list<pair<ChanCount, ChanCount> > ();
1553                 }
1554         }
1555
1556         DEBUG_TRACE (DEBUG::Processors, "}\n");
1557
1558         return configuration;
1559 }
1560
1561 /** Set the input/output configuration of each processor in the processors list.
1562  *  Caller must hold process lock.
1563  *  Return 0 on success, otherwise configuration is impossible.
1564  */
1565 int
1566 Route::configure_processors_unlocked (ProcessorStreams* err)
1567 {
1568         assert (!AudioEngine::instance()->process_lock().trylock());
1569
1570         if (_in_configure_processors) {
1571                 return 0;
1572         }
1573
1574         _in_configure_processors = true;
1575
1576         list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1577
1578         if (configuration.empty ()) {
1579                 _in_configure_processors = false;
1580                 return -1;
1581         }
1582
1583         ChanCount out;
1584
1585         list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1586         for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1587
1588                 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1589                         break;
1590                 }
1591
1592                 (*p)->configure_io(c->first, c->second);
1593                 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1594                 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1595                 out = c->second;
1596         }
1597
1598         if (_meter) {
1599                 _meter->reset_max_channels (processor_max_streams);
1600         }
1601
1602         /* make sure we have sufficient scratch buffers to cope with the new processor
1603            configuration */
1604         _session.ensure_buffers (n_process_buffers ());
1605
1606         DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1607
1608         _in_configure_processors = false;
1609         return 0;
1610 }
1611
1612 void
1613 Route::all_processors_flip ()
1614 {
1615         Glib::RWLock::ReaderLock lm (_processor_lock);
1616
1617         if (_processors.empty()) {
1618                 return;
1619         }
1620
1621         bool first_is_on = _processors.front()->active();
1622
1623         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1624                 if (first_is_on) {
1625                         (*i)->deactivate ();
1626                 } else {
1627                         (*i)->activate ();
1628                 }
1629         }
1630
1631         _session.set_dirty ();
1632 }
1633
1634 /** Set all processors with a given placement to a given active state.
1635  * @param p Placement of processors to change.
1636  * @param state New active state for those processors.
1637  */
1638 void
1639 Route::all_processors_active (Placement p, bool state)
1640 {
1641         Glib::RWLock::ReaderLock lm (_processor_lock);
1642
1643         if (_processors.empty()) {
1644                 return;
1645         }
1646         ProcessorList::iterator start, end;
1647         placement_range(p, start, end);
1648
1649         bool before_amp = true;
1650         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1651                 if ((*i) == _amp) {
1652                         before_amp = false;
1653                         continue;
1654                 }
1655                 if (p == PreFader && before_amp) {
1656                         if (state) {
1657                                 (*i)->activate ();
1658                         } else {
1659                                 (*i)->deactivate ();
1660                         }
1661                 }
1662         }
1663
1664         _session.set_dirty ();
1665 }
1666
1667 bool
1668 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1669 {
1670         bool pre_fader = true;
1671         Glib::RWLock::ReaderLock lm (_processor_lock);
1672
1673         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1674
1675                 /* semantic note: if p == amp, we want to return true, so test
1676                    for equality before checking if this is the amp
1677                 */
1678
1679                 if ((*i) == p) {
1680                         break;
1681                 }
1682
1683                 if ((*i) == _amp) {
1684                         pre_fader = false;
1685                         break;
1686                 }
1687         }
1688
1689         return pre_fader;
1690 }
1691
1692 int
1693 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1694 {
1695         /* "new_order" is an ordered list of processors to be positioned according to "placement".
1696            NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1697            processors in the current actual processor list that are hidden. Any visible processors
1698            in the current list but not in "new_order" will be assumed to be deleted.
1699         */
1700
1701         {
1702                 Glib::RWLock::WriterLock lm (_processor_lock);
1703                 ChanCount old_pms = processor_max_streams;
1704                 ProcessorList::iterator oiter;
1705                 ProcessorList::const_iterator niter;
1706                 ProcessorList as_it_was_before = _processors;
1707                 ProcessorList as_it_will_be;
1708
1709                 oiter = _processors.begin();
1710                 niter = new_order.begin();
1711
1712                 while (niter !=  new_order.end()) {
1713
1714                         /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1715                            then append it to the temp list.
1716
1717                            Otherwise, see if the next processor in the old list is in the new list. if not,
1718                            its been deleted. If its there, append it to the temp list.
1719                         */
1720
1721                         if (oiter == _processors.end()) {
1722
1723                                 /* no more elements in the old list, so just stick the rest of
1724                                    the new order onto the temp list.
1725                                 */
1726
1727                                 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1728                                 while (niter != new_order.end()) {
1729                                         ++niter;
1730                                 }
1731                                 break;
1732
1733                         } else {
1734
1735                                 if (!(*oiter)->display_to_user()) {
1736
1737                                         as_it_will_be.push_back (*oiter);
1738
1739                                 } else {
1740
1741                                         /* visible processor: check that its in the new order */
1742
1743                                         if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1744                                                 /* deleted: do nothing, shared_ptr<> will clean up */
1745                                         } else {
1746                                                 /* ignore this one, and add the next item from the new order instead */
1747                                                 as_it_will_be.push_back (*niter);
1748                                                 ++niter;
1749                                         }
1750                                 }
1751
1752                                 /* now remove from old order - its taken care of no matter what */
1753                                 oiter = _processors.erase (oiter);
1754                         }
1755
1756                 }
1757
1758                 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1759
1760                 {
1761                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1762
1763                         if (configure_processors_unlocked (err)) {
1764                                 _processors = as_it_was_before;
1765                                 processor_max_streams = old_pms;
1766                                 return -1;
1767                         }
1768                 }
1769         }
1770
1771         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1772         set_processor_positions ();
1773
1774         return 0;
1775 }
1776
1777 XMLNode&
1778 Route::get_state()
1779 {
1780         return state(true);
1781 }
1782
1783 XMLNode&
1784 Route::get_template()
1785 {
1786         return state(false);
1787 }
1788
1789 XMLNode&
1790 Route::state(bool full_state)
1791 {
1792         XMLNode *node = new XMLNode("Route");
1793         ProcessorList::iterator i;
1794         char buf[32];
1795
1796         id().print (buf, sizeof (buf));
1797         node->add_property("id", buf);
1798         node->add_property ("name", _name);
1799         node->add_property("default-type", _default_type.to_string());
1800
1801         if (_flags) {
1802                 node->add_property("flags", enum_2_string (_flags));
1803         }
1804
1805         node->add_property("active", _active?"yes":"no");
1806         string p;
1807         boost::to_string (_phase_invert, p);
1808         node->add_property("phase-invert", p);
1809         node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1810         node->add_property("meter-point", enum_2_string (_meter_point));
1811
1812         if (_route_group) {
1813                 node->add_property("route-group", _route_group->name());
1814         }
1815
1816         string order_string;
1817         OrderKeys::iterator x = order_keys.begin();
1818
1819         while (x != order_keys.end()) {
1820                 order_string += string ((*x).first);
1821                 order_string += '=';
1822                 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1823                 order_string += buf;
1824
1825                 ++x;
1826
1827                 if (x == order_keys.end()) {
1828                         break;
1829                 }
1830
1831                 order_string += ':';
1832         }
1833         node->add_property ("order-keys", order_string);
1834         node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1835         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1836         node->add_property ("soloed-by-upstream", buf);
1837         snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1838         node->add_property ("soloed-by-downstream", buf);
1839         node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1840         node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1841
1842         node->add_child_nocopy (_input->state (full_state));
1843         node->add_child_nocopy (_output->state (full_state));
1844         node->add_child_nocopy (_solo_control->get_state ());
1845         node->add_child_nocopy (_mute_control->get_state ());
1846         node->add_child_nocopy (_mute_master->get_state ());
1847
1848         XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1849         snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1850         remote_control_node->add_property (X_("id"), buf);
1851         node->add_child_nocopy (*remote_control_node);
1852
1853         if (_comment.length()) {
1854                 XMLNode *cmt = node->add_child ("Comment");
1855                 cmt->add_content (_comment);
1856         }
1857
1858         node->add_child_nocopy (_pannable->state (full_state));
1859
1860         for (i = _processors.begin(); i != _processors.end(); ++i) {
1861                 node->add_child_nocopy((*i)->state (full_state));
1862         }
1863
1864         if (_extra_xml){
1865                 node->add_child_copy (*_extra_xml);
1866         }
1867
1868         return *node;
1869 }
1870
1871 int
1872 Route::set_state (const XMLNode& node, int version)
1873 {
1874         return _set_state (node, version, true);
1875 }
1876
1877 int
1878 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1879 {
1880         if (version < 3000) {
1881                 return _set_state_2X (node, version);
1882         }
1883
1884         XMLNodeList nlist;
1885         XMLNodeConstIterator niter;
1886         XMLNode *child;
1887         const XMLProperty *prop;
1888
1889         if (node.name() != "Route"){
1890                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1891                 return -1;
1892         }
1893
1894         if ((prop = node.property (X_("name"))) != 0) {
1895                 Route::set_name (prop->value());
1896         }
1897
1898         if ((prop = node.property ("id")) != 0) {
1899                 _id = prop->value ();
1900         }
1901
1902         if ((prop = node.property (X_("flags"))) != 0) {
1903                 _flags = Flag (string_2_enum (prop->value(), _flags));
1904         } else {
1905                 _flags = Flag (0);
1906         }
1907
1908         if (is_master() || is_monitor() || is_hidden()) {
1909                 _mute_master->set_solo_ignore (true);
1910         }
1911
1912         /* add all processors (except amp, which is always present) */
1913
1914         nlist = node.children();
1915         XMLNode processor_state (X_("processor_state"));
1916
1917         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1918
1919                 child = *niter;
1920
1921                 if (child->name() == IO::state_node_name) {
1922                         if ((prop = child->property (X_("direction"))) == 0) {
1923                                 continue;
1924                         }
1925
1926                         if (prop->value() == "Input") {
1927                                 _input->set_state (*child, version);
1928                         } else if (prop->value() == "Output") {
1929                                 _output->set_state (*child, version);
1930                         }
1931                 }
1932
1933                 if (child->name() == X_("Processor")) {
1934                         processor_state.add_child_copy (*child);
1935                 }
1936
1937
1938                 if (child->name() == X_("Pannable")) {
1939                         _pannable->set_state (*child, version);
1940                 }
1941         }
1942
1943         set_processor_state (processor_state);
1944
1945         if ((prop = node.property ("self-solo")) != 0) {
1946                 set_self_solo (string_is_affirmative (prop->value()));
1947         }
1948
1949         if ((prop = node.property ("soloed-by-upstream")) != 0) {
1950                 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1951                 mod_solo_by_others_upstream (atoi (prop->value()));
1952         }
1953
1954         if ((prop = node.property ("soloed-by-downstream")) != 0) {
1955                 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1956                 mod_solo_by_others_downstream (atoi (prop->value()));
1957         }
1958
1959         if ((prop = node.property ("solo-isolated")) != 0) {
1960                 set_solo_isolated (string_is_affirmative (prop->value()), this);
1961         }
1962
1963         if ((prop = node.property ("solo-safe")) != 0) {
1964                 set_solo_safe (string_is_affirmative (prop->value()), this);
1965         }
1966
1967         if ((prop = node.property (X_("phase-invert"))) != 0) {
1968                 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1969         }
1970
1971         if ((prop = node.property (X_("denormal-protection"))) != 0) {
1972                 set_denormal_protection (string_is_affirmative (prop->value()));
1973         }
1974
1975         if ((prop = node.property (X_("active"))) != 0) {
1976                 bool yn = string_is_affirmative (prop->value());
1977                 _active = !yn; // force switch
1978                 set_active (yn, this);
1979         }
1980
1981         if ((prop = node.property (X_("meter-point"))) != 0) {
1982                 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1983                 set_meter_point (mp, true);
1984                 if (_meter) {
1985                         _meter->set_display_to_user (_meter_point == MeterCustom);
1986                 }
1987         }
1988
1989         if ((prop = node.property (X_("order-keys"))) != 0) {
1990
1991                 int32_t n;
1992
1993                 string::size_type colon, equal;
1994                 string remaining = prop->value();
1995
1996                 while (remaining.length()) {
1997
1998                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1999                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2000                                       << endmsg;
2001                         } else {
2002                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2003                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2004                                               << endmsg;
2005                                 } else {
2006                                         set_order_key (remaining.substr (0, equal), n);
2007                                 }
2008                         }
2009
2010                         colon = remaining.find_first_of (':');
2011
2012                         if (colon != string::npos) {
2013                                 remaining = remaining.substr (colon+1);
2014                         } else {
2015                                 break;
2016                         }
2017                 }
2018         }
2019
2020         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2021                 child = *niter;
2022
2023                 if (child->name() == X_("Comment")) {
2024
2025                         /* XXX this is a terrible API design in libxml++ */
2026
2027                         XMLNode *cmt = *(child->children().begin());
2028                         _comment = cmt->content();
2029
2030                 } else if (child->name() == X_("Extra")) {
2031
2032                         _extra_xml = new XMLNode (*child);
2033
2034                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2035                         if (prop->value() == "solo") {
2036                                 _solo_control->set_state (*child, version);
2037                         }
2038
2039                 } else if (child->name() == X_("RemoteControl")) {
2040                         if ((prop = child->property (X_("id"))) != 0) {
2041                                 int32_t x;
2042                                 sscanf (prop->value().c_str(), "%d", &x);
2043                                 set_remote_control_id (x);
2044                         }
2045
2046                 } else if (child->name() == X_("MuteMaster")) {
2047                         _mute_master->set_state (*child, version);
2048                 }
2049         }
2050
2051         return 0;
2052 }
2053
2054 int
2055 Route::_set_state_2X (const XMLNode& node, int version)
2056 {
2057         XMLNodeList nlist;
2058         XMLNodeConstIterator niter;
2059         XMLNode *child;
2060         const XMLProperty *prop;
2061
2062         /* 2X things which still remain to be handled:
2063          * default-type
2064          * automation
2065          * controlouts
2066          */
2067
2068         if (node.name() != "Route") {
2069                 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2070                 return -1;
2071         }
2072
2073         if ((prop = node.property (X_("flags"))) != 0) {
2074                 _flags = Flag (string_2_enum (prop->value(), _flags));
2075         } else {
2076                 _flags = Flag (0);
2077         }
2078
2079         if ((prop = node.property (X_("phase-invert"))) != 0) {
2080                 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2081                 if (string_is_affirmative (prop->value ())) {
2082                         p.set ();
2083                 }
2084                 set_phase_invert (p);
2085         }
2086
2087         if ((prop = node.property (X_("denormal-protection"))) != 0) {
2088                 set_denormal_protection (string_is_affirmative (prop->value()));
2089         }
2090
2091         if ((prop = node.property (X_("soloed"))) != 0) {
2092                 bool yn = string_is_affirmative (prop->value());
2093
2094                 /* XXX force reset of solo status */
2095
2096                 set_solo (yn, this);
2097         }
2098
2099         if ((prop = node.property (X_("muted"))) != 0) {
2100
2101                 bool first = true;
2102                 bool muted = string_is_affirmative (prop->value());
2103
2104                 if (muted){
2105
2106                         string mute_point;
2107
2108                         if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2109
2110                                 if (string_is_affirmative (prop->value())){
2111                                         mute_point = mute_point + "PreFader";
2112                                         first = false;
2113                                 }
2114                         }
2115
2116                         if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2117
2118                                 if (string_is_affirmative (prop->value())){
2119
2120                                         if (!first) {
2121                                                 mute_point = mute_point + ",";
2122                                         }
2123
2124                                         mute_point = mute_point + "PostFader";
2125                                         first = false;
2126                                 }
2127                         }
2128
2129                         if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2130
2131                                 if (string_is_affirmative (prop->value())){
2132
2133                                         if (!first) {
2134                                                 mute_point = mute_point + ",";
2135                                         }
2136
2137                                         mute_point = mute_point + "Listen";
2138                                         first = false;
2139                                 }
2140                         }
2141
2142                         if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2143
2144                                 if (string_is_affirmative (prop->value())){
2145
2146                                         if (!first) {
2147                                                 mute_point = mute_point + ",";
2148                                         }
2149
2150                                         mute_point = mute_point + "Main";
2151                                 }
2152                         }
2153
2154                         _mute_master->set_mute_points (mute_point);
2155                 }
2156         }
2157
2158         if ((prop = node.property (X_("meter-point"))) != 0) {
2159                 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2160         }
2161
2162         /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2163            don't mean the same thing.
2164         */
2165
2166         if ((prop = node.property (X_("order-keys"))) != 0) {
2167
2168                 int32_t n;
2169
2170                 string::size_type colon, equal;
2171                 string remaining = prop->value();
2172
2173                 while (remaining.length()) {
2174
2175                         if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2176                                 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2177                                         << endmsg;
2178                         } else {
2179                                 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2180                                         error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2181                                                 << endmsg;
2182                                 } else {
2183                                         set_order_key (remaining.substr (0, equal), n);
2184                                 }
2185                         }
2186
2187                         colon = remaining.find_first_of (':');
2188
2189                         if (colon != string::npos) {
2190                                 remaining = remaining.substr (colon+1);
2191                         } else {
2192                                 break;
2193                         }
2194                 }
2195         }
2196
2197         /* IOs */
2198
2199         nlist = node.children ();
2200         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2201
2202                 child = *niter;
2203
2204                 if (child->name() == IO::state_node_name) {
2205
2206                         /* there is a note in IO::set_state_2X() about why we have to call
2207                            this directly.
2208                            */
2209
2210                         _input->set_state_2X (*child, version, true);
2211                         _output->set_state_2X (*child, version, false);
2212
2213                         if ((prop = child->property (X_("name"))) != 0) {
2214                                 Route::set_name (prop->value ());
2215                         }
2216
2217                         if ((prop = child->property (X_("id"))) != 0) {
2218                                 _id = prop->value ();
2219                         }
2220
2221                         if ((prop = child->property (X_("active"))) != 0) {
2222                                 bool yn = string_is_affirmative (prop->value());
2223                                 _active = !yn; // force switch
2224                                 set_active (yn, this);
2225                         }
2226
2227                         if ((prop = child->property (X_("gain"))) != 0) {
2228                                 gain_t val;
2229
2230                                 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2231                                         _amp->gain_control()->set_value (val);
2232                                 }
2233                         }
2234
2235                         /* Set up Panners in the IO */
2236                         XMLNodeList io_nlist = child->children ();
2237
2238                         XMLNodeConstIterator io_niter;
2239                         XMLNode *io_child;
2240
2241                         for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2242
2243                                 io_child = *io_niter;
2244
2245                                 if (io_child->name() == X_("Panner")) {
2246                                         _main_outs->panner_shell()->set_state(*io_child, version);
2247                                 } else if (io_child->name() == X_("Automation")) {
2248                                         /* IO's automation is for the fader */
2249                                         _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2250                                 }
2251                         }
2252                 }
2253         }
2254
2255         XMLNodeList redirect_nodes;
2256
2257         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2258
2259                 child = *niter;
2260
2261                 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2262                         redirect_nodes.push_back(child);
2263                 }
2264
2265         }
2266
2267         set_processor_state_2X (redirect_nodes, version);
2268
2269         for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2270                 child = *niter;
2271
2272                 if (child->name() == X_("Comment")) {
2273
2274                         /* XXX this is a terrible API design in libxml++ */
2275
2276                         XMLNode *cmt = *(child->children().begin());
2277                         _comment = cmt->content();
2278
2279                 } else if (child->name() == X_("extra")) {
2280
2281                         _extra_xml = new XMLNode (*child);
2282
2283                 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2284                         if (prop->value() == X_("solo")) {
2285                                 _solo_control->set_state (*child, version);
2286                         } else if (prop->value() == X_("mute")) {
2287                                 _mute_control->set_state (*child, version);
2288                         }
2289
2290                 } else if (child->name() == X_("RemoteControl")) {
2291                         if ((prop = child->property (X_("id"))) != 0) {
2292                                 int32_t x;
2293                                 sscanf (prop->value().c_str(), "%d", &x);
2294                                 set_remote_control_id (x);
2295                         }
2296
2297                 }
2298         }
2299
2300         return 0;
2301 }
2302
2303 XMLNode&
2304 Route::get_processor_state ()
2305 {
2306         XMLNode* root = new XMLNode (X_("redirects"));
2307         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2308                 root->add_child_nocopy ((*i)->state (true));
2309         }
2310
2311         return *root;
2312 }
2313
2314 void
2315 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2316 {
2317         /* We don't bother removing existing processors not in nList, as this
2318            method will only be called when creating a Route from scratch, not
2319            for undo purposes.  Just put processors in at the appropriate place
2320            in the list.
2321         */
2322
2323         for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2324                 add_processor_from_xml_2X (**i, version);
2325         }
2326 }
2327
2328 void
2329 Route::set_processor_state (const XMLNode& node)
2330 {
2331         const XMLNodeList &nlist = node.children();
2332         XMLNodeConstIterator niter;
2333         ProcessorList new_order;
2334         bool must_configure = false;
2335
2336         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2337
2338                 XMLProperty* prop = (*niter)->property ("type");
2339
2340                 if (prop->value() == "amp") {
2341                         _amp->set_state (**niter, Stateful::current_state_version);
2342                         new_order.push_back (_amp);
2343                 } else if (prop->value() == "meter") {
2344                         _meter->set_state (**niter, Stateful::current_state_version);
2345                         new_order.push_back (_meter);
2346                 } else if (prop->value() == "main-outs") {
2347                         _main_outs->set_state (**niter, Stateful::current_state_version);
2348                         new_order.push_back (_main_outs);
2349                 } else if (prop->value() == "intreturn") {
2350                         if (!_intreturn) {
2351                                 _intreturn.reset (new InternalReturn (_session));
2352                                 must_configure = true;
2353                         }
2354                         _intreturn->set_state (**niter, Stateful::current_state_version);
2355                         new_order.push_back (_intreturn);
2356                 } else if (is_monitor() && prop->value() == "monitor") {
2357                         if (!_monitor_control) {
2358                                 _monitor_control.reset (new MonitorProcessor (_session));
2359                                 must_configure = true;
2360                         }
2361                         _monitor_control->set_state (**niter, Stateful::current_state_version);
2362                         new_order.push_back (_monitor_control);
2363                 } else {
2364                         ProcessorList::iterator o;
2365
2366                         for (o = _processors.begin(); o != _processors.end(); ++o) {
2367                                 XMLProperty* id_prop = (*niter)->property(X_("id"));
2368                                 if (id_prop && (*o)->id() == id_prop->value()) {
2369                                         (*o)->set_state (**niter, Stateful::current_state_version);
2370                                         new_order.push_back (*o);
2371                                         break;
2372                                 }
2373                         }
2374
2375                         // If the processor (*niter) is not on the route then create it
2376
2377                         if (o == _processors.end()) {
2378
2379                                 boost::shared_ptr<Processor> processor;
2380
2381                                 if (prop->value() == "intsend") {
2382
2383                                         processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2384
2385                                 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2386                                            prop->value() == "lv2" ||
2387                                            prop->value() == "vst" ||
2388                                            prop->value() == "audiounit") {
2389
2390                                         processor.reset (new PluginInsert(_session));
2391
2392                                 } else if (prop->value() == "port") {
2393
2394                                         processor.reset (new PortInsert (_session, _pannable, _mute_master));
2395
2396                                 } else if (prop->value() == "send") {
2397
2398                                         processor.reset (new Send (_session, _pannable, _mute_master));
2399
2400                                 } else {
2401                                         error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2402                                         continue;
2403                                 }
2404
2405                                 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2406                                         /* This processor could not be configured.  Turn it into a UnknownProcessor */
2407                                         processor.reset (new UnknownProcessor (_session, **niter));
2408                                 }
2409
2410                                 new_order.push_back (processor);
2411                                 must_configure = true;
2412                         }
2413                 }
2414         }
2415
2416         {
2417                 Glib::RWLock::WriterLock lm (_processor_lock);
2418                 _processors = new_order;
2419                 if (must_configure) {
2420                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2421                         configure_processors_unlocked (0);
2422                 }
2423         }
2424
2425         processors_changed (RouteProcessorChange ());
2426         set_processor_positions ();
2427 }
2428
2429 void
2430 Route::curve_reallocate ()
2431 {
2432 //      _gain_automation_curve.finish_resize ();
2433 //      _pan_automation_curve.finish_resize ();
2434 }
2435
2436 void
2437 Route::silence (framecnt_t nframes)
2438 {
2439         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2440         if (!lm.locked()) {
2441                 return;
2442         }
2443
2444         silence_unlocked (nframes);
2445 }
2446
2447 void
2448 Route::silence_unlocked (framecnt_t nframes)
2449 {
2450         /* Must be called with the processor lock held */
2451
2452         if (!_silent) {
2453
2454                 _output->silence (nframes);
2455
2456                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2457                         boost::shared_ptr<PluginInsert> pi;
2458
2459                         if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2460                                 // skip plugins, they don't need anything when we're not active
2461                                 continue;
2462                         }
2463
2464                         (*i)->silence (nframes);
2465                 }
2466
2467                 if (nframes == _session.get_block_size()) {
2468                         // _silent = true;
2469                 }
2470         }
2471 }
2472
2473 void
2474 Route::add_internal_return ()
2475 {
2476         if (!_intreturn) {
2477                 _intreturn.reset (new InternalReturn (_session));
2478                 add_processor (_intreturn, PreFader);
2479         }
2480 }
2481
2482 BufferSet*
2483 Route::get_return_buffer () const
2484 {
2485         Glib::RWLock::ReaderLock rm (_processor_lock);
2486
2487         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2488                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2489
2490                 if (d) {
2491                         BufferSet* bs = d->get_buffers ();
2492                         return bs;
2493                 }
2494         }
2495
2496         return 0;
2497 }
2498
2499 void
2500 Route::release_return_buffer () const
2501 {
2502         Glib::RWLock::ReaderLock rm (_processor_lock);
2503
2504         for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2505                 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2506
2507                 if (d) {
2508                         return d->release_buffers ();
2509                 }
2510         }
2511 }
2512
2513 int
2514 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2515 {
2516         vector<string> ports;
2517         vector<string>::const_iterator i;
2518
2519         {
2520                 Glib::RWLock::ReaderLock rm (_processor_lock);
2521
2522                 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2523
2524                         boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2525
2526                         if (d && d->target_route() == route) {
2527
2528                                 /* if the target is the control outs, then make sure
2529                                    we take note of which i-send is doing that.
2530                                 */
2531
2532                                 if (route == _session.monitor_out()) {
2533                                         _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
2534                                 }
2535
2536                                 /* already listening via the specified IO: do nothing */
2537
2538                                 return 0;
2539                         }
2540                 }
2541         }
2542
2543         boost::shared_ptr<InternalSend> listener;
2544
2545         try {
2546
2547                 if (is_master()) {
2548
2549                         if (route == _session.monitor_out()) {
2550                                 /* master never sends to control outs */
2551                                 return 0;
2552                         } else {
2553                                 listener.reset (new InternalSend (_session, _pannable, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2554                         }
2555
2556                 } else {
2557                         listener.reset (new InternalSend (_session, _pannable, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2558                 }
2559
2560         } catch (failed_constructor& err) {
2561                 return -1;
2562         }
2563
2564         if (route == _session.monitor_out()) {
2565                 _monitor_send = listener;
2566         }
2567
2568
2569         if (aux) {
2570
2571                 add_processor (listener, placement);
2572
2573         } else {
2574
2575                 if (placement == PostFader) {
2576                         /* put it *really* at the end, not just after the panner (main outs)
2577                          */
2578                         add_processor (listener, _processors.end());
2579                 } else {
2580                         add_processor (listener, PreFader);
2581                 }
2582
2583         }
2584
2585         return 0;
2586 }
2587
2588 void
2589 Route::drop_listen (boost::shared_ptr<Route> route)
2590 {
2591         ProcessorStreams err;
2592         ProcessorList::iterator tmp;
2593
2594         Glib::RWLock::ReaderLock rl(_processor_lock);
2595         rl.acquire ();
2596
2597   again:
2598         for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2599
2600                 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2601
2602                 if (d && d->target_route() == route) {
2603                         rl.release ();
2604                         remove_processor (*x, &err);
2605                         rl.acquire ();
2606
2607                         /* list could have been demolished while we dropped the lock
2608                            so start over.
2609                         */
2610
2611                         goto again;
2612                 }
2613         }
2614
2615         rl.release ();
2616
2617         if (route == _session.monitor_out()) {
2618                 _monitor_send.reset ();
2619         }
2620 }
2621
2622 void
2623 Route::set_comment (string cmt, void *src)
2624 {
2625         _comment = cmt;
2626         comment_changed (src);
2627         _session.set_dirty ();
2628 }
2629
2630 bool
2631 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2632 {
2633         FeedRecord fr (other, via_sends_only);
2634
2635         pair<FedBy::iterator,bool> result =  _fed_by.insert (fr);
2636
2637         if (!result.second) {
2638
2639                 /* already a record for "other" - make sure sends-only information is correct */
2640                 if (!via_sends_only && result.first->sends_only) {
2641                         FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2642                         frp->sends_only = false;
2643                 }
2644         }
2645
2646         return result.second;
2647 }
2648
2649 void
2650 Route::clear_fed_by ()
2651 {
2652         _fed_by.clear ();
2653 }
2654
2655 bool
2656 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2657 {
2658         const FedBy& fed_by (other->fed_by());
2659
2660         for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2661                 boost::shared_ptr<Route> sr = f->r.lock();
2662
2663                 if (sr && (sr.get() == this)) {
2664
2665                         if (via_sends_only) {
2666                                 *via_sends_only = f->sends_only;
2667                         }
2668
2669                         return true;
2670                 }
2671         }
2672
2673         return false;
2674 }
2675
2676 bool
2677 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2678 {
2679         DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2680
2681         if (_output->connected_to (other->input())) {
2682                 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2683                 if (only_send) {
2684                         *only_send = false;
2685                 }
2686
2687                 return true;
2688         }
2689
2690
2691         for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2692
2693                 boost::shared_ptr<IOProcessor> iop;
2694
2695                 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2696                         if (iop->feeds (other)) {
2697                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2698                                 if (only_send) {
2699                                         *only_send = true;
2700                                 }
2701                                 return true;
2702                         } else {
2703                                 DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2704                         }
2705                 } else {
2706                         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2707                 }
2708
2709         }
2710
2711         DEBUG_TRACE (DEBUG::Graph,  string_compose ("\tdoes NOT feed %1\n", other->name()));
2712         return false;
2713 }
2714
2715 /** Called from the (non-realtime) butler thread when the transport is stopped */
2716 void
2717 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2718 {
2719         framepos_t now = _session.transport_frame();
2720
2721         {
2722                 Glib::RWLock::ReaderLock lm (_processor_lock);
2723
2724                 if (!did_locate) {
2725                         automation_snapshot (now, true);
2726                 }
2727
2728                 Automatable::transport_stopped (now);
2729
2730                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2731
2732                         if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2733                                 (*i)->flush ();
2734                         }
2735
2736                         (*i)->transport_stopped (now);
2737                 }
2738         }
2739
2740         _roll_delay = _initial_delay;
2741 }
2742
2743 /** Called with the process lock held if change contains ConfigurationChanged */
2744 void
2745 Route::input_change_handler (IOChange change, void * /*src*/)
2746 {
2747         if ((change.type & IOChange::ConfigurationChanged)) {
2748                 configure_processors (0);
2749                 _phase_invert.resize (_input->n_ports().n_audio ());
2750                 io_changed (); /* EMIT SIGNAL */
2751         }
2752 }
2753
2754 /** Called with the process lock held if change contains ConfigurationChanged */
2755 void
2756 Route::output_change_handler (IOChange change, void * /*src*/)
2757 {
2758         if ((change.type & IOChange::ConfigurationChanged)) {
2759
2760                 /* XXX resize all listeners to match _main_outs? */
2761
2762                 /* Auto-connect newly-created outputs, unless we're auto-connecting to master
2763                    and we are master (as an auto-connect in this situation would cause a
2764                    feedback loop)
2765                 */
2766                 AutoConnectOption ac = Config->get_output_auto_connect ();
2767                 if (ac == AutoConnectPhysical || (ac == AutoConnectMaster && !is_master ())) {
2768
2769                         ChanCount start = change.before;
2770
2771                         for (DataType::iterator i = DataType::begin(); i != DataType::end(); ++i) {
2772                                 if (change.before.get(*i) < change.after.get(*i)) {
2773                                         /* the existing ChanCounts don't matter for this call as they are only
2774                                            to do with matching input and output indices, and we are only changing
2775                                            outputs here.
2776                                         */
2777                                         ChanCount dummy;
2778
2779                                         /* only auto-connect the newly-created outputs, not the ones that were
2780                                            already there
2781                                         */
2782                                         start.set (*i, start.get (*i) + 1);
2783
2784                                         _session.auto_connect_route (this, dummy, dummy, false, ChanCount(), change.before);
2785                                 }
2786                         }
2787                 }
2788
2789                 // configure_processors (0);
2790         }
2791 }
2792
2793 uint32_t
2794 Route::pans_required () const
2795 {
2796         if (n_outputs().n_audio() < 2) {
2797                 return 0;
2798         }
2799
2800         return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2801 }
2802
2803 int
2804 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
2805                 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2806 {
2807         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2808         if (!lm.locked()) {
2809                 return 0;
2810         }
2811
2812         if (n_outputs().n_total() == 0) {
2813                 return 0;
2814         }
2815
2816         if (!_active || n_inputs() == ChanCount::ZERO)  {
2817                 silence_unlocked (nframes);
2818                 return 0;
2819         }
2820         if (session_state_changing) {
2821                 if (_session.transport_speed() != 0.0f) {
2822                         /* we're rolling but some state is changing (e.g. our diskstream contents)
2823                            so we cannot use them. Be silent till this is over.
2824
2825                            XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2826                         */
2827                         silence_unlocked (nframes);
2828                         return 0;
2829                 }
2830                 /* we're really not rolling, so we're either delivery silence or actually
2831                    monitoring, both of which are safe to do while session_state_changing is true.
2832                 */
2833         }
2834
2835         _amp->apply_gain_automation (false);
2836         passthru (start_frame, end_frame, nframes, 0);
2837
2838         return 0;
2839 }
2840
2841 framecnt_t
2842 Route::check_initial_delay (framecnt_t nframes, framecnt_t& transport_frame)
2843 {
2844         if (_roll_delay > nframes) {
2845
2846                 _roll_delay -= nframes;
2847                 silence_unlocked (nframes);
2848                 /* transport frame is not legal for caller to use */
2849                 return 0;
2850
2851         } else if (_roll_delay > 0) {
2852
2853                 nframes -= _roll_delay;
2854                 silence_unlocked (_roll_delay);
2855                 /* we've written _roll_delay of samples into the
2856                    output ports, so make a note of that for
2857                    future reference.
2858                 */
2859                 _main_outs->increment_output_offset (_roll_delay);
2860                 transport_frame += _roll_delay;
2861
2862                 _roll_delay = 0;
2863         }
2864
2865         return nframes;
2866 }
2867
2868 int
2869 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick,
2870              bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2871 {
2872         Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2873         if (!lm.locked()) {
2874                 return 0;
2875         }
2876
2877         automation_snapshot (_session.transport_frame(), false);
2878
2879         if (n_outputs().n_total() == 0) {
2880                 return 0;
2881         }
2882
2883         if (!_active || n_inputs().n_total() == 0) {
2884                 silence_unlocked (nframes);
2885                 return 0;
2886         }
2887
2888         framecnt_t unused = 0;
2889
2890         if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2891                 return 0;
2892         }
2893
2894         _silent = false;
2895
2896         passthru (start_frame, end_frame, nframes, declick);
2897
2898         return 0;
2899 }
2900
2901 int
2902 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/,
2903                     bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2904 {
2905         silence (nframes);
2906         return 0;
2907 }
2908
2909 void
2910 Route::toggle_monitor_input ()
2911 {
2912         for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2913                 i->ensure_monitor_input( ! i->monitoring_input());
2914         }
2915 }
2916
2917 bool
2918 Route::has_external_redirects () const
2919 {
2920         // FIXME: what about sends? - they don't return a signal back to ardour?
2921
2922         boost::shared_ptr<const PortInsert> pi;
2923
2924         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2925
2926                 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2927
2928                         for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2929
2930                                 string port_name = port->name();
2931                                 string client_name = port_name.substr (0, port_name.find(':'));
2932
2933                                 /* only say "yes" if the redirect is actually in use */
2934
2935                                 if (client_name != "ardour" && pi->active()) {
2936                                         return true;
2937                                 }
2938                         }
2939                 }
2940         }
2941
2942         return false;
2943 }
2944
2945 void
2946 Route::flush_processors ()
2947 {
2948         /* XXX shouldn't really try to take this lock, since
2949            this is called from the RT audio thread.
2950         */
2951
2952         Glib::RWLock::ReaderLock lm (_processor_lock);
2953
2954         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2955                 (*i)->flush ();
2956         }
2957 }
2958
2959 void
2960 Route::set_meter_point (MeterPoint p, bool force)
2961 {
2962         /* CAN BE CALLED FROM PROCESS CONTEXT */
2963
2964         if (_meter_point == p && !force) {
2965                 return;
2966         }
2967
2968         bool meter_was_visible_to_user = _meter->display_to_user ();
2969
2970         {
2971                 Glib::RWLock::WriterLock lm (_processor_lock);
2972
2973                 if (p != MeterCustom) {
2974                         // Move meter in the processors list to reflect the new position
2975                         ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2976                         _processors.erase(loc);
2977                         switch (p) {
2978                         case MeterInput:
2979                                 loc = _processors.begin();
2980                                 break;
2981                         case MeterPreFader:
2982                                 loc = find (_processors.begin(), _processors.end(), _amp);
2983                                 break;
2984                         case MeterPostFader:
2985                                 loc = _processors.end();
2986                                 break;
2987                         default:
2988                                 break;
2989                         }
2990
2991                         ChanCount m_in;
2992
2993                         if (loc == _processors.begin()) {
2994                                 m_in = _input->n_ports();
2995                         } else {
2996                                 ProcessorList::iterator before = loc;
2997                                 --before;
2998                                 m_in = (*before)->output_streams ();
2999                         }
3000
3001                         _meter->reflect_inputs (m_in);
3002
3003                         _processors.insert (loc, _meter);
3004
3005                         /* we do not need to reconfigure the processors, because the meter
3006                            (a) is always ready to handle processor_max_streams
3007                            (b) is always an N-in/N-out processor, and thus moving
3008                            it doesn't require any changes to the other processors.
3009                         */
3010
3011                         _meter->set_display_to_user (false);
3012
3013                 } else {
3014
3015                         // just make it visible and let the user move it
3016
3017                         _meter->set_display_to_user (true);
3018                 }
3019         }
3020
3021         _meter_point = p;
3022         meter_change (); /* EMIT SIGNAL */
3023
3024         bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
3025
3026         processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
3027 }
3028
3029 void
3030 Route::put_monitor_send_at (Placement p)
3031 {
3032         if (!_monitor_send) {
3033                 return;
3034         }
3035
3036         {
3037                 Glib::RWLock::WriterLock lm (_processor_lock);
3038                 ProcessorList as_it_was (_processors);
3039                 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
3040                 _processors.erase(loc);
3041
3042                 switch (p) {
3043                 case PreFader:
3044                         loc = find(_processors.begin(), _processors.end(), _amp);
3045                         if (loc != _processors.begin()) {
3046                                 --loc;
3047                         }
3048                         break;
3049                 case PostFader:
3050                         loc = _processors.end();
3051                         break;
3052                 }
3053
3054                 _processors.insert (loc, _monitor_send);
3055
3056                 {
3057                         Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3058
3059                         if (configure_processors_unlocked (0)) {
3060                                 _processors = as_it_was;
3061                                 configure_processors_unlocked (0); // it worked before we tried to add it ...
3062                                 return;
3063                         }
3064                 }
3065         }
3066
3067         processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
3068         _session.set_dirty ();
3069 }
3070
3071 boost::shared_ptr<CapturingProcessor>
3072 Route::add_export_point()
3073 {
3074         // Check if it exists already
3075         boost::shared_ptr<CapturingProcessor> processor;
3076         if ((processor = boost::dynamic_pointer_cast<CapturingProcessor> (*_processors.begin()))) {
3077                 return processor;
3078         }
3079
3080         // ...else add it
3081         processor.reset (new CapturingProcessor (_session));
3082         add_processor (processor, _processors.begin());
3083         return processor;
3084 }
3085
3086 framecnt_t
3087 Route::update_total_latency ()
3088 {
3089         framecnt_t old = _output->effective_latency();
3090         framecnt_t own_latency = _output->user_latency();
3091
3092         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3093                 if ((*i)->active ()) {
3094                         own_latency += (*i)->signal_latency ();
3095                 }
3096         }
3097
3098         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
3099
3100         _output->set_port_latency (own_latency);
3101
3102         if (_output->user_latency() == 0) {
3103
3104                 /* this (virtual) function is used for pure Routes,
3105                    not derived classes like AudioTrack.  this means
3106                    that the data processed here comes from an input
3107                    port, not prerecorded material, and therefore we
3108                    have to take into account any input latency.
3109                 */
3110
3111                 own_latency += _input->signal_latency ();
3112         }
3113
3114         if (old != own_latency) {
3115                 _output->set_latency_delay (own_latency);
3116                 signal_latency_changed (); /* EMIT SIGNAL */
3117         }
3118
3119         DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
3120
3121         return _output->effective_latency ();
3122 }
3123
3124 void
3125 Route::set_user_latency (framecnt_t nframes)
3126 {
3127         _output->set_user_latency (nframes);
3128         _session.update_latency_compensation (false, false);
3129 }
3130
3131 void
3132 Route::set_latency_delay (framecnt_t longest_session_latency)
3133 {
3134         framecnt_t old = _initial_delay;
3135
3136         if (_output->effective_latency() < longest_session_latency) {
3137                 _initial_delay = longest_session_latency - _output->effective_latency();
3138         } else {
3139                 _initial_delay = 0;
3140         }
3141
3142         if (_initial_delay != old) {
3143                 initial_delay_changed (); /* EMIT SIGNAL */
3144         }
3145
3146         if (_session.transport_stopped()) {
3147                 _roll_delay = _initial_delay;
3148         }
3149 }
3150
3151 void
3152 Route::automation_snapshot (framepos_t now, bool force)
3153 {
3154         _pannable->automation_snapshot (now, force);
3155         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3156                 (*i)->automation_snapshot (now, force);
3157         }
3158 }
3159
3160 Route::SoloControllable::SoloControllable (std::string name, Route& r)
3161         : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
3162                              boost::shared_ptr<AutomationList>(), name)
3163         , route (r)
3164 {
3165         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3166         set_list (gl);
3167 }
3168
3169 void
3170 Route::SoloControllable::set_value (double val)
3171 {
3172         bool bval = ((val >= 0.5f) ? true: false);
3173 # if 0
3174         this is how it should be done
3175
3176         boost::shared_ptr<RouteList> rl (new RouteList);
3177         rl->push_back (route);
3178
3179         if (Config->get_solo_control_is_listen_control()) {
3180                 _session.set_listen (rl, bval);
3181         } else {
3182                 _session.set_solo (rl, bval);
3183         }
3184 #else
3185         route.set_solo (bval, this);
3186 #endif
3187 }
3188
3189 double
3190 Route::SoloControllable::get_value (void) const
3191 {
3192         if (Config->get_solo_control_is_listen_control()) {
3193                 return route.listening() ? 1.0f : 0.0f;
3194         } else {
3195                 return route.self_soloed() ? 1.0f : 0.0f;
3196         }
3197 }
3198
3199 Route::MuteControllable::MuteControllable (std::string name, Route& r)
3200         : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
3201                              boost::shared_ptr<AutomationList>(), name)
3202         , route (r)
3203 {
3204         boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3205         set_list (gl);
3206 }
3207
3208 void
3209 Route::MuteControllable::set_value (double val)
3210 {
3211         bool bval = ((val >= 0.5f) ? true: false);
3212 # if 0
3213         this is how it should be done
3214
3215         boost::shared_ptr<RouteList> rl (new RouteList);
3216         rl->push_back (route);
3217         _session.set_mute (rl, bval);
3218 #else
3219         route.set_mute (bval, this);
3220 #endif
3221 }
3222
3223 double
3224 Route::MuteControllable::get_value (void) const
3225 {
3226         return route.muted() ? 1.0f : 0.0f;
3227 }
3228
3229 void
3230 Route::set_block_size (pframes_t nframes)
3231 {
3232         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3233                 (*i)->set_block_size (nframes);
3234         }
3235
3236         _session.ensure_buffers (n_process_buffers ());
3237 }
3238
3239 void
3240 Route::protect_automation ()
3241 {
3242         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3243                 (*i)->protect_automation();
3244 }
3245
3246 void
3247 Route::set_pending_declick (int declick)
3248 {
3249         if (_declickable) {
3250                 /* this call is not allowed to turn off a pending declick unless "force" is true */
3251                 if (declick) {
3252                         _pending_declick = declick;
3253                 }
3254                 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3255         } else {
3256                 _pending_declick = 0;
3257         }
3258
3259 }
3260
3261 /** Shift automation forwards from a particular place, thereby inserting time.
3262  *  Adds undo commands for any shifts that are performed.
3263  *
3264  * @param pos Position to start shifting from.
3265  * @param frames Amount to shift forwards by.
3266  */
3267
3268 void
3269 Route::shift (framepos_t pos, framecnt_t frames)
3270 {
3271         /* gain automation */
3272         {
3273                 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3274
3275                 XMLNode &before = gc->alist()->get_state ();
3276                 gc->alist()->shift (pos, frames);
3277                 XMLNode &after = gc->alist()->get_state ();
3278                 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3279         }
3280
3281         /* pan automation */
3282         {
3283                 ControlSet::Controls& c (_pannable->controls());
3284
3285                 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3286                         boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3287                         if (pc) {
3288                                 boost::shared_ptr<AutomationList> al = pc->alist();
3289                                 XMLNode& before = al->get_state ();
3290                                 al->shift (pos, frames);
3291                                 XMLNode& after = al->get_state ();
3292                                 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3293                         }
3294                 }
3295         }
3296
3297         /* redirect automation */
3298         {
3299                 Glib::RWLock::ReaderLock lm (_processor_lock);
3300                 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3301
3302                         set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3303
3304                         for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3305                                 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3306                                 if (ac) {
3307                                         boost::shared_ptr<AutomationList> al = ac->alist();
3308                                         XMLNode &before = al->get_state ();
3309                                         al->shift (pos, frames);
3310                                         XMLNode &after = al->get_state ();
3311                                         _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3312                                 }
3313                         }
3314                 }
3315         }
3316 }
3317
3318
3319 int
3320 Route::save_as_template (const string& path, const string& name)
3321 {
3322         XMLNode& node (state (false));
3323         XMLTree tree;
3324
3325         IO::set_name_in_state (*node.children().front(), name);
3326
3327         tree.set_root (&node);
3328         return tree.write (path.c_str());
3329 }
3330
3331
3332 bool
3333 Route::set_name (const string& str)
3334 {
3335         bool ret;
3336         string ioproc_name;
3337         string name;
3338
3339         name = Route::ensure_track_or_route_name (str, _session);
3340         SessionObject::set_name (name);
3341
3342         ret = (_input->set_name(name) && _output->set_name(name));
3343
3344         if (ret) {
3345
3346                 Glib::RWLock::ReaderLock lm (_processor_lock);
3347
3348                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3349
3350                         /* rename all I/O processors that have inputs or outputs */
3351
3352                         boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3353
3354                         if (iop && (iop->output() || iop->input())) {
3355                                 if (!iop->set_name (name)) {
3356                                         ret = false;
3357                                 }
3358                         }
3359                 }
3360
3361         }
3362
3363         return ret;
3364 }
3365
3366 boost::shared_ptr<Send>
3367 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3368 {
3369         Glib::RWLock::ReaderLock lm (_processor_lock);
3370
3371         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3372                 boost::shared_ptr<InternalSend> send;
3373
3374                 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3375                         if (send->target_route() == target) {
3376                                 return send;
3377                         }
3378                 }
3379         }
3380
3381         return boost::shared_ptr<Send>();
3382 }
3383
3384 /** @param c Audio channel index.
3385  *  @param yn true to invert phase, otherwise false.
3386  */
3387 void
3388 Route::set_phase_invert (uint32_t c, bool yn)
3389 {
3390         if (_phase_invert[c] != yn) {
3391                 _phase_invert[c] = yn;
3392                 phase_invert_changed (); /* EMIT SIGNAL */
3393                 _session.set_dirty ();
3394         }
3395 }
3396
3397 void
3398 Route::set_phase_invert (boost::dynamic_bitset<> p)
3399 {
3400         if (_phase_invert != p) {
3401                 _phase_invert = p;
3402                 phase_invert_changed (); /* EMIT SIGNAL */
3403                 _session.set_dirty ();
3404         }
3405 }
3406
3407 bool
3408 Route::phase_invert (uint32_t c) const
3409 {
3410         return _phase_invert[c];
3411 }
3412
3413 boost::dynamic_bitset<>
3414 Route::phase_invert () const
3415 {
3416         return _phase_invert;
3417 }
3418
3419 void
3420 Route::set_denormal_protection (bool yn)
3421 {
3422         if (_denormal_protection != yn) {
3423                 _denormal_protection = yn;
3424                 denormal_protection_changed (); /* EMIT SIGNAL */
3425         }
3426 }
3427
3428 bool
3429 Route::denormal_protection () const
3430 {
3431         return _denormal_protection;
3432 }
3433
3434 void
3435 Route::set_active (bool yn, void* src)
3436 {
3437         if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3438                 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3439                 return;
3440         }
3441
3442         if (_active != yn) {
3443                 _active = yn;
3444                 _input->set_active (yn);
3445                 _output->set_active (yn);
3446                 active_changed (); // EMIT SIGNAL
3447         }
3448 }
3449
3450 void
3451 Route::meter ()
3452 {
3453         Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3454
3455         assert (_meter);
3456
3457         _meter->meter ();
3458
3459         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3460
3461                 boost::shared_ptr<Send> s;
3462                 boost::shared_ptr<Return> r;
3463
3464                 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3465                         s->meter()->meter();
3466                 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3467                         r->meter()->meter ();
3468                 }
3469         }
3470 }
3471
3472 boost::shared_ptr<Pannable>
3473 Route::pannable() const
3474 {
3475         return _pannable;
3476 }
3477
3478 boost::shared_ptr<Panner>
3479 Route::panner() const
3480 {
3481         /* may be null ! */
3482         return _main_outs->panner_shell()->panner();
3483 }
3484
3485 boost::shared_ptr<PannerShell>
3486 Route::panner_shell() const
3487 {
3488         return _main_outs->panner_shell();
3489 }
3490
3491 boost::shared_ptr<AutomationControl>
3492 Route::gain_control() const
3493 {
3494         return _amp->gain_control();
3495 }
3496
3497 boost::shared_ptr<AutomationControl>
3498 Route::get_control (const Evoral::Parameter& param)
3499 {
3500         /* either we own the control or .... */
3501
3502         boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3503
3504         if (!c) {
3505
3506                 /* maybe one of our processors does or ... */
3507
3508                 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3509                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3510                         if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3511                                 break;
3512                         }
3513                 }
3514         }
3515
3516         if (!c) {
3517
3518                 /* nobody does so we'll make a new one */
3519
3520                 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3521                 add_control(c);
3522         }
3523
3524         return c;
3525 }
3526
3527 boost::shared_ptr<Processor>
3528 Route::nth_plugin (uint32_t n)
3529 {
3530         Glib::RWLock::ReaderLock lm (_processor_lock);
3531         ProcessorList::iterator i;
3532
3533         for (i = _processors.begin(); i != _processors.end(); ++i) {
3534                 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3535                         if (n-- == 0) {
3536                                 return *i;
3537                         }
3538                 }
3539         }
3540
3541         return boost::shared_ptr<Processor> ();
3542 }
3543
3544 boost::shared_ptr<Processor>
3545 Route::nth_send (uint32_t n)
3546 {
3547         Glib::RWLock::ReaderLock lm (_processor_lock);
3548         ProcessorList::iterator i;
3549
3550         for (i = _processors.begin(); i != _processors.end(); ++i) {
3551                 if (boost::dynamic_pointer_cast<Send> (*i)) {
3552                         if (n-- == 0) {
3553                                 return *i;
3554                         }
3555                 }
3556         }
3557
3558         return boost::shared_ptr<Processor> ();
3559 }
3560
3561 bool
3562 Route::has_io_processor_named (const string& name)
3563 {
3564         Glib::RWLock::ReaderLock lm (_processor_lock);
3565         ProcessorList::iterator i;
3566
3567         for (i = _processors.begin(); i != _processors.end(); ++i) {
3568                 if (boost::dynamic_pointer_cast<Send> (*i) ||
3569                     boost::dynamic_pointer_cast<PortInsert> (*i)) {
3570                         if ((*i)->name() == name) {
3571                                 return true;
3572                         }
3573                 }
3574         }
3575
3576         return false;
3577 }
3578
3579 MuteMaster::MutePoint
3580 Route::mute_points () const
3581 {
3582         return _mute_master->mute_points ();
3583 }
3584
3585 void
3586 Route::set_processor_positions ()
3587 {
3588         Glib::RWLock::ReaderLock lm (_processor_lock);
3589
3590         bool had_amp = false;
3591         for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3592                 (*i)->set_pre_fader (!had_amp);
3593                 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3594                         had_amp = true;
3595                 }
3596         }
3597 }
3598
3599 /** Called when there is a proposed change to the input port count */
3600 bool
3601 Route::input_port_count_changing (ChanCount to)
3602 {
3603         list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3604         if (c.empty()) {
3605                 /* The processors cannot be configured with the new input arrangement, so
3606                    block the change.
3607                 */
3608                 return true;
3609         }
3610
3611         /* The change is ok */
3612         return false;
3613 }
3614
3615 list<string>
3616 Route::unknown_processors () const
3617 {
3618         list<string> p;
3619
3620         Glib::RWLock::ReaderLock lm (_processor_lock);
3621         for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3622                 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3623                         p.push_back ((*i)->name ());
3624                 }
3625         }
3626
3627         return p;
3628 }