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