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