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