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