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