2 Copyright (C) 2000 Paul Davis
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.
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.
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.
25 #include "pbd/xml++.h"
26 #include "pbd/enumwriter.h"
27 #include "pbd/memento_command.h"
28 #include "pbd/stacktrace.h"
29 #include "pbd/convert.h"
31 #include "evoral/Curve.hpp"
33 #include "ardour/amp.h"
34 #include "ardour/audio_port.h"
35 #include "ardour/audioengine.h"
36 #include "ardour/buffer.h"
37 #include "ardour/buffer_set.h"
38 #include "ardour/configuration.h"
39 #include "ardour/cycle_timer.h"
40 #include "ardour/debug.h"
41 #include "ardour/delivery.h"
42 #include "ardour/dB.h"
43 #include "ardour/internal_send.h"
44 #include "ardour/internal_return.h"
45 #include "ardour/ladspa_plugin.h"
46 #include "ardour/meter.h"
47 #include "ardour/mix.h"
48 #include "ardour/monitor_processor.h"
49 #include "ardour/panner.h"
50 #include "ardour/plugin_insert.h"
51 #include "ardour/port.h"
52 #include "ardour/port_insert.h"
53 #include "ardour/processor.h"
54 #include "ardour/profile.h"
55 #include "ardour/route.h"
56 #include "ardour/route_group.h"
57 #include "ardour/send.h"
58 #include "ardour/session.h"
59 #include "ardour/timestamps.h"
60 #include "ardour/utils.h"
65 using namespace ARDOUR;
68 uint32_t Route::order_key_cnt = 0;
69 PBD::Signal1<void,string const&> Route::SyncOrderKeys;
70 PBD::Signal0<void> Route::RemoteControlIDChange;
72 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
73 : SessionObject (sess, name)
74 , AutomatableControls (sess)
79 , _pending_declick (true)
80 , _meter_point (MeterPostFader)
83 , _soloed_by_others (0)
85 , _denormal_protection (false)
88 , _declickable (false)
89 , _solo_control (new SoloControllable (X_("solo"), *this))
90 , _mute_control (new MuteControllable (X_("mute"), *this))
91 , _mute_master (new MuteMaster (sess, name))
92 , _mute_points (MuteMaster::AllPoints)
93 , _have_internal_generator (false)
95 , _default_type (default_type)
96 , _remote_control_id (0)
97 , _in_configure_processors (false)
99 processor_max_streams.reset();
100 order_keys[N_("signal")] = order_key_cnt++;
106 /* add standard controls */
108 _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
109 _mute_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
111 add_control (_solo_control);
112 add_control (_mute_control);
114 /* input and output objects */
116 _input.reset (new IO (_session, _name, IO::Input, _default_type));
117 _output.reset (new IO (_session, _name, IO::Output, _default_type));
119 _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
120 _output->changed.connect_same_thread (*this, boost::bind (&Route::output_change_handler, this, _1, _2));
122 /* add amp processor */
124 _amp.reset (new Amp (_session, _mute_master));
125 add_processor (_amp, PostFader);
127 /* add standard processors: meter, main outs, monitor out */
129 _meter.reset (new PeakMeter (_session));
130 _meter->set_display_to_user (false);
132 add_processor (_meter, PostFader);
134 _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
136 add_processor (_main_outs, PostFader);
139 /* where we listen to tracks */
140 _intreturn.reset (new InternalReturn (_session));
141 add_processor (_intreturn, PreFader);
143 ProcessorList::iterator i;
145 for (i = _processors.begin(); i != _processors.end(); ++i) {
146 if (*i == _intreturn) {
152 /* the thing that provides proper control over a control/monitor/listen bus
153 (such as per-channel cut, dim, solo, invert, etc).
154 It always goes right after the internal return;
156 _monitor_control.reset (new MonitorProcessor (_session));
157 add_processor (_monitor_control, i);
159 /* no panning on the monitor main outs */
161 _main_outs->panner()->set_bypassed (true);
164 /* now that we have _meter, its safe to connect to this */
166 Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
173 DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
175 /* do this early so that we don't get incoming signals as we are going through destruction
180 /* don't use clear_processors here, as it depends on the session which may
181 be half-destroyed by now
184 Glib::RWLock::WriterLock lm (_processor_lock);
185 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
186 (*i)->drop_references ();
189 _processors.clear ();
193 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
195 if (id != _remote_control_id) {
196 _remote_control_id = id;
197 RemoteControlIDChanged ();
198 if (notify_class_listeners) {
199 RemoteControlIDChange ();
205 Route::remote_control_id() const
207 return _remote_control_id;
211 Route::order_key (std::string const & name) const
213 OrderKeys::const_iterator i = order_keys.find (name);
214 if (i == order_keys.end()) {
222 Route::set_order_key (std::string const & name, long n)
224 order_keys[name] = n;
226 if (Config->get_sync_all_route_ordering()) {
227 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
232 _session.set_dirty ();
235 /** Set all order keys to be the same as that for `base', if such a key
236 * exists in this route.
237 * @param base Base key.
240 Route::sync_order_keys (std::string const & base)
242 if (order_keys.empty()) {
246 OrderKeys::iterator i;
249 if ((i = order_keys.find (base)) == order_keys.end()) {
250 /* key doesn't exist, use the first existing key (during session initialization) */
251 i = order_keys.begin();
255 /* key exists - use it and reset all others (actually, itself included) */
257 i = order_keys.begin();
260 for (; i != order_keys.end(); ++i) {
266 Route::ensure_track_or_route_name(string name, Session &session)
268 string newname = name;
270 while (session.route_by_name (newname) != NULL) {
271 newname = bump_name_once (newname);
279 Route::inc_gain (gain_t fraction, void *src)
281 _amp->inc_gain (fraction, src);
285 Route::set_gain (gain_t val, void *src)
287 if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
289 if (_route_group->is_relative()) {
291 gain_t usable_gain = _amp->gain();
292 if (usable_gain < 0.000001f) {
293 usable_gain = 0.000001f;
297 if (delta < 0.000001f) {
301 delta -= usable_gain;
306 gain_t factor = delta / usable_gain;
309 factor = _route_group->get_max_factor(factor);
310 if (factor == 0.0f) {
311 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
315 factor = _route_group->get_min_factor(factor);
316 if (factor == 0.0f) {
317 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
322 _route_group->apply (&Route::inc_gain, factor, _route_group);
326 _route_group->apply (&Route::set_gain, val, _route_group);
332 if (val == _amp->gain()) {
336 _amp->set_gain (val, src);
339 /** Process this route for one (sub) cycle (process thread)
341 * @param bufs Scratch buffers to use for the signal path
342 * @param start_frame Initial transport frame
343 * @param end_frame Final transport frame
344 * @param nframes Number of frames to output (to ports)
346 * Note that (end_frame - start_frame) may not be equal to nframes when the
347 * transport speed isn't 1.0 (eg varispeed).
350 Route::process_output_buffers (BufferSet& bufs,
351 sframes_t start_frame, sframes_t end_frame, nframes_t nframes,
352 bool /*with_processors*/, int declick)
356 bufs.is_silent (false);
358 switch (Config->get_monitoring_model()) {
359 case HardwareMonitoring:
360 case ExternalMonitoring:
361 monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
368 declick = _pending_declick;
371 /* figure out if we're going to use gain automation */
372 _amp->setup_gain_automation (start_frame, end_frame, nframes);
375 /* tell main outs what to do about monitoring */
376 _main_outs->no_outs_cuz_we_no_monitor (!monitor);
379 /* -------------------------------------------------------------------------------------------
380 GLOBAL DECLICK (for transport changes etc.)
381 ----------------------------------------------------------------------------------------- */
384 Amp::apply_gain (bufs, nframes, 0.0, 1.0);
385 } else if (declick < 0) {
386 Amp::apply_gain (bufs, nframes, 1.0, 0.0);
389 _pending_declick = 0;
391 /* -------------------------------------------------------------------------------------------
392 DENORMAL CONTROL/PHASE INVERT
393 ----------------------------------------------------------------------------------------- */
399 if (_denormal_protection || Config->get_denormal_protection()) {
401 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
402 Sample* const sp = i->data();
404 if (_phase_invert & chn) {
405 for (nframes_t nx = 0; nx < nframes; ++nx) {
410 for (nframes_t nx = 0; nx < nframes; ++nx) {
418 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
419 Sample* const sp = i->data();
421 if (_phase_invert & (1<<chn)) {
422 for (nframes_t nx = 0; nx < nframes; ++nx) {
431 if (_denormal_protection || Config->get_denormal_protection()) {
433 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
434 Sample* const sp = i->data();
435 for (nframes_t nx = 0; nx < nframes; ++nx) {
443 /* -------------------------------------------------------------------------------------------
445 ----------------------------------------------------------------------------------------- */
447 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
450 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
452 if (bufs.count() != (*i)->input_streams()) {
453 cerr << _name << " bufs = " << bufs.count()
454 << " input for " << (*i)->name() << " = " << (*i)->input_streams()
457 assert (bufs.count() == (*i)->input_streams());
459 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
460 bufs.set_count ((*i)->output_streams());
466 Route::n_process_buffers ()
468 return max (_input->n_ports(), processor_max_streams);
472 Route::passthru (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
474 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
478 assert (bufs.available() >= input_streams());
480 if (_input->n_ports() == ChanCount::ZERO) {
484 bufs.set_count (input_streams());
486 if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
488 /* control/monitor bus ignores input ports when something is
489 feeding the listen "stream". data will "arrive" into the
490 route from the intreturn processor element.
492 bufs.silence (nframes, 0);
496 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
498 BufferSet::iterator o = bufs.begin(*t);
499 PortSet& ports (_input->ports());
501 for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
502 o->read_from (i->get_buffer(nframes), nframes);
507 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
508 process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
512 Route::passthru_silence (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
514 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
515 bufs.set_count (_input->n_ports());
516 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
517 process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
521 Route::set_listen (bool yn, void* src)
524 if (yn != _monitor_send->active()) {
526 _monitor_send->set_solo_level (1);
527 _monitor_send->activate ();
529 _monitor_send->set_solo_level (0);
530 _monitor_send->deactivate ();
533 listen_changed (src); /* EMIT SIGNAL */
539 Route::listening () const
542 return _monitor_send->active ();
549 Route::set_solo_safe (bool yn, void *src)
551 if (_solo_safe != yn) {
553 solo_safe_changed (src);
558 Route::solo_safe() const
564 Route::set_solo (bool yn, void *src)
570 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
571 _route_group->apply (&Route::set_solo, yn, _route_group);
575 if (self_soloed() != yn) {
577 set_delivery_solo ();
578 solo_changed (src); /* EMIT SIGNAL */
579 _solo_control->Changed (); /* EMIT SIGNAL */
584 Route::set_self_solo (bool yn)
590 Route::mod_solo_by_others (int32_t delta)
593 if (_soloed_by_others >= (uint32_t) delta) {
594 _soloed_by_others += delta;
596 _soloed_by_others = 0;
599 _soloed_by_others += delta;
602 set_delivery_solo ();
606 Route::set_delivery_solo ()
608 /* tell all delivery processors what the solo situation is, so that they keep
609 delivering even though Session::soloing() is true and they were not
613 Glib::RWLock::ReaderLock rm (_processor_lock);
614 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
615 boost::shared_ptr<Delivery> d;
617 if ((d = boost::dynamic_pointer_cast<Delivery> (*i)) != 0) {
618 d->set_solo_level (soloed ());
619 d->set_solo_isolated (solo_isolated());
625 Route::set_solo_isolated (bool yn, void *src)
627 if (is_master() || is_monitor() || is_hidden()) {
631 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
632 _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
636 /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
638 boost::shared_ptr<RouteList> routes = _session.get_routes ();
639 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
641 bool does_feed = feeds (*i, &sends_only);
643 if (does_feed && !sends_only) {
644 (*i)->set_solo_isolated (yn, (*i)->route_group());
648 bool changed = false;
651 if (_solo_isolated == 0) {
656 changed = (_solo_isolated == 1);
657 if (_solo_isolated > 0) {
663 set_delivery_solo ();
664 solo_isolated_changed (src);
669 Route::solo_isolated () const
671 return _solo_isolated > 0;
675 Route::set_mute_points (MuteMaster::MutePoint mp)
678 mute_points_changed (); /* EMIT SIGNAL */
680 if (_mute_master->muted()) {
681 _mute_master->mute_at (_mute_points);
682 mute_changed (this); /* EMIT SIGNAL */
687 Route::set_mute (bool yn, void *src)
689 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
690 _route_group->apply (&Route::set_mute, yn, _route_group);
696 _mute_master->mute_at (_mute_points);
698 _mute_master->clear_mute ();
701 mute_changed (src); /* EMIT SIGNAL */
708 return _mute_master->muted ();
713 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
715 cerr << name << " {" << endl;
716 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
717 p != procs.end(); ++p) {
718 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
725 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
727 ProcessorList::iterator loc;
729 /* XXX this is not thread safe - we don't hold the lock across determining the iter
730 to add before and actually doing the insertion. dammit.
733 if (placement == PreFader) {
734 /* generic pre-fader: insert immediately before the amp */
735 loc = find (_processors.begin(), _processors.end(), _amp);
737 /* generic post-fader: insert right before the main outs */
738 loc = find (_processors.begin(), _processors.end(), _main_outs);
741 return add_processor (processor, loc, err);
745 /** Add a processor to the route.
746 * @a iter must point to an iterator in _processors and the new
747 * processor will be inserted immediately before this location. Otherwise,
748 * @a position is used.
751 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
753 ChanCount old_pms = processor_max_streams;
755 if (!_session.engine().connected() || !processor) {
760 Glib::RWLock::WriterLock lm (_processor_lock);
762 boost::shared_ptr<PluginInsert> pi;
763 boost::shared_ptr<PortInsert> porti;
765 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
767 if (processor == _amp || processor == _meter || processor == _main_outs) {
768 // Ensure only one of these are in the list at any time
769 if (loc != _processors.end()) {
770 if (iter == loc) { // Already in place, do nothing
772 } else { // New position given, relocate
773 _processors.erase (loc);
778 if (loc != _processors.end()) {
779 cerr << "ERROR: Processor added to route twice!" << endl;
786 _processors.insert (loc, processor);
788 // Set up processor list channels. This will set processor->[input|output]_streams(),
789 // configure redirect ports properly, etc.
791 if (configure_processors_unlocked (err)) {
792 ProcessorList::iterator ploc = loc;
794 _processors.erase(ploc);
795 configure_processors_unlocked (0); // it worked before we tried to add it ...
796 cerr << "configure failed\n";
800 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
802 if (pi->natural_input_streams() == ChanCount::ZERO) {
803 /* generator plugin */
804 _have_internal_generator = true;
809 /* is this the monitor send ? if so, make sure we keep track of it */
811 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
813 if (isend && _session.monitor_out() && (isend->target_id() == _session.monitor_out()->id())) {
814 _monitor_send = isend;
816 if (_monitor_send->active()) {
817 _monitor_send->set_solo_level (1);
819 _monitor_send->set_solo_level (0);
823 if (activation_allowed && (processor != _monitor_send)) {
824 processor->activate ();
827 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
829 _output->set_user_latency (0);
832 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
838 Route::add_processor_from_xml_2X (const XMLNode& node, int version, ProcessorList::iterator iter)
840 const XMLProperty *prop;
843 boost::shared_ptr<Processor> processor;
845 if (node.name() == "Insert") {
847 if ((prop = node.property ("type")) != 0) {
849 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
850 prop->value() == "lv2" ||
851 prop->value() == "vst" ||
852 prop->value() == "audiounit") {
854 processor.reset (new PluginInsert (_session));
858 processor.reset (new PortInsert (_session, _mute_master));
863 } else if (node.name() == "Send") {
865 processor.reset (new Send (_session, _mute_master));
869 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
873 if (processor->set_state (node, version)) {
877 if (iter == _processors.end() && processor->display_to_user() && !_processors.empty()) {
878 /* check for invisible processors stacked at the end and leave them there */
879 ProcessorList::iterator p;
880 p = _processors.end();
882 while (!(*p)->display_to_user() && p != _processors.begin()) {
889 return (add_processor (processor, iter) == 0);
892 catch (failed_constructor &err) {
893 warning << _("processor could not be created. Ignored.") << endmsg;
899 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
901 ProcessorList::iterator loc;
904 loc = find(_processors.begin(), _processors.end(), before);
906 /* nothing specified - at end but before main outs */
907 loc = find (_processors.begin(), _processors.end(), _main_outs);
910 return add_processors (others, loc, err);
914 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
916 /* NOTE: this is intended to be used ONLY when copying
917 processors from another Route. Hence the subtle
918 differences between this and ::add_processor()
921 ChanCount old_pms = processor_max_streams;
923 if (!_session.engine().connected()) {
927 if (others.empty()) {
932 Glib::RWLock::WriterLock lm (_processor_lock);
934 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
936 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
938 // Ensure meter only appears in the list once
940 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
941 if (m != _processors.end()) {
942 _processors.erase(m);
946 boost::shared_ptr<PluginInsert> pi;
948 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
951 ChanCount m = max (pi->input_streams(), pi->output_streams());
953 if (m > potential_max_streams) {
954 potential_max_streams = m;
958 ProcessorList::iterator inserted = _processors.insert (iter, *i);
960 if ((*i)->active()) {
964 if (configure_processors_unlocked (err)) {
965 _processors.erase (inserted);
966 configure_processors_unlocked (0); // it worked before we tried to add it ...
970 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false, false));
973 _output->set_user_latency (0);
976 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
982 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
985 start = _processors.begin();
986 end = find(_processors.begin(), _processors.end(), _amp);
988 start = find(_processors.begin(), _processors.end(), _amp);
990 end = _processors.end();
994 /** Turn off all processors with a given placement
995 * @param p Placement of processors to disable
998 Route::disable_processors (Placement p)
1000 Glib::RWLock::ReaderLock lm (_processor_lock);
1002 ProcessorList::iterator start, end;
1003 placement_range(p, start, end);
1005 for (ProcessorList::iterator i = start; i != end; ++i) {
1006 (*i)->deactivate ();
1009 _session.set_dirty ();
1012 /** Turn off all redirects
1015 Route::disable_processors ()
1017 Glib::RWLock::ReaderLock lm (_processor_lock);
1019 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1020 (*i)->deactivate ();
1023 _session.set_dirty ();
1026 /** Turn off all redirects with a given placement
1027 * @param p Placement of redirects to disable
1030 Route::disable_plugins (Placement p)
1032 Glib::RWLock::ReaderLock lm (_processor_lock);
1034 ProcessorList::iterator start, end;
1035 placement_range(p, start, end);
1037 for (ProcessorList::iterator i = start; i != end; ++i) {
1038 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1039 (*i)->deactivate ();
1043 _session.set_dirty ();
1046 /** Turn off all plugins
1049 Route::disable_plugins ()
1051 Glib::RWLock::ReaderLock lm (_processor_lock);
1053 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1054 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1055 (*i)->deactivate ();
1059 _session.set_dirty ();
1064 Route::ab_plugins (bool forward)
1066 Glib::RWLock::ReaderLock lm (_processor_lock);
1070 /* forward = turn off all active redirects, and mark them so that the next time
1071 we go the other way, we will revert them
1074 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1075 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1079 if ((*i)->active()) {
1080 (*i)->deactivate ();
1081 (*i)->set_next_ab_is_active (true);
1083 (*i)->set_next_ab_is_active (false);
1089 /* backward = if the redirect was marked to go active on the next ab, do so */
1091 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1093 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1097 if ((*i)->get_next_ab_is_active()) {
1100 (*i)->deactivate ();
1105 _session.set_dirty ();
1109 /** Remove processors with a given placement.
1110 * @param p Placement of processors to remove.
1113 Route::clear_processors (Placement p)
1115 const ChanCount old_pms = processor_max_streams;
1117 if (!_session.engine().connected()) {
1121 bool already_deleting = _session.deletion_in_progress();
1122 if (!already_deleting) {
1123 _session.set_deletion_in_progress();
1127 Glib::RWLock::WriterLock lm (_processor_lock);
1128 ProcessorList new_list;
1129 ProcessorStreams err;
1130 bool seen_amp = false;
1132 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1138 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1140 /* you can't remove these */
1142 new_list.push_back (*i);
1149 new_list.push_back (*i);
1152 (*i)->drop_references ();
1160 (*i)->drop_references ();
1163 new_list.push_back (*i);
1170 _processors = new_list;
1171 configure_processors_unlocked (&err); // this can't fail
1174 processor_max_streams.reset();
1175 _have_internal_generator = false;
1176 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1178 if (!already_deleting) {
1179 _session.clear_deletion_in_progress();
1184 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1186 /* these can never be removed */
1188 if (processor == _amp || processor == _meter || processor == _main_outs) {
1192 ChanCount old_pms = processor_max_streams;
1194 if (!_session.engine().connected()) {
1198 processor_max_streams.reset();
1201 Glib::RWLock::WriterLock lm (_processor_lock);
1202 ProcessorList::iterator i;
1203 bool removed = false;
1205 for (i = _processors.begin(); i != _processors.end(); ) {
1206 if (*i == processor) {
1208 /* move along, see failure case for configure_processors()
1209 where we may need to reconfigure the processor.
1212 /* stop redirects that send signals to JACK ports
1213 from causing noise as a result of no longer being
1217 boost::shared_ptr<IOProcessor> iop;
1219 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1221 iop->input()->disconnect (this);
1223 if (iop->output()) {
1224 iop->output()->disconnect (this);
1228 i = _processors.erase (i);
1236 _output->set_user_latency (0);
1244 if (configure_processors_unlocked (err)) {
1245 /* get back to where we where */
1246 _processors.insert (i, processor);
1247 /* we know this will work, because it worked before :) */
1248 configure_processors_unlocked (0);
1252 _have_internal_generator = false;
1254 for (i = _processors.begin(); i != _processors.end(); ++i) {
1255 boost::shared_ptr<PluginInsert> pi;
1257 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1258 if (pi->is_generator()) {
1259 _have_internal_generator = true;
1266 processor->drop_references ();
1267 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1273 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1275 ProcessorList deleted;
1277 if (!_session.engine().connected()) {
1281 processor_max_streams.reset();
1284 Glib::RWLock::WriterLock lm (_processor_lock);
1285 ProcessorList::iterator i;
1286 boost::shared_ptr<Processor> processor;
1288 ProcessorList as_we_were = _processors;
1290 for (i = _processors.begin(); i != _processors.end(); ) {
1294 /* these can never be removed */
1296 if (processor == _amp || processor == _meter || processor == _main_outs) {
1301 /* see if its in the list of processors to delete */
1303 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1308 /* stop IOProcessors that send to JACK ports
1309 from causing noise as a result of no longer being
1313 boost::shared_ptr<IOProcessor> iop;
1315 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1319 deleted.push_back (processor);
1320 i = _processors.erase (i);
1323 if (deleted.empty()) {
1324 /* none of those in the requested list were found */
1328 _output->set_user_latency (0);
1330 if (configure_processors_unlocked (err)) {
1331 /* get back to where we where */
1332 _processors = as_we_were;
1333 /* we know this will work, because it worked before :) */
1334 configure_processors_unlocked (0);
1338 _have_internal_generator = false;
1340 for (i = _processors.begin(); i != _processors.end(); ++i) {
1341 boost::shared_ptr<PluginInsert> pi;
1343 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1344 if (pi->is_generator()) {
1345 _have_internal_generator = true;
1352 /* now try to do what we need to so that those that were removed will be deleted */
1354 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1355 (*i)->drop_references ();
1358 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1365 Route::configure_processors (ProcessorStreams* err)
1367 if (!_in_configure_processors) {
1368 Glib::RWLock::WriterLock lm (_processor_lock);
1369 return configure_processors_unlocked (err);
1375 Route::input_streams () const
1377 return _input->n_ports ();
1380 /** Configure the input/output configuration of each processor in the processors list.
1381 * Return 0 on success, otherwise configuration is impossible.
1384 Route::configure_processors_unlocked (ProcessorStreams* err)
1386 if (_in_configure_processors) {
1390 _in_configure_processors = true;
1392 // Check each processor in order to see if we can configure as requested
1393 ChanCount in = input_streams ();
1395 list< pair<ChanCount,ChanCount> > configuration;
1398 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1400 DEBUG_TRACE (DEBUG::Processors, "{\n");
1401 for (list<boost::shared_ptr<Processor> >::const_iterator p = _processors.begin(); p != _processors.end(); ++p) {
1402 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID = %2\n", (*p)->name(), (*p)->id()));
1404 DEBUG_TRACE (DEBUG::Processors, "}\n");
1407 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1409 if ((*p)->can_support_io_configuration(in, out)) {
1410 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1in = %2 out = %3\n",(*p)->name(), in, out));
1411 configuration.push_back(make_pair(in, out));
1418 _in_configure_processors = false;
1423 // We can, so configure everything
1424 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1425 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1426 (*p)->configure_io(c->first, c->second);
1427 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1428 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1433 _meter->reset_max_channels (processor_max_streams);
1436 /* make sure we have sufficient scratch buffers to cope with the new processor
1438 _session.ensure_buffers (n_process_buffers ());
1440 _in_configure_processors = false;
1445 Route::all_processors_flip ()
1447 Glib::RWLock::ReaderLock lm (_processor_lock);
1449 if (_processors.empty()) {
1453 bool first_is_on = _processors.front()->active();
1455 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1457 (*i)->deactivate ();
1463 _session.set_dirty ();
1466 /** Set all processors with a given placement to a given active state.
1467 * @param p Placement of processors to change.
1468 * @param state New active state for those processors.
1471 Route::all_processors_active (Placement p, bool state)
1473 Glib::RWLock::ReaderLock lm (_processor_lock);
1475 if (_processors.empty()) {
1478 ProcessorList::iterator start, end;
1479 placement_range(p, start, end);
1481 bool before_amp = true;
1482 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1487 if (p == PreFader && before_amp) {
1491 (*i)->deactivate ();
1496 _session.set_dirty ();
1500 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1502 bool pre_fader = true;
1503 Glib::RWLock::ReaderLock lm (_processor_lock);
1505 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1507 /* semantic note: if p == amp, we want to return true, so test
1508 for equality before checking if this is the amp
1525 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1527 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1528 NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1529 processors in the current actual processor list that are hidden. Any visible processors
1530 in the current list but not in "new_order" will be assumed to be deleted.
1534 Glib::RWLock::WriterLock lm (_processor_lock);
1535 ChanCount old_pms = processor_max_streams;
1536 ProcessorList::iterator oiter;
1537 ProcessorList::const_iterator niter;
1538 ProcessorList as_it_was_before = _processors;
1539 ProcessorList as_it_will_be;
1541 oiter = _processors.begin();
1542 niter = new_order.begin();
1544 while (niter != new_order.end()) {
1546 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1547 then append it to the temp list.
1549 Otherwise, see if the next processor in the old list is in the new list. if not,
1550 its been deleted. If its there, append it to the temp list.
1553 if (oiter == _processors.end()) {
1555 /* no more elements in the old list, so just stick the rest of
1556 the new order onto the temp list.
1559 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1560 while (niter != new_order.end()) {
1567 if (!(*oiter)->display_to_user()) {
1569 as_it_will_be.push_back (*oiter);
1573 /* visible processor: check that its in the new order */
1575 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1576 /* deleted: do nothing, shared_ptr<> will clean up */
1578 /* ignore this one, and add the next item from the new order instead */
1579 as_it_will_be.push_back (*niter);
1584 /* now remove from old order - its taken care of no matter what */
1585 oiter = _processors.erase (oiter);
1590 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1592 if (configure_processors_unlocked (err)) {
1593 _processors = as_it_was_before;
1594 processor_max_streams = old_pms;
1600 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1613 Route::get_template()
1615 return state(false);
1619 Route::state(bool full_state)
1621 XMLNode *node = new XMLNode("Route");
1622 ProcessorList::iterator i;
1625 id().print (buf, sizeof (buf));
1626 node->add_property("id", buf);
1627 node->add_property ("name", _name);
1628 node->add_property("default-type", _default_type.to_string());
1631 node->add_property("flags", enum_2_string (_flags));
1634 node->add_property("active", _active?"yes":"no");
1635 node->add_property("phase-invert", _phase_invert?"yes":"no");
1636 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1637 node->add_property("meter-point", enum_2_string (_meter_point));
1640 node->add_property("route-group", _route_group->name());
1643 string order_string;
1644 OrderKeys::iterator x = order_keys.begin();
1646 while (x != order_keys.end()) {
1647 order_string += string ((*x).first);
1648 order_string += '=';
1649 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1650 order_string += buf;
1654 if (x == order_keys.end()) {
1658 order_string += ':';
1660 node->add_property ("order-keys", order_string);
1661 node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1662 snprintf (buf, sizeof (buf), "%d", _soloed_by_others);
1663 node->add_property ("soloed-by-others", buf);
1665 node->add_child_nocopy (_input->state (full_state));
1666 node->add_child_nocopy (_output->state (full_state));
1667 node->add_child_nocopy (_solo_control->get_state ());
1668 node->add_child_nocopy (_mute_master->get_state ());
1670 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1671 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1672 remote_control_node->add_property (X_("id"), buf);
1673 node->add_child_nocopy (*remote_control_node);
1675 if (_comment.length()) {
1676 XMLNode *cmt = node->add_child ("Comment");
1677 cmt->add_content (_comment);
1680 for (i = _processors.begin(); i != _processors.end(); ++i) {
1681 node->add_child_nocopy((*i)->state (full_state));
1685 node->add_child_copy (*_extra_xml);
1692 Route::set_state (const XMLNode& node, int version)
1694 return _set_state (node, version, true);
1698 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1700 if (version < 3000) {
1701 return _set_state_2X (node, version);
1705 XMLNodeConstIterator niter;
1707 XMLPropertyList plist;
1708 const XMLProperty *prop;
1710 if (node.name() != "Route"){
1711 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1715 if ((prop = node.property (X_("name"))) != 0) {
1716 Route::set_name (prop->value());
1719 if ((prop = node.property ("id")) != 0) {
1720 _id = prop->value ();
1723 if ((prop = node.property (X_("flags"))) != 0) {
1724 _flags = Flag (string_2_enum (prop->value(), _flags));
1729 /* add all processors (except amp, which is always present) */
1731 nlist = node.children();
1732 XMLNode processor_state (X_("processor_state"));
1734 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1738 if (child->name() == IO::state_node_name) {
1739 if ((prop = child->property (X_("direction"))) == 0) {
1743 if (prop->value() == "Input") {
1744 _input->set_state (*child, version);
1745 } else if (prop->value() == "Output") {
1746 _output->set_state (*child, version);
1750 if (child->name() == X_("Processor")) {
1751 processor_state.add_child_copy (*child);
1755 set_processor_state (processor_state);
1757 if ((prop = node.property ("self-solo")) != 0) {
1758 set_self_solo (string_is_affirmative (prop->value()));
1761 if ((prop = node.property ("soloed-by-others")) != 0) {
1762 _soloed_by_others = 0; // needed for mod_solo_by_others () to work
1763 mod_solo_by_others (atoi (prop->value()));
1766 if ((prop = node.property ("solo-isolated")) != 0) {
1767 set_solo_isolated (string_is_affirmative (prop->value()), this);
1770 if ((prop = node.property (X_("phase-invert"))) != 0) {
1771 set_phase_invert (string_is_affirmative (prop->value()));
1774 if ((prop = node.property (X_("denormal-protection"))) != 0) {
1775 set_denormal_protection (string_is_affirmative (prop->value()));
1778 if ((prop = node.property (X_("active"))) != 0) {
1779 bool yn = string_is_affirmative (prop->value());
1780 _active = !yn; // force switch
1784 if ((prop = node.property (X_("meter-point"))) != 0) {
1785 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1787 _meter->set_display_to_user (_meter_point == MeterCustom);
1791 if ((prop = node.property (X_("order-keys"))) != 0) {
1795 string::size_type colon, equal;
1796 string remaining = prop->value();
1798 while (remaining.length()) {
1800 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1801 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1804 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1805 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1808 set_order_key (remaining.substr (0, equal), n);
1812 colon = remaining.find_first_of (':');
1814 if (colon != string::npos) {
1815 remaining = remaining.substr (colon+1);
1822 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1825 if (child->name() == X_("Comment")) {
1827 /* XXX this is a terrible API design in libxml++ */
1829 XMLNode *cmt = *(child->children().begin());
1830 _comment = cmt->content();
1832 } else if (child->name() == X_("Extra")) {
1834 _extra_xml = new XMLNode (*child);
1836 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1838 if (prop->value() == "solo") {
1839 _solo_control->set_state (*child, version);
1840 _session.add_controllable (_solo_control);
1843 } else if (child->name() == X_("RemoteControl")) {
1844 if ((prop = child->property (X_("id"))) != 0) {
1846 sscanf (prop->value().c_str(), "%d", &x);
1847 set_remote_control_id (x);
1850 } else if (child->name() == X_("MuteMaster")) {
1851 _mute_master->set_state (*child, version);
1859 Route::_set_state_2X (const XMLNode& node, int version)
1862 XMLNodeConstIterator niter;
1864 XMLPropertyList plist;
1865 const XMLProperty *prop;
1867 /* 2X things which still remain to be handled:
1873 if (node.name() != "Route") {
1874 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1878 if ((prop = node.property (X_("flags"))) != 0) {
1879 _flags = Flag (string_2_enum (prop->value(), _flags));
1884 if ((prop = node.property (X_("phase-invert"))) != 0) {
1885 set_phase_invert (string_is_affirmative (prop->value()));
1888 if ((prop = node.property (X_("denormal-protection"))) != 0) {
1889 set_denormal_protection (string_is_affirmative (prop->value()));
1892 if ((prop = node.property (X_("soloed"))) != 0) {
1893 bool yn = string_is_affirmative (prop->value());
1895 /* XXX force reset of solo status */
1897 set_solo (yn, this);
1900 if ((prop = node.property (X_("muted"))) != 0) {
1903 bool muted = string_is_affirmative (prop->value());
1909 if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
1911 if (string_is_affirmative (prop->value())){
1912 mute_point = mute_point + "PreFader";
1917 if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
1919 if (string_is_affirmative (prop->value())){
1922 mute_point = mute_point + ",";
1925 mute_point = mute_point + "PostFader";
1930 if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
1932 if (string_is_affirmative (prop->value())){
1935 mute_point = mute_point + ",";
1938 mute_point = mute_point + "Listen";
1943 if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
1945 if (string_is_affirmative (prop->value())){
1948 mute_point = mute_point + ",";
1951 mute_point = mute_point + "Main";
1955 _mute_master->set_state (mute_point);
1959 if ((prop = node.property (X_("meter-point"))) != 0) {
1960 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1963 /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
1964 don't mean the same thing.
1967 if ((prop = node.property (X_("order-keys"))) != 0) {
1971 string::size_type colon, equal;
1972 string remaining = prop->value();
1974 while (remaining.length()) {
1976 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1977 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1980 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1981 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1984 set_order_key (remaining.substr (0, equal), n);
1988 colon = remaining.find_first_of (':');
1990 if (colon != string::npos) {
1991 remaining = remaining.substr (colon+1);
1998 /* add standard processors */
2000 //_meter.reset (new PeakMeter (_session));
2001 //add_processor (_meter, PreFader);
2004 /* where we listen to tracks */
2005 _intreturn.reset (new InternalReturn (_session));
2006 add_processor (_intreturn, PreFader);
2008 _monitor_control.reset (new MonitorProcessor (_session));
2009 add_processor (_monitor_control, PostFader);
2012 _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
2013 add_processor (_main_outs, PostFader);
2017 nlist = node.children ();
2018 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2022 if (child->name() == IO::state_node_name) {
2024 /* there is a note in IO::set_state_2X() about why we have to call
2028 _input->set_state_2X (*child, version, true);
2029 _output->set_state_2X (*child, version, false);
2031 if ((prop = child->property (X_("name"))) != 0) {
2032 Route::set_name (prop->value ());
2035 if ((prop = child->property (X_("id"))) != 0) {
2036 _id = prop->value ();
2039 if ((prop = child->property (X_("active"))) != 0) {
2040 bool yn = string_is_affirmative (prop->value());
2041 _active = !yn; // force switch
2045 if ((prop = child->property (X_("gain"))) != 0) {
2048 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2049 _amp->gain_control()->set_value (val);
2053 /* Set up Panners in the IO */
2054 XMLNodeList io_nlist = child->children ();
2056 XMLNodeConstIterator io_niter;
2059 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2061 io_child = *io_niter;
2063 if (io_child->name() == X_("Panner")) {
2064 _main_outs->panner()->set_state(*io_child, version);
2070 XMLNodeList redirect_nodes;
2072 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2076 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2077 redirect_nodes.push_back(child);
2082 set_processor_state_2X (redirect_nodes, version);
2084 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2087 if (child->name() == X_("Comment")) {
2089 /* XXX this is a terrible API design in libxml++ */
2091 XMLNode *cmt = *(child->children().begin());
2092 _comment = cmt->content();
2094 } else if (child->name() == X_("Extra")) {
2096 _extra_xml = new XMLNode (*child);
2098 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
2100 if (prop->value() == "solo") {
2101 _solo_control->set_state (*child, version);
2102 _session.add_controllable (_solo_control);
2105 } else if (child->name() == X_("RemoteControl")) {
2106 if ((prop = child->property (X_("id"))) != 0) {
2108 sscanf (prop->value().c_str(), "%d", &x);
2109 set_remote_control_id (x);
2119 Route::get_processor_state ()
2121 XMLNode* root = new XMLNode (X_("redirects"));
2122 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2123 root->add_child_nocopy ((*i)->state (true));
2130 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2132 /* We don't bother removing existing processors not in nList, as this
2133 method will only be called when creating a Route from scratch, not
2134 for undo purposes. Just put processors in at the appropriate place
2138 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2139 add_processor_from_xml_2X (**i, version, _processors.begin ());
2144 Route::set_processor_state (const XMLNode& node)
2146 const XMLNodeList &nlist = node.children();
2147 XMLNodeConstIterator niter;
2148 ProcessorList new_order;
2149 bool must_configure = false;
2151 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2153 XMLProperty* prop = (*niter)->property ("type");
2155 if (prop->value() == "amp") {
2156 _amp->set_state (**niter, Stateful::current_state_version);
2157 new_order.push_back (_amp);
2158 } else if (prop->value() == "meter") {
2159 _meter->set_state (**niter, Stateful::current_state_version);
2160 new_order.push_back (_meter);
2161 } else if (prop->value() == "main-outs") {
2162 _main_outs->set_state (**niter, Stateful::current_state_version);
2163 new_order.push_back (_main_outs);
2164 } else if (is_monitor() && prop->value() == "intreturn") {
2166 _intreturn.reset (new InternalReturn (_session));
2167 must_configure = true;
2169 _intreturn->set_state (**niter, Stateful::current_state_version);
2170 new_order.push_back (_intreturn);
2171 } else if (is_monitor() && prop->value() == "monitor") {
2172 if (!_monitor_control) {
2173 _monitor_control.reset (new MonitorProcessor (_session));
2174 must_configure = true;
2176 _monitor_control->set_state (**niter, Stateful::current_state_version);
2177 new_order.push_back (_monitor_control);
2179 ProcessorList::iterator o;
2181 for (o = _processors.begin(); o != _processors.end(); ++o) {
2182 XMLProperty* id_prop = (*niter)->property(X_("id"));
2183 if (id_prop && (*o)->id() == id_prop->value()) {
2184 (*o)->set_state (**niter, Stateful::current_state_version);
2185 new_order.push_back (*o);
2190 // If the processor (*niter) is not on the route then create it
2192 if (o == _processors.end()) {
2194 boost::shared_ptr<Processor> processor;
2196 if (prop->value() == "intsend") {
2198 processor.reset (new InternalSend (_session, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2200 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2201 prop->value() == "lv2" ||
2202 prop->value() == "vst" ||
2203 prop->value() == "audiounit") {
2205 processor.reset (new PluginInsert(_session));
2207 } else if (prop->value() == "port") {
2209 processor.reset (new PortInsert (_session, _mute_master));
2211 } else if (prop->value() == "send") {
2213 processor.reset (new Send (_session, _mute_master));
2216 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2220 processor->set_state (**niter, Stateful::current_state_version);
2221 new_order.push_back (processor);
2222 must_configure = true;
2228 Glib::RWLock::WriterLock lm (_processor_lock);
2229 _processors = new_order;
2230 if (must_configure) {
2231 configure_processors_unlocked (0);
2235 processors_changed (RouteProcessorChange ());
2239 Route::curve_reallocate ()
2241 // _gain_automation_curve.finish_resize ();
2242 // _pan_automation_curve.finish_resize ();
2246 Route::silence (nframes_t nframes)
2250 _output->silence (nframes);
2253 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2256 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2257 boost::shared_ptr<PluginInsert> pi;
2259 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2260 // skip plugins, they don't need anything when we're not active
2264 (*i)->silence (nframes);
2267 if (nframes == _session.get_block_size()) {
2277 Route::add_internal_return ()
2280 _intreturn.reset (new InternalReturn (_session));
2281 add_processor (_intreturn, PreFader);
2286 Route::get_return_buffer () const
2288 Glib::RWLock::ReaderLock rm (_processor_lock);
2290 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2291 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2294 BufferSet* bs = d->get_buffers ();
2303 Route::release_return_buffer () const
2305 Glib::RWLock::ReaderLock rm (_processor_lock);
2307 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2308 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2311 return d->release_buffers ();
2317 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2319 vector<string> ports;
2320 vector<string>::const_iterator i;
2323 Glib::RWLock::ReaderLock rm (_processor_lock);
2325 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2327 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2329 if (d && d->target_route() == route) {
2331 /* if the target is the control outs, then make sure
2332 we take note of which i-send is doing that.
2335 if (route == _session.monitor_out()) {
2336 _monitor_send = boost::dynamic_pointer_cast<Delivery>(d);
2337 if (_monitor_send->active()) {
2338 _monitor_send->set_solo_level (1);
2340 _monitor_send->set_solo_level (0);
2344 /* already listening via the specified IO: do nothing */
2351 boost::shared_ptr<InternalSend> listener;
2357 if (route == _session.monitor_out()) {
2358 /* master never sends to control outs */
2361 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2365 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2366 if (route == _session.monitor_out()) {
2370 } catch (failed_constructor& err) {
2374 if (route == _session.monitor_out()) {
2375 _monitor_send = listener;
2378 if (placement == PostFader) {
2379 /* put it *really* at the end, not just after the panner (main outs)
2381 add_processor (listener, _processors.end());
2383 add_processor (listener, PreFader);
2390 Route::drop_listen (boost::shared_ptr<Route> route)
2392 ProcessorStreams err;
2393 ProcessorList::iterator tmp;
2395 Glib::RWLock::ReaderLock rl(_processor_lock);
2399 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2401 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2403 if (d && d->target_route() == route) {
2405 remove_processor (*x, &err);
2408 /* list could have been demolished while we dropped the lock
2418 if (route == _session.monitor_out()) {
2419 _monitor_send.reset ();
2424 Route::set_comment (string cmt, void *src)
2427 comment_changed (src);
2428 _session.set_dirty ();
2432 Route::feeds (boost::shared_ptr<Route> other, bool* only_send)
2434 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2436 if (_output->connected_to (other->input())) {
2437 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2446 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2448 boost::shared_ptr<IOProcessor> iop;
2450 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2451 if (iop->feeds (other)) {
2452 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2458 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2461 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2466 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
2471 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2473 nframes_t now = _session.transport_frame();
2476 Glib::RWLock::ReaderLock lm (_processor_lock);
2479 automation_snapshot (now, true);
2482 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2484 if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2485 (*i)->deactivate ();
2489 (*i)->transport_stopped (now);
2493 _roll_delay = _initial_delay;
2497 Route::input_change_handler (IOChange change, void * /*src*/)
2499 if ((change & ConfigurationChanged)) {
2500 configure_processors (0);
2505 Route::output_change_handler (IOChange change, void * /*src*/)
2507 if ((change & ConfigurationChanged)) {
2509 /* XXX resize all listeners to match _main_outs? */
2511 // configure_processors (0);
2516 Route::pans_required () const
2518 if (n_outputs().n_audio() < 2) {
2522 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2526 Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2527 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2529 if (n_outputs().n_total() == 0) {
2533 if (!_active || n_inputs() == ChanCount::ZERO) {
2537 if (session_state_changing) {
2538 if (_session.transport_speed() != 0.0f) {
2539 /* we're rolling but some state is changing (e.g. our diskstream contents)
2540 so we cannot use them. Be silent till this is over.
2542 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2547 /* we're really not rolling, so we're either delivery silence or actually
2548 monitoring, both of which are safe to do while session_state_changing is true.
2552 _amp->apply_gain_automation (false);
2553 passthru (start_frame, end_frame, nframes, 0);
2559 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2561 if (_roll_delay > nframes) {
2563 _roll_delay -= nframes;
2565 /* transport frame is not legal for caller to use */
2568 } else if (_roll_delay > 0) {
2570 nframes -= _roll_delay;
2571 silence (_roll_delay);
2572 /* we've written _roll_delay of samples into the
2573 output ports, so make a note of that for
2576 _main_outs->increment_output_offset (_roll_delay);
2577 transport_frame += _roll_delay;
2586 Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
2587 bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2590 // automation snapshot can also be called from the non-rt context
2591 // and it uses the processor list, so we try to acquire the lock here
2592 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2595 automation_snapshot (_session.transport_frame(), false);
2599 if (n_outputs().n_total() == 0) {
2603 if (!_active || n_inputs().n_total() == 0) {
2608 nframes_t unused = 0;
2610 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2616 passthru (start_frame, end_frame, nframes, declick);
2622 Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
2623 bool /*can_record*/, bool /*rec_monitors_input*/, bool& /* need_butler */)
2630 Route::toggle_monitor_input ()
2632 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2633 i->ensure_monitor_input( ! i->monitoring_input());
2638 Route::has_external_redirects () const
2640 // FIXME: what about sends? - they don't return a signal back to ardour?
2642 boost::shared_ptr<const PortInsert> pi;
2644 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2646 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2648 for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2650 string port_name = port->name();
2651 string client_name = port_name.substr (0, port_name.find(':'));
2653 /* only say "yes" if the redirect is actually in use */
2655 if (client_name != "ardour" && pi->active()) {
2666 Route::flush_processors ()
2668 /* XXX shouldn't really try to take this lock, since
2669 this is called from the RT audio thread.
2672 Glib::RWLock::ReaderLock lm (_processor_lock);
2674 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2675 (*i)->deactivate ();
2681 Route::set_meter_point (MeterPoint p, void *src)
2683 /* CAN BE CALLED FROM PROCESS CONTEXT */
2685 if (_meter_point == p) {
2689 bool meter_was_visible_to_user = _meter->display_to_user ();
2692 Glib::RWLock::WriterLock lm (_processor_lock);
2694 if (p != MeterCustom) {
2695 // Move meter in the processors list to reflect the new position
2696 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2697 _processors.erase(loc);
2700 loc = _processors.begin();
2703 loc = find (_processors.begin(), _processors.end(), _amp);
2705 case MeterPostFader:
2706 loc = _processors.end();
2714 if (loc == _processors.begin()) {
2715 m_in = _input->n_ports();
2717 ProcessorList::iterator before = loc;
2719 m_in = (*before)->output_streams ();
2722 _meter->reflect_inputs (m_in);
2724 _processors.insert (loc, _meter);
2726 /* we do not need to reconfigure the processors, because the meter
2727 (a) is always ready to handle processor_max_streams
2728 (b) is always an N-in/N-out processor, and thus moving
2729 it doesn't require any changes to the other processors.
2732 _meter->set_display_to_user (false);
2736 // just make it visible and let the user move it
2738 _meter->set_display_to_user (true);
2743 meter_change (src); /* EMIT SIGNAL */
2745 bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2747 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2751 Route::put_monitor_send_at (Placement p)
2753 if (!_monitor_send) {
2758 Glib::RWLock::WriterLock lm (_processor_lock);
2759 ProcessorList as_it_was (_processors);
2760 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _monitor_send);
2761 _processors.erase(loc);
2765 loc = find(_processors.begin(), _processors.end(), _amp);
2766 if (loc != _processors.begin()) {
2771 loc = _processors.end();
2775 _processors.insert (loc, _monitor_send);
2777 if (configure_processors_unlocked (0)) {
2778 _processors = as_it_was;
2779 configure_processors_unlocked (0); // it worked before we tried to add it ...
2784 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2785 _session.set_dirty ();
2789 Route::update_total_latency ()
2791 nframes_t old = _output->effective_latency();
2792 nframes_t own_latency = _output->user_latency();
2794 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2795 if ((*i)->active ()) {
2796 own_latency += (*i)->signal_latency ();
2800 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal redirect latency = %2\n", _name, own_latency));
2802 _output->set_port_latency (own_latency);
2804 if (_output->user_latency() == 0) {
2806 /* this (virtual) function is used for pure Routes,
2807 not derived classes like AudioTrack. this means
2808 that the data processed here comes from an input
2809 port, not prerecorded material, and therefore we
2810 have to take into account any input latency.
2813 own_latency += _input->signal_latency ();
2816 if (old != own_latency) {
2817 _output->set_latency_delay (own_latency);
2818 signal_latency_changed (); /* EMIT SIGNAL */
2821 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: input latency = %2 total = %3\n", _name, _input->signal_latency(), own_latency));
2823 return _output->effective_latency ();
2827 Route::set_user_latency (nframes_t nframes)
2829 _output->set_user_latency (nframes);
2830 _session.update_latency_compensation (false, false);
2834 Route::set_latency_delay (nframes_t longest_session_latency)
2836 nframes_t old = _initial_delay;
2838 if (_output->effective_latency() < longest_session_latency) {
2839 _initial_delay = longest_session_latency - _output->effective_latency();
2844 if (_initial_delay != old) {
2845 initial_delay_changed (); /* EMIT SIGNAL */
2848 if (_session.transport_stopped()) {
2849 _roll_delay = _initial_delay;
2854 Route::automation_snapshot (nframes_t now, bool force)
2856 panner()->automation_snapshot (now, force);
2858 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2859 (*i)->automation_snapshot (now, force);
2863 Route::SoloControllable::SoloControllable (std::string name, Route& r)
2864 : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
2865 boost::shared_ptr<AutomationList>(), name)
2868 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
2873 Route::SoloControllable::set_value (float val)
2875 bool bval = ((val >= 0.5f) ? true: false);
2877 this is how it should be done
2879 boost::shared_ptr<RouteList> rl (new RouteList);
2880 rl->push_back (route);
2882 if (Config->get_solo_control_is_listen_control()) {
2883 _session.set_listen (rl, bval);
2885 _session.set_solo (rl, bval);
2888 route.set_solo (bval, this);
2893 Route::SoloControllable::get_value (void) const
2895 if (Config->get_solo_control_is_listen_control()) {
2896 return route.listening() ? 1.0f : 0.0f;
2898 return route.self_soloed() ? 1.0f : 0.0f;
2902 Route::MuteControllable::MuteControllable (std::string name, Route& r)
2903 : AutomationControl (r.session(), Evoral::Parameter (MuteAutomation),
2904 boost::shared_ptr<AutomationList>(), name)
2907 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
2912 Route::MuteControllable::set_value (float val)
2914 bool bval = ((val >= 0.5f) ? true: false);
2916 this is how it should be done
2918 boost::shared_ptr<RouteList> rl (new RouteList);
2919 rl->push_back (route);
2920 _session.set_mute (rl, bval);
2922 route.set_mute (bval, this);
2927 Route::MuteControllable::get_value (void) const
2929 return route.muted() ? 1.0f : 0.0f;
2933 Route::set_block_size (nframes_t nframes)
2935 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2936 (*i)->set_block_size (nframes);
2939 _session.ensure_buffers (n_process_buffers ());
2943 Route::protect_automation ()
2945 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
2946 (*i)->protect_automation();
2950 Route::set_pending_declick (int declick)
2953 /* this call is not allowed to turn off a pending declick unless "force" is true */
2955 _pending_declick = declick;
2957 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2959 _pending_declick = 0;
2964 /** Shift automation forwards from a particular place, thereby inserting time.
2965 * Adds undo commands for any shifts that are performed.
2967 * @param pos Position to start shifting from.
2968 * @param frames Amount to shift forwards by.
2972 Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
2974 #ifdef THIS_NEEDS_FIXING_FOR_V3
2976 /* gain automation */
2977 XMLNode &before = _gain_control->get_state ();
2978 _gain_control->shift (pos, frames);
2979 XMLNode &after = _gain_control->get_state ();
2980 _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
2982 /* pan automation */
2983 for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
2984 Curve & c = (*i)->automation ();
2985 XMLNode &before = c.get_state ();
2986 c.shift (pos, frames);
2987 XMLNode &after = c.get_state ();
2988 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
2991 /* redirect automation */
2993 Glib::RWLock::ReaderLock lm (redirect_lock);
2994 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
2997 (*i)->what_has_automation (a);
2999 for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
3000 AutomationList & al = (*i)->automation_list (*j);
3001 XMLNode &before = al.get_state ();
3002 al.shift (pos, frames);
3003 XMLNode &after = al.get_state ();
3004 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
3014 Route::save_as_template (const string& path, const string& name)
3016 XMLNode& node (state (false));
3019 IO::set_name_in_state (*node.children().front(), name);
3021 tree.set_root (&node);
3022 return tree.write (path.c_str());
3027 Route::set_name (const string& str)
3033 name = Route::ensure_track_or_route_name (str, _session);
3034 SessionObject::set_name (name);
3036 ret = (_input->set_name(name) && _output->set_name(name));
3040 Glib::RWLock::ReaderLock lm (_processor_lock);
3042 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3044 /* rename all I/O processors that have inputs or outputs */
3046 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
3048 if (iop && (iop->output() || iop->input())) {
3049 if (!iop->set_name (name)) {
3060 boost::shared_ptr<Send>
3061 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3063 Glib::RWLock::ReaderLock lm (_processor_lock);
3065 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3066 boost::shared_ptr<InternalSend> send;
3068 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3069 if (send->target_route() == target) {
3075 return boost::shared_ptr<Send>();
3079 Route::set_phase_invert (bool yn)
3081 if (_phase_invert != yn) {
3083 _phase_invert = 0xffff; // XXX all channels
3085 _phase_invert = 0; // XXX no channels
3088 phase_invert_changed (); /* EMIT SIGNAL */
3089 _session.set_dirty ();
3094 Route::phase_invert () const
3096 return _phase_invert != 0;
3100 Route::set_denormal_protection (bool yn)
3102 if (_denormal_protection != yn) {
3103 _denormal_protection = yn;
3104 denormal_protection_changed (); /* EMIT SIGNAL */
3109 Route::denormal_protection () const
3111 return _denormal_protection;
3115 Route::set_active (bool yn)
3117 if (_active != yn) {
3119 _input->set_active (yn);
3120 _output->set_active (yn);
3121 active_changed (); // EMIT SIGNAL
3128 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3134 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3136 boost::shared_ptr<Send> s;
3137 boost::shared_ptr<Return> r;
3139 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3140 s->meter()->meter();
3141 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3142 r->meter()->meter ();
3147 boost::shared_ptr<Panner>
3148 Route::panner() const
3150 return _main_outs->panner();
3153 boost::shared_ptr<AutomationControl>
3154 Route::gain_control() const
3156 return _amp->gain_control();
3159 boost::shared_ptr<AutomationControl>
3160 Route::get_control (const Evoral::Parameter& param)
3162 /* either we own the control or .... */
3164 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3168 /* maybe one of our processors does or ... */
3170 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3171 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3172 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3180 /* nobody does so we'll make a new one */
3182 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3189 boost::shared_ptr<Processor>
3190 Route::nth_plugin (uint32_t n)
3192 Glib::RWLock::ReaderLock lm (_processor_lock);
3193 ProcessorList::iterator i;
3195 for (i = _processors.begin(); i != _processors.end(); ++i) {
3196 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3203 return boost::shared_ptr<Processor> ();
3206 boost::shared_ptr<Processor>
3207 Route::nth_send (uint32_t n)
3209 Glib::RWLock::ReaderLock lm (_processor_lock);
3210 ProcessorList::iterator i;
3212 for (i = _processors.begin(); i != _processors.end(); ++i) {
3213 if (boost::dynamic_pointer_cast<Send> (*i)) {
3220 return boost::shared_ptr<Processor> ();