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