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.
21 #include "libardour-config.h"
29 #include "pbd/xml++.h"
30 #include "pbd/enumwriter.h"
31 #include "pbd/memento_command.h"
32 #include "pbd/stacktrace.h"
33 #include "pbd/convert.h"
34 #include "pbd/boost_debug.h"
36 #include "evoral/Curve.hpp"
38 #include "ardour/amp.h"
39 #include "ardour/audio_port.h"
40 #include "ardour/audioengine.h"
41 #include "ardour/buffer.h"
42 #include "ardour/buffer_set.h"
43 #include "ardour/configuration.h"
44 #include "ardour/cycle_timer.h"
45 #include "ardour/debug.h"
46 #include "ardour/delivery.h"
47 #include "ardour/dB.h"
48 #include "ardour/internal_send.h"
49 #include "ardour/internal_return.h"
50 #include "ardour/ladspa_plugin.h"
51 #include "ardour/meter.h"
52 #include "ardour/mix.h"
53 #include "ardour/monitor_processor.h"
54 #include "ardour/pannable.h"
55 #include "ardour/panner.h"
56 #include "ardour/panner_shell.h"
57 #include "ardour/plugin_insert.h"
58 #include "ardour/port.h"
59 #include "ardour/port_insert.h"
60 #include "ardour/processor.h"
61 #include "ardour/profile.h"
62 #include "ardour/route.h"
63 #include "ardour/route_group.h"
64 #include "ardour/send.h"
65 #include "ardour/session.h"
66 #include "ardour/timestamps.h"
67 #include "ardour/utils.h"
68 #include "ardour/graph.h"
69 #include "ardour/unknown_processor.h"
70 #include "ardour/capturing_processor.h"
75 using namespace ARDOUR;
78 uint32_t Route::order_key_cnt = 0;
79 PBD::Signal1<void,string const&> Route::SyncOrderKeys;
80 PBD::Signal0<void> Route::RemoteControlIDChange;
82 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
83 : SessionObject (sess, name)
85 , GraphNode( sess.route_graph )
91 , _pending_declick (true)
92 , _meter_point (MeterPostFader)
94 , _soloed_by_others_upstream (0)
95 , _soloed_by_others_downstream (0)
97 , _denormal_protection (false)
100 , _declickable (false)
101 , _mute_master (new MuteMaster (sess, name))
102 , _have_internal_generator (false)
104 , _default_type (default_type)
105 , _remote_control_id (0)
106 , _in_configure_processors (false)
108 processor_max_streams.reset();
109 order_keys[N_("signal")] = order_key_cnt++;
115 /* add standard controls */
117 _solo_control.reset (new SoloControllable (X_("solo"), shared_from_this ()));
118 _mute_control.reset (new MuteControllable (X_("mute"), shared_from_this ()));
120 _solo_control->set_flags (Controllable::Flag (_solo_control->flags() | Controllable::Toggle));
121 _mute_control->set_flags (Controllable::Flag (_mute_control->flags() | Controllable::Toggle));
123 add_control (_solo_control);
124 add_control (_mute_control);
128 if (!(_flags & Route::MonitorOut)) {
129 Pannable* p = new Pannable (_session);
130 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
131 boost_debug_shared_ptr_mark_interesting (p, "Pannable");
136 /* input and output objects */
138 _input.reset (new IO (_session, _name, IO::Input, _default_type));
139 _output.reset (new IO (_session, _name, IO::Output, _default_type));
141 _input->changed.connect_same_thread (*this, boost::bind (&Route::input_change_handler, this, _1, _2));
142 _input->PortCountChanging.connect_same_thread (*this, boost::bind (&Route::input_port_count_changing, this, _1));
144 /* add amp processor */
146 _amp.reset (new Amp (_session));
147 add_processor (_amp, PostFader);
149 /* create standard processors: meter, main outs, monitor out;
150 they will be added to _processors by setup_invisible_processors ()
153 _meter.reset (new PeakMeter (_session));
154 _meter->set_display_to_user (false);
157 _main_outs.reset (new Delivery (_session, _output, _pannable, _mute_master, _name, Delivery::Main));
158 _main_outs->activate ();
161 /* where we listen to tracks */
162 _intreturn.reset (new InternalReturn (_session));
163 _intreturn->activate ();
165 /* the thing that provides proper control over a control/monitor/listen bus
166 (such as per-channel cut, dim, solo, invert, etc).
168 _monitor_control.reset (new MonitorProcessor (_session));
169 _monitor_control->activate ();
172 if (is_master() || is_monitor() || is_hidden()) {
173 _mute_master->set_solo_ignore (true);
176 /* now that we have _meter, its safe to connect to this */
178 Metering::Meter.connect_same_thread (*this, (boost::bind (&Route::meter, this)));
181 /* run a configure so that the invisible processors get set up */
182 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
183 configure_processors (0);
191 DEBUG_TRACE (DEBUG::Destruction, string_compose ("route %1 destructor\n", _name));
193 /* do this early so that we don't get incoming signals as we are going through destruction
198 /* don't use clear_processors here, as it depends on the session which may
199 be half-destroyed by now
202 Glib::RWLock::WriterLock lm (_processor_lock);
203 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
204 (*i)->drop_references ();
207 _processors.clear ();
211 Route::set_remote_control_id (uint32_t id, bool notify_class_listeners)
213 if (id != _remote_control_id) {
214 _remote_control_id = id;
215 RemoteControlIDChanged ();
216 if (notify_class_listeners) {
217 RemoteControlIDChange ();
223 Route::remote_control_id() const
225 return _remote_control_id;
229 Route::order_key (std::string const & name) const
231 OrderKeys::const_iterator i = order_keys.find (name);
232 if (i == order_keys.end()) {
240 Route::set_order_key (std::string const & name, int32_t n)
242 bool changed = false;
244 /* This method looks more complicated than it should, but
245 it's important that we don't emit order_key_changed unless
246 it actually has, as expensive things happen on receipt of that
250 if (order_keys.find(name) == order_keys.end() || order_keys[name] != n) {
251 order_keys[name] = n;
255 if (Config->get_sync_all_route_ordering()) {
256 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
257 if (x->second != n) {
265 order_key_changed (); /* EMIT SIGNAL */
266 _session.set_dirty ();
270 /** Set all order keys to be the same as that for `base', if such a key
271 * exists in this route.
272 * @param base Base key.
275 Route::sync_order_keys (std::string const & base)
277 if (order_keys.empty()) {
281 OrderKeys::iterator i;
284 if ((i = order_keys.find (base)) == order_keys.end()) {
285 /* key doesn't exist, use the first existing key (during session initialization) */
286 i = order_keys.begin();
290 /* key exists - use it and reset all others (actually, itself included) */
292 i = order_keys.begin();
295 bool changed = false;
297 for (; i != order_keys.end(); ++i) {
298 if (i->second != key) {
305 order_key_changed (); /* EMIT SIGNAL */
310 Route::ensure_track_or_route_name(string name, Session &session)
312 string newname = name;
314 while (!session.io_name_is_legal (newname)) {
315 newname = bump_name_once (newname, '.');
323 Route::inc_gain (gain_t fraction, void *src)
325 _amp->inc_gain (fraction, src);
329 Route::set_gain (gain_t val, void *src)
331 if (src != 0 && _route_group && src != _route_group && _route_group->is_active() && _route_group->is_gain()) {
333 if (_route_group->is_relative()) {
335 gain_t usable_gain = _amp->gain();
336 if (usable_gain < 0.000001f) {
337 usable_gain = 0.000001f;
341 if (delta < 0.000001f) {
345 delta -= usable_gain;
350 gain_t factor = delta / usable_gain;
353 factor = _route_group->get_max_factor(factor);
354 if (factor == 0.0f) {
355 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
359 factor = _route_group->get_min_factor(factor);
360 if (factor == 0.0f) {
361 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
366 _route_group->foreach_route (boost::bind (&Route::inc_gain, _1, factor, _route_group));
370 _route_group->foreach_route (boost::bind (&Route::set_gain, _1, val, _route_group));
376 if (val == _amp->gain()) {
380 _amp->set_gain (val, src);
384 Route::maybe_declick (BufferSet&, framecnt_t, int)
386 /* this is the "bus" implementation and they never declick.
391 /** Process this route for one (sub) cycle (process thread)
393 * @param bufs Scratch buffers to use for the signal path
394 * @param start_frame Initial transport frame
395 * @param end_frame Final transport frame
396 * @param nframes Number of frames to output (to ports)
398 * Note that (end_frame - start_frame) may not be equal to nframes when the
399 * transport speed isn't 1.0 (eg varispeed).
402 Route::process_output_buffers (BufferSet& bufs,
403 framepos_t start_frame, framepos_t end_frame, pframes_t nframes,
404 bool /*with_processors*/, int declick,
405 bool gain_automation_ok)
407 bool monitor = should_monitor ();
409 bufs.is_silent (false);
411 /* figure out if we're going to use gain automation */
412 if (gain_automation_ok) {
413 _amp->setup_gain_automation (start_frame, end_frame, nframes);
415 _amp->apply_gain_automation (false);
418 /* tell main outs what to do about monitoring */
419 _main_outs->no_outs_cuz_we_no_monitor (!monitor);
422 /* -------------------------------------------------------------------------------------------
423 GLOBAL DECLICK (for transport changes etc.)
424 ----------------------------------------------------------------------------------------- */
426 maybe_declick (bufs, nframes, declick);
427 _pending_declick = 0;
429 /* -------------------------------------------------------------------------------------------
430 DENORMAL CONTROL/PHASE INVERT
431 ----------------------------------------------------------------------------------------- */
433 if (_phase_invert.any ()) {
437 if (_denormal_protection || Config->get_denormal_protection()) {
439 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
440 Sample* const sp = i->data();
442 if (_phase_invert[chn]) {
443 for (pframes_t nx = 0; nx < nframes; ++nx) {
448 for (pframes_t nx = 0; nx < nframes; ++nx) {
456 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
457 Sample* const sp = i->data();
459 if (_phase_invert[chn]) {
460 for (pframes_t nx = 0; nx < nframes; ++nx) {
469 if (_denormal_protection || Config->get_denormal_protection()) {
471 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
472 Sample* const sp = i->data();
473 for (pframes_t nx = 0; nx < nframes; ++nx) {
481 /* -------------------------------------------------------------------------------------------
483 ----------------------------------------------------------------------------------------- */
485 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
487 if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
492 /* if it has any inputs, make sure they match */
493 if ((*i)->input_streams() != ChanCount::ZERO) {
494 if (bufs.count() != (*i)->input_streams()) {
495 cerr << _name << " bufs = " << bufs.count()
496 << " input for " << (*i)->name() << " = " << (*i)->input_streams()
502 /* should we NOT run plugins here if the route is inactive?
503 do we catch route != active somewhere higher?
506 (*i)->run (bufs, start_frame, end_frame, nframes, *i != _processors.back());
507 bufs.set_count ((*i)->output_streams());
512 Route::n_process_buffers ()
514 return max (_input->n_ports(), processor_max_streams);
518 Route::passthru (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
520 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
524 assert (bufs.available() >= input_streams());
526 if (_input->n_ports() == ChanCount::ZERO) {
527 silence_unlocked (nframes);
530 bufs.set_count (input_streams());
532 if (is_monitor() && _session.listening() && !_session.is_auditioning()) {
534 /* control/monitor bus ignores input ports when something is
535 feeding the listen "stream". data will "arrive" into the
536 route from the intreturn processor element.
538 bufs.silence (nframes, 0);
542 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
544 BufferSet::iterator o = bufs.begin(*t);
545 PortSet& ports (_input->ports());
547 for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
548 o->read_from (i->get_buffer(nframes), nframes);
553 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
554 process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, true);
558 Route::passthru_silence (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick)
560 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
561 bufs.set_count (_input->n_ports());
562 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
563 process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, false);
567 Route::set_listen (bool yn, void* src)
573 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
574 _route_group->foreach_route (boost::bind (&Route::set_listen, _1, yn, _route_group));
579 if (yn != _monitor_send->active()) {
581 _monitor_send->activate ();
582 _mute_master->set_soloed (true);
584 _monitor_send->deactivate ();
585 _mute_master->set_soloed (false);
588 listen_changed (src); /* EMIT SIGNAL */
594 Route::listening_via_monitor () const
597 return _monitor_send->active ();
604 Route::set_solo_safe (bool yn, void *src)
606 if (_solo_safe != yn) {
608 solo_safe_changed (src);
613 Route::solo_safe() const
619 Route::set_solo (bool yn, void *src)
625 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
626 _route_group->foreach_route (boost::bind (&Route::set_solo, _1, yn, _route_group));
630 if (self_soloed() != yn) {
632 set_mute_master_solo ();
633 solo_changed (true, src); /* EMIT SIGNAL */
634 _solo_control->Changed (); /* EMIT SIGNAL */
639 Route::set_self_solo (bool yn)
645 Route::mod_solo_by_others_upstream (int32_t delta)
651 uint32_t old_sbu = _soloed_by_others_upstream;
654 if (_soloed_by_others_upstream >= (uint32_t) abs (delta)) {
655 _soloed_by_others_upstream += delta;
657 _soloed_by_others_upstream = 0;
660 _soloed_by_others_upstream += delta;
663 DEBUG_TRACE (DEBUG::Solo, string_compose (
664 "%1 SbU delta %2 = %3 old = %4 sbd %5 ss %6 exclusive %7\n",
665 name(), delta, _soloed_by_others_upstream, old_sbu,
666 _soloed_by_others_downstream, _self_solo, Config->get_exclusive_solo()));
668 /* push the inverse solo change to everything that feeds us.
670 This is important for solo-within-group. When we solo 1 track out of N that
671 feed a bus, that track will cause mod_solo_by_upstream (+1) to be called
672 on the bus. The bus then needs to call mod_solo_by_downstream (-1) on all
673 tracks that feed it. This will silence them if they were audible because
674 of a bus solo, but the newly soloed track will still be audible (because
677 but .. do this only when we are being told to solo-by-upstream (i.e delta = +1),
681 if ((_self_solo || _soloed_by_others_downstream) &&
682 ((old_sbu == 0 && _soloed_by_others_upstream > 0) ||
683 (old_sbu > 0 && _soloed_by_others_upstream == 0))) {
685 if (delta > 0 || !Config->get_exclusive_solo()) {
686 DEBUG_TRACE (DEBUG::Solo, "\t ... INVERT push\n");
687 for (FedBy::iterator i = _fed_by.begin(); i != _fed_by.end(); ++i) {
688 boost::shared_ptr<Route> sr = i->r.lock();
690 sr->mod_solo_by_others_downstream (-delta);
696 set_mute_master_solo ();
697 solo_changed (false, this);
701 Route::mod_solo_by_others_downstream (int32_t delta)
708 if (_soloed_by_others_downstream >= (uint32_t) abs (delta)) {
709 _soloed_by_others_downstream += delta;
711 _soloed_by_others_downstream = 0;
714 _soloed_by_others_downstream += delta;
717 DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 SbD delta %2 = %3\n", name(), delta, _soloed_by_others_downstream));
719 set_mute_master_solo ();
720 solo_changed (false, this);
724 Route::set_mute_master_solo ()
726 _mute_master->set_soloed (self_soloed() || soloed_by_others_downstream() || soloed_by_others_upstream());
730 Route::set_solo_isolated (bool yn, void *src)
732 if (is_master() || is_monitor() || is_hidden()) {
736 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_solo()) {
737 _route_group->foreach_route (boost::bind (&Route::set_solo_isolated, _1, yn, _route_group));
741 /* forward propagate solo-isolate status to everything fed by this route, but not those via sends only */
743 boost::shared_ptr<RouteList> routes = _session.get_routes ();
744 for (RouteList::iterator i = routes->begin(); i != routes->end(); ++i) {
746 if ((*i).get() == this || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
751 bool does_feed = direct_feeds (*i, &sends_only); // we will recurse anyway, so don't use ::feeds()
753 if (does_feed && !sends_only) {
754 (*i)->set_solo_isolated (yn, (*i)->route_group());
758 /* XXX should we back-propagate as well? (April 2010: myself and chris goddard think not) */
760 bool changed = false;
763 if (_solo_isolated == 0) {
764 _mute_master->set_solo_ignore (true);
769 if (_solo_isolated > 0) {
771 if (_solo_isolated == 0) {
772 _mute_master->set_solo_ignore (false);
779 solo_isolated_changed (src);
784 Route::solo_isolated () const
786 return _solo_isolated > 0;
790 Route::set_mute_points (MuteMaster::MutePoint mp)
792 _mute_master->set_mute_points (mp);
793 mute_points_changed (); /* EMIT SIGNAL */
795 if (_mute_master->muted_by_self()) {
796 mute_changed (this); /* EMIT SIGNAL */
797 _mute_control->Changed (); /* EMIT SIGNAL */
802 Route::set_mute (bool yn, void *src)
804 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_mute()) {
805 _route_group->foreach_route (boost::bind (&Route::set_mute, _1, yn, _route_group));
810 _mute_master->set_muted_by_self (yn);
811 mute_changed (src); /* EMIT SIGNAL */
812 _mute_control->Changed (); /* EMIT SIGNAL */
817 Route::muted () const
819 return _mute_master->muted_by_self();
824 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
826 cerr << name << " {" << endl;
827 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
828 p != procs.end(); ++p) {
829 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << " @ " << (*p) << endl;
836 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err, bool activation_allowed)
838 ProcessorList::iterator loc;
840 /* XXX this is not thread safe - we don't hold the lock across determining the iter
841 to add before and actually doing the insertion. dammit.
844 if (placement == PreFader) {
845 /* generic pre-fader: insert immediately before the amp */
846 loc = find (_processors.begin(), _processors.end(), _amp);
848 /* generic post-fader: insert right before the main outs */
849 loc = find (_processors.begin(), _processors.end(), _main_outs);
852 return add_processor (processor, loc, err, activation_allowed);
856 /** Add a processor to a route such that it ends up with a given index into the visible processors.
857 * @param index Index to add the processor at, or -1 to add at the end of the list.
861 Route::add_processor_by_index (boost::shared_ptr<Processor> processor, int index, ProcessorStreams* err, bool activation_allowed)
863 /* XXX this is not thread safe - we don't hold the lock across determining the iter
864 to add before and actually doing the insertion. dammit.
868 return add_processor (processor, _processors.end(), err, activation_allowed);
871 ProcessorList::iterator i = _processors.begin ();
873 while (i != _processors.end() && j < index) {
874 if ((*i)->display_to_user()) {
881 return add_processor (processor, i, err, activation_allowed);
884 /** Add a processor to the route.
885 * @param iter an iterator in _processors; the new processor will be inserted immediately before this location.
888 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err, bool activation_allowed)
890 assert (processor != _meter);
891 assert (processor != _main_outs);
893 DEBUG_TRACE (DEBUG::Processors, string_compose (
894 "%1 adding processor %2\n", name(), processor->name()));
896 if (!_session.engine().connected() || !processor) {
901 Glib::RWLock::WriterLock lm (_processor_lock);
902 ProcessorState pstate (this);
904 boost::shared_ptr<PluginInsert> pi;
905 boost::shared_ptr<PortInsert> porti;
907 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
909 if (processor == _amp) {
910 // Ensure only one amp is in the list at any time
911 if (loc != _processors.end()) {
912 if (iter == loc) { // Already in place, do nothing
914 } else { // New position given, relocate
915 _processors.erase (loc);
920 if (loc != _processors.end()) {
921 cerr << "ERROR: Processor added to route twice!" << endl;
928 _processors.insert (loc, processor);
930 // Set up processor list channels. This will set processor->[input|output]_streams(),
931 // configure redirect ports properly, etc.
934 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
936 if (configure_processors_unlocked (err)) {
938 configure_processors_unlocked (0); // it worked before we tried to add it ...
943 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
945 if (pi->has_no_inputs ()) {
946 /* generator plugin */
947 _have_internal_generator = true;
952 if (activation_allowed) {
953 processor->activate ();
956 processor->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
958 _output->set_user_latency (0);
961 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
962 set_processor_positions ();
968 Route::add_processor_from_xml_2X (const XMLNode& node, int version)
970 const XMLProperty *prop;
973 boost::shared_ptr<Processor> processor;
975 /* bit of a hack: get the `placement' property from the <Redirect> tag here
976 so that we can add the processor in the right place (pre/post-fader)
979 XMLNodeList const & children = node.children ();
980 XMLNodeList::const_iterator i = children.begin ();
982 while (i != children.end() && (*i)->name() != X_("Redirect")) {
986 Placement placement = PreFader;
988 if (i != children.end()) {
989 if ((prop = (*i)->property (X_("placement"))) != 0) {
990 placement = Placement (string_2_enum (prop->value(), placement));
994 if (node.name() == "Insert") {
996 if ((prop = node.property ("type")) != 0) {
998 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
999 prop->value() == "lv2" ||
1000 prop->value() == "vst" ||
1001 prop->value() == "lxvst" ||
1002 prop->value() == "audiounit") {
1004 processor.reset (new PluginInsert (_session));
1008 processor.reset (new PortInsert (_session, _pannable, _mute_master));
1013 } else if (node.name() == "Send") {
1015 processor.reset (new Send (_session, _pannable, _mute_master));
1019 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
1023 if (processor->set_state (node, version)) {
1027 return (add_processor (processor, placement) == 0);
1030 catch (failed_constructor &err) {
1031 warning << _("processor could not be created. Ignored.") << endmsg;
1037 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
1039 /* NOTE: this is intended to be used ONLY when copying
1040 processors from another Route. Hence the subtle
1041 differences between this and ::add_processor()
1044 ProcessorList::iterator loc;
1047 loc = find(_processors.begin(), _processors.end(), before);
1049 /* nothing specified - at end */
1050 loc = _processors.end ();
1053 if (!_session.engine().connected()) {
1057 if (others.empty()) {
1062 Glib::RWLock::WriterLock lm (_processor_lock);
1063 ProcessorState pstate (this);
1065 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
1071 boost::shared_ptr<PluginInsert> pi;
1073 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1077 _processors.insert (loc, *i);
1079 if ((*i)->active()) {
1084 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1085 if (configure_processors_unlocked (err)) {
1087 configure_processors_unlocked (0); // it worked before we tried to add it ...
1092 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
1095 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
1096 boost::shared_ptr<PluginInsert> pi;
1098 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1099 if (pi->has_no_inputs ()) {
1100 _have_internal_generator = true;
1106 _output->set_user_latency (0);
1109 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1110 set_processor_positions ();
1116 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
1118 if (p == PreFader) {
1119 start = _processors.begin();
1120 end = find(_processors.begin(), _processors.end(), _amp);
1122 start = find(_processors.begin(), _processors.end(), _amp);
1124 end = _processors.end();
1128 /** Turn off all processors with a given placement
1129 * @param p Placement of processors to disable
1132 Route::disable_processors (Placement p)
1134 Glib::RWLock::ReaderLock lm (_processor_lock);
1136 ProcessorList::iterator start, end;
1137 placement_range(p, start, end);
1139 for (ProcessorList::iterator i = start; i != end; ++i) {
1140 (*i)->deactivate ();
1143 _session.set_dirty ();
1146 /** Turn off all redirects
1149 Route::disable_processors ()
1151 Glib::RWLock::ReaderLock lm (_processor_lock);
1153 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1154 (*i)->deactivate ();
1157 _session.set_dirty ();
1160 /** Turn off all redirects with a given placement
1161 * @param p Placement of redirects to disable
1164 Route::disable_plugins (Placement p)
1166 Glib::RWLock::ReaderLock lm (_processor_lock);
1168 ProcessorList::iterator start, end;
1169 placement_range(p, start, end);
1171 for (ProcessorList::iterator i = start; i != end; ++i) {
1172 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1173 (*i)->deactivate ();
1177 _session.set_dirty ();
1180 /** Turn off all plugins
1183 Route::disable_plugins ()
1185 Glib::RWLock::ReaderLock lm (_processor_lock);
1187 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1188 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1189 (*i)->deactivate ();
1193 _session.set_dirty ();
1198 Route::ab_plugins (bool forward)
1200 Glib::RWLock::ReaderLock lm (_processor_lock);
1204 /* forward = turn off all active redirects, and mark them so that the next time
1205 we go the other way, we will revert them
1208 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1209 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1213 if ((*i)->active()) {
1214 (*i)->deactivate ();
1215 (*i)->set_next_ab_is_active (true);
1217 (*i)->set_next_ab_is_active (false);
1223 /* backward = if the redirect was marked to go active on the next ab, do so */
1225 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1227 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1231 if ((*i)->get_next_ab_is_active()) {
1234 (*i)->deactivate ();
1239 _session.set_dirty ();
1243 /** Remove processors with a given placement.
1244 * @param p Placement of processors to remove.
1247 Route::clear_processors (Placement p)
1249 if (!_session.engine().connected()) {
1253 bool already_deleting = _session.deletion_in_progress();
1254 if (!already_deleting) {
1255 _session.set_deletion_in_progress();
1259 Glib::RWLock::WriterLock lm (_processor_lock);
1260 ProcessorList new_list;
1261 ProcessorStreams err;
1262 bool seen_amp = false;
1264 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1270 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1272 /* you can't remove these */
1274 new_list.push_back (*i);
1281 new_list.push_back (*i);
1284 (*i)->drop_references ();
1292 (*i)->drop_references ();
1295 new_list.push_back (*i);
1302 _processors = new_list;
1305 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1306 configure_processors_unlocked (&err); // this can't fail
1310 processor_max_streams.reset();
1311 _have_internal_generator = false;
1312 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1313 set_processor_positions ();
1315 if (!already_deleting) {
1316 _session.clear_deletion_in_progress();
1321 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1323 /* these can never be removed */
1325 if (processor == _amp || processor == _meter || processor == _main_outs) {
1329 if (!_session.engine().connected()) {
1333 processor_max_streams.reset();
1336 Glib::RWLock::WriterLock lm (_processor_lock);
1337 ProcessorState pstate (this);
1339 ProcessorList::iterator i;
1340 bool removed = false;
1342 for (i = _processors.begin(); i != _processors.end(); ) {
1343 if (*i == processor) {
1345 /* move along, see failure case for configure_processors()
1346 where we may need to reconfigure the processor.
1349 /* stop redirects that send signals to JACK ports
1350 from causing noise as a result of no longer being
1354 boost::shared_ptr<IOProcessor> iop;
1356 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1358 iop->input()->disconnect (this);
1360 if (iop->output()) {
1361 iop->output()->disconnect (this);
1365 i = _processors.erase (i);
1373 _output->set_user_latency (0);
1382 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1384 if (configure_processors_unlocked (err)) {
1386 /* we know this will work, because it worked before :) */
1387 configure_processors_unlocked (0);
1392 _have_internal_generator = false;
1394 for (i = _processors.begin(); i != _processors.end(); ++i) {
1395 boost::shared_ptr<PluginInsert> pi;
1397 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1398 if (pi->has_no_inputs ()) {
1399 _have_internal_generator = true;
1406 processor->drop_references ();
1407 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1408 set_processor_positions ();
1414 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1416 ProcessorList deleted;
1418 if (!_session.engine().connected()) {
1422 processor_max_streams.reset();
1425 Glib::RWLock::WriterLock lm (_processor_lock);
1426 ProcessorState pstate (this);
1428 ProcessorList::iterator i;
1429 boost::shared_ptr<Processor> processor;
1431 for (i = _processors.begin(); i != _processors.end(); ) {
1435 /* these can never be removed */
1437 if (processor == _amp || processor == _meter || processor == _main_outs) {
1442 /* see if its in the list of processors to delete */
1444 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1449 /* stop IOProcessors that send to JACK ports
1450 from causing noise as a result of no longer being
1454 boost::shared_ptr<IOProcessor> iop;
1456 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1460 deleted.push_back (processor);
1461 i = _processors.erase (i);
1464 if (deleted.empty()) {
1465 /* none of those in the requested list were found */
1469 _output->set_user_latency (0);
1472 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1474 if (configure_processors_unlocked (err)) {
1476 /* we know this will work, because it worked before :) */
1477 configure_processors_unlocked (0);
1482 _have_internal_generator = false;
1484 for (i = _processors.begin(); i != _processors.end(); ++i) {
1485 boost::shared_ptr<PluginInsert> pi;
1487 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1488 if (pi->has_no_inputs ()) {
1489 _have_internal_generator = true;
1496 /* now try to do what we need to so that those that were removed will be deleted */
1498 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1499 (*i)->drop_references ();
1502 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1503 set_processor_positions ();
1508 /** Caller must hold process lock */
1510 Route::configure_processors (ProcessorStreams* err)
1512 assert (!AudioEngine::instance()->process_lock().trylock());
1514 if (!_in_configure_processors) {
1515 Glib::RWLock::WriterLock lm (_processor_lock);
1516 return configure_processors_unlocked (err);
1523 Route::input_streams () const
1525 return _input->n_ports ();
1528 list<pair<ChanCount, ChanCount> >
1529 Route::try_configure_processors (ChanCount in, ProcessorStreams* err)
1531 Glib::RWLock::ReaderLock lm (_processor_lock);
1533 return try_configure_processors_unlocked (in, err);
1536 list<pair<ChanCount, ChanCount> >
1537 Route::try_configure_processors_unlocked (ChanCount in, ProcessorStreams* err)
1539 // Check each processor in order to see if we can configure as requested
1541 list<pair<ChanCount, ChanCount> > configuration;
1544 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configure processors\n", _name));
1545 DEBUG_TRACE (DEBUG::Processors, "{\n");
1547 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1549 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1550 DEBUG_TRACE (DEBUG::Processors, "--- CONFIGURE ABORTED due to unknown processor.\n");
1554 if ((*p)->can_support_io_configuration(in, out)) {
1555 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1 ID=%2 in=%3 out=%4\n",(*p)->name(), (*p)->id(), in, out));
1556 configuration.push_back(make_pair(in, out));
1563 DEBUG_TRACE (DEBUG::Processors, "---- CONFIGURATION FAILED.\n");
1564 DEBUG_TRACE (DEBUG::Processors, string_compose ("---- %1 cannot support in=%2 out=%3\n", (*p)->name(), in, out));
1565 DEBUG_TRACE (DEBUG::Processors, "}\n");
1566 return list<pair<ChanCount, ChanCount> > ();
1570 DEBUG_TRACE (DEBUG::Processors, "}\n");
1572 return configuration;
1575 /** Set the input/output configuration of each processor in the processors list.
1576 * Caller must hold process lock.
1577 * Return 0 on success, otherwise configuration is impossible.
1580 Route::configure_processors_unlocked (ProcessorStreams* err)
1582 assert (!AudioEngine::instance()->process_lock().trylock());
1584 if (_in_configure_processors) {
1588 /* put invisible processors where they should be */
1589 setup_invisible_processors ();
1591 _in_configure_processors = true;
1593 list<pair<ChanCount, ChanCount> > configuration = try_configure_processors_unlocked (input_streams (), err);
1595 if (configuration.empty ()) {
1596 _in_configure_processors = false;
1602 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1603 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1605 if (boost::dynamic_pointer_cast<UnknownProcessor> (*p)) {
1609 (*p)->configure_io(c->first, c->second);
1610 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1611 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1616 _meter->reset_max_channels (processor_max_streams);
1619 /* make sure we have sufficient scratch buffers to cope with the new processor
1622 _session.ensure_buffers (n_process_buffers ());
1624 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: configuration complete\n", _name));
1626 _in_configure_processors = false;
1630 /** Set all processors with a given placement to a given active state.
1631 * @param p Placement of processors to change.
1632 * @param state New active state for those processors.
1635 Route::all_processors_active (Placement p, bool state)
1637 Glib::RWLock::ReaderLock lm (_processor_lock);
1639 if (_processors.empty()) {
1643 ProcessorList::iterator start, end;
1644 placement_range(p, start, end);
1646 for (ProcessorList::iterator i = start; i != end; ++i) {
1650 (*i)->deactivate ();
1654 _session.set_dirty ();
1658 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1660 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1661 NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1662 processors in the current actual processor list that are hidden. Any visible processors
1663 in the current list but not in "new_order" will be assumed to be deleted.
1667 Glib::RWLock::WriterLock lm (_processor_lock);
1668 ProcessorState pstate (this);
1670 ProcessorList::iterator oiter;
1671 ProcessorList::const_iterator niter;
1672 ProcessorList as_it_will_be;
1674 oiter = _processors.begin();
1675 niter = new_order.begin();
1677 while (niter != new_order.end()) {
1679 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1680 then append it to the temp list.
1682 Otherwise, see if the next processor in the old list is in the new list. if not,
1683 its been deleted. If its there, append it to the temp list.
1686 if (oiter == _processors.end()) {
1688 /* no more elements in the old list, so just stick the rest of
1689 the new order onto the temp list.
1692 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1693 while (niter != new_order.end()) {
1700 if (!(*oiter)->display_to_user()) {
1702 as_it_will_be.push_back (*oiter);
1706 /* visible processor: check that its in the new order */
1708 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1709 /* deleted: do nothing, shared_ptr<> will clean up */
1711 /* ignore this one, and add the next item from the new order instead */
1712 as_it_will_be.push_back (*niter);
1717 /* now remove from old order - its taken care of no matter what */
1718 oiter = _processors.erase (oiter);
1723 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1726 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1728 if (configure_processors_unlocked (err)) {
1735 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1736 set_processor_positions ();
1748 Route::get_template()
1750 return state(false);
1754 Route::state(bool full_state)
1756 XMLNode *node = new XMLNode("Route");
1757 ProcessorList::iterator i;
1760 id().print (buf, sizeof (buf));
1761 node->add_property("id", buf);
1762 node->add_property ("name", _name);
1763 node->add_property("default-type", _default_type.to_string());
1766 node->add_property("flags", enum_2_string (_flags));
1769 node->add_property("active", _active?"yes":"no");
1771 boost::to_string (_phase_invert, p);
1772 node->add_property("phase-invert", p);
1773 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1774 node->add_property("meter-point", enum_2_string (_meter_point));
1777 node->add_property("route-group", _route_group->name());
1780 string order_string;
1781 OrderKeys::iterator x = order_keys.begin();
1783 while (x != order_keys.end()) {
1784 order_string += string ((*x).first);
1785 order_string += '=';
1786 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1787 order_string += buf;
1791 if (x == order_keys.end()) {
1795 order_string += ':';
1797 node->add_property ("order-keys", order_string);
1798 node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1799 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1800 node->add_property ("soloed-by-upstream", buf);
1801 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1802 node->add_property ("soloed-by-downstream", buf);
1803 node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1804 node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1806 node->add_child_nocopy (_input->state (full_state));
1807 node->add_child_nocopy (_output->state (full_state));
1808 node->add_child_nocopy (_solo_control->get_state ());
1809 node->add_child_nocopy (_mute_control->get_state ());
1810 node->add_child_nocopy (_mute_master->get_state ());
1812 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1813 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1814 remote_control_node->add_property (X_("id"), buf);
1815 node->add_child_nocopy (*remote_control_node);
1817 if (_comment.length()) {
1818 XMLNode *cmt = node->add_child ("Comment");
1819 cmt->add_content (_comment);
1823 node->add_child_nocopy (_pannable->state (full_state));
1826 for (i = _processors.begin(); i != _processors.end(); ++i) {
1827 node->add_child_nocopy((*i)->state (full_state));
1831 node->add_child_copy (*_extra_xml);
1838 Route::set_state (const XMLNode& node, int version)
1840 return _set_state (node, version);
1844 Route::_set_state (const XMLNode& node, int version)
1846 if (version < 3000) {
1847 return _set_state_2X (node, version);
1851 XMLNodeConstIterator niter;
1853 const XMLProperty *prop;
1855 if (node.name() != "Route"){
1856 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1860 if ((prop = node.property (X_("name"))) != 0) {
1861 Route::set_name (prop->value());
1866 if ((prop = node.property (X_("flags"))) != 0) {
1867 _flags = Flag (string_2_enum (prop->value(), _flags));
1872 if (is_master() || is_monitor() || is_hidden()) {
1873 _mute_master->set_solo_ignore (true);
1877 /* monitor bus does not get a panner, but if (re)created
1878 via XML, it will already have one by the time we
1879 call ::set_state(). so ... remove it.
1884 /* add all processors (except amp, which is always present) */
1886 nlist = node.children();
1887 XMLNode processor_state (X_("processor_state"));
1889 Stateful::save_extra_xml (node);
1891 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1895 if (child->name() == IO::state_node_name) {
1896 if ((prop = child->property (X_("direction"))) == 0) {
1900 if (prop->value() == "Input") {
1901 _input->set_state (*child, version);
1902 } else if (prop->value() == "Output") {
1903 _output->set_state (*child, version);
1907 if (child->name() == X_("Processor")) {
1908 processor_state.add_child_copy (*child);
1912 if (child->name() == X_("Pannable")) {
1914 _pannable->set_state (*child, version);
1916 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
1921 if ((prop = node.property (X_("meter-point"))) != 0) {
1922 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
1923 set_meter_point (mp, true);
1925 _meter->set_display_to_user (_meter_point == MeterCustom);
1929 set_processor_state (processor_state);
1931 if ((prop = node.property ("self-solo")) != 0) {
1932 set_self_solo (string_is_affirmative (prop->value()));
1935 if ((prop = node.property ("soloed-by-upstream")) != 0) {
1936 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1937 mod_solo_by_others_upstream (atoi (prop->value()));
1940 if ((prop = node.property ("soloed-by-downstream")) != 0) {
1941 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1942 mod_solo_by_others_downstream (atoi (prop->value()));
1945 if ((prop = node.property ("solo-isolated")) != 0) {
1946 set_solo_isolated (string_is_affirmative (prop->value()), this);
1949 if ((prop = node.property ("solo-safe")) != 0) {
1950 set_solo_safe (string_is_affirmative (prop->value()), this);
1953 if ((prop = node.property (X_("phase-invert"))) != 0) {
1954 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1957 if ((prop = node.property (X_("denormal-protection"))) != 0) {
1958 set_denormal_protection (string_is_affirmative (prop->value()));
1961 if ((prop = node.property (X_("active"))) != 0) {
1962 bool yn = string_is_affirmative (prop->value());
1963 _active = !yn; // force switch
1964 set_active (yn, this);
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(), "%d", &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 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2001 if (child->name() == X_("Comment")) {
2003 /* XXX this is a terrible API design in libxml++ */
2005 XMLNode *cmt = *(child->children().begin());
2006 _comment = cmt->content();
2008 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2009 if (prop->value() == "solo") {
2010 _solo_control->set_state (*child, version);
2013 } else if (child->name() == X_("RemoteControl")) {
2014 if ((prop = child->property (X_("id"))) != 0) {
2016 sscanf (prop->value().c_str(), "%d", &x);
2017 set_remote_control_id (x);
2020 } else if (child->name() == X_("MuteMaster")) {
2021 _mute_master->set_state (*child, version);
2029 Route::_set_state_2X (const XMLNode& node, int version)
2032 XMLNodeConstIterator niter;
2034 const XMLProperty *prop;
2036 /* 2X things which still remain to be handled:
2042 if (node.name() != "Route") {
2043 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2047 if ((prop = node.property (X_("flags"))) != 0) {
2048 _flags = Flag (string_2_enum (prop->value(), _flags));
2053 if ((prop = node.property (X_("phase-invert"))) != 0) {
2054 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2055 if (string_is_affirmative (prop->value ())) {
2058 set_phase_invert (p);
2061 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2062 set_denormal_protection (string_is_affirmative (prop->value()));
2065 if ((prop = node.property (X_("soloed"))) != 0) {
2066 bool yn = string_is_affirmative (prop->value());
2068 /* XXX force reset of solo status */
2070 set_solo (yn, this);
2073 if ((prop = node.property (X_("muted"))) != 0) {
2076 bool muted = string_is_affirmative (prop->value());
2082 if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2084 if (string_is_affirmative (prop->value())){
2085 mute_point = mute_point + "PreFader";
2090 if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2092 if (string_is_affirmative (prop->value())){
2095 mute_point = mute_point + ",";
2098 mute_point = mute_point + "PostFader";
2103 if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2105 if (string_is_affirmative (prop->value())){
2108 mute_point = mute_point + ",";
2111 mute_point = mute_point + "Listen";
2116 if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2118 if (string_is_affirmative (prop->value())){
2121 mute_point = mute_point + ",";
2124 mute_point = mute_point + "Main";
2128 _mute_master->set_mute_points (mute_point);
2129 _mute_master->set_muted_by_self (true);
2133 if ((prop = node.property (X_("meter-point"))) != 0) {
2134 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2137 /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2138 don't mean the same thing.
2141 if ((prop = node.property (X_("order-keys"))) != 0) {
2145 string::size_type colon, equal;
2146 string remaining = prop->value();
2148 while (remaining.length()) {
2150 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2151 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2154 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2155 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2158 set_order_key (remaining.substr (0, equal), n);
2162 colon = remaining.find_first_of (':');
2164 if (colon != string::npos) {
2165 remaining = remaining.substr (colon+1);
2174 nlist = node.children ();
2175 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2179 if (child->name() == IO::state_node_name) {
2181 /* there is a note in IO::set_state_2X() about why we have to call
2185 _input->set_state_2X (*child, version, true);
2186 _output->set_state_2X (*child, version, false);
2188 if ((prop = child->property (X_("name"))) != 0) {
2189 Route::set_name (prop->value ());
2194 if ((prop = child->property (X_("active"))) != 0) {
2195 bool yn = string_is_affirmative (prop->value());
2196 _active = !yn; // force switch
2197 set_active (yn, this);
2200 if ((prop = child->property (X_("gain"))) != 0) {
2203 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2204 _amp->gain_control()->set_value (val);
2208 /* Set up Panners in the IO */
2209 XMLNodeList io_nlist = child->children ();
2211 XMLNodeConstIterator io_niter;
2214 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2216 io_child = *io_niter;
2218 if (io_child->name() == X_("Panner")) {
2219 _main_outs->panner_shell()->set_state(*io_child, version);
2220 } else if (io_child->name() == X_("Automation")) {
2221 /* IO's automation is for the fader */
2222 _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2228 XMLNodeList redirect_nodes;
2230 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2234 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2235 redirect_nodes.push_back(child);
2240 set_processor_state_2X (redirect_nodes, version);
2242 Stateful::save_extra_xml (node);
2244 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2247 if (child->name() == X_("Comment")) {
2249 /* XXX this is a terrible API design in libxml++ */
2251 XMLNode *cmt = *(child->children().begin());
2252 _comment = cmt->content();
2254 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2255 if (prop->value() == X_("solo")) {
2256 _solo_control->set_state (*child, version);
2257 } else if (prop->value() == X_("mute")) {
2258 _mute_control->set_state (*child, version);
2261 } else if (child->name() == X_("RemoteControl")) {
2262 if ((prop = child->property (X_("id"))) != 0) {
2264 sscanf (prop->value().c_str(), "%d", &x);
2265 set_remote_control_id (x);
2275 Route::get_processor_state ()
2277 XMLNode* root = new XMLNode (X_("redirects"));
2278 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2279 root->add_child_nocopy ((*i)->state (true));
2286 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2288 /* We don't bother removing existing processors not in nList, as this
2289 method will only be called when creating a Route from scratch, not
2290 for undo purposes. Just put processors in at the appropriate place
2294 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2295 add_processor_from_xml_2X (**i, version);
2300 Route::set_processor_state (const XMLNode& node)
2302 const XMLNodeList &nlist = node.children();
2303 XMLNodeConstIterator niter;
2304 ProcessorList new_order;
2305 bool must_configure = false;
2307 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2309 XMLProperty* prop = (*niter)->property ("type");
2311 if (prop->value() == "amp") {
2312 _amp->set_state (**niter, Stateful::current_state_version);
2313 new_order.push_back (_amp);
2314 } else if (prop->value() == "meter") {
2315 _meter->set_state (**niter, Stateful::current_state_version);
2316 new_order.push_back (_meter);
2317 } else if (prop->value() == "main-outs") {
2318 _main_outs->set_state (**niter, Stateful::current_state_version);
2319 } else if (prop->value() == "intreturn") {
2321 _intreturn.reset (new InternalReturn (_session));
2322 must_configure = true;
2324 _intreturn->set_state (**niter, Stateful::current_state_version);
2325 } else if (is_monitor() && prop->value() == "monitor") {
2326 if (!_monitor_control) {
2327 _monitor_control.reset (new MonitorProcessor (_session));
2328 must_configure = true;
2330 _monitor_control->set_state (**niter, Stateful::current_state_version);
2331 } else if (prop->value() == "capture") {
2332 _capturing_processor.reset (new CapturingProcessor (_session));
2334 ProcessorList::iterator o;
2336 for (o = _processors.begin(); o != _processors.end(); ++o) {
2337 XMLProperty* id_prop = (*niter)->property(X_("id"));
2338 if (id_prop && (*o)->id() == id_prop->value()) {
2339 (*o)->set_state (**niter, Stateful::current_state_version);
2340 new_order.push_back (*o);
2345 // If the processor (*niter) is not on the route then create it
2347 if (o == _processors.end()) {
2349 boost::shared_ptr<Processor> processor;
2351 if (prop->value() == "intsend") {
2353 processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2355 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2356 prop->value() == "lv2" ||
2357 prop->value() == "vst" ||
2358 prop->value() == "lxvst" ||
2359 prop->value() == "audiounit") {
2361 processor.reset (new PluginInsert(_session));
2363 } else if (prop->value() == "port") {
2365 processor.reset (new PortInsert (_session, _pannable, _mute_master));
2367 } else if (prop->value() == "send") {
2369 processor.reset (new Send (_session, _pannable, _mute_master));
2372 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2376 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2377 /* This processor could not be configured. Turn it into a UnknownProcessor */
2378 processor.reset (new UnknownProcessor (_session, **niter));
2381 /* we have to note the monitor send here, otherwise a new one will be created
2382 and the state of this one will be lost.
2384 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2385 if (isend && isend->role() == Delivery::Listen) {
2386 _monitor_send = isend;
2389 /* it doesn't matter if invisible processors are added here, as they
2390 will be sorted out by setup_invisible_processors () shortly.
2393 new_order.push_back (processor);
2394 must_configure = true;
2400 Glib::RWLock::WriterLock lm (_processor_lock);
2401 _processors = new_order;
2403 if (must_configure) {
2404 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2405 configure_processors_unlocked (0);
2408 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2410 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2412 boost::shared_ptr<PluginInsert> pi;
2414 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2415 if (pi->has_no_inputs ()) {
2416 _have_internal_generator = true;
2423 processors_changed (RouteProcessorChange ());
2424 set_processor_positions ();
2428 Route::curve_reallocate ()
2430 // _gain_automation_curve.finish_resize ();
2431 // _pan_automation_curve.finish_resize ();
2435 Route::silence (framecnt_t nframes)
2437 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2442 silence_unlocked (nframes);
2446 Route::silence_unlocked (framecnt_t nframes)
2448 /* Must be called with the processor lock held */
2452 _output->silence (nframes);
2454 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2455 boost::shared_ptr<PluginInsert> pi;
2457 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2458 // skip plugins, they don't need anything when we're not active
2462 (*i)->silence (nframes);
2465 if (nframes == _session.get_block_size()) {
2472 Route::add_internal_return ()
2475 _intreturn.reset (new InternalReturn (_session));
2476 add_processor (_intreturn, PreFader);
2481 Route::add_send_to_internal_return (InternalSend* send)
2483 Glib::RWLock::ReaderLock rm (_processor_lock);
2485 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2486 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2489 return d->add_send (send);
2495 Route::remove_send_from_internal_return (InternalSend* send)
2497 Glib::RWLock::ReaderLock rm (_processor_lock);
2499 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2500 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2503 return d->remove_send (send);
2508 /** Add a monitor send (if we don't already have one) but don't activate it */
2510 Route::listen_via_monitor ()
2512 /* master never sends to control outs */
2513 assert (!is_master ());
2515 /* make sure we have one */
2516 if (!_monitor_send) {
2517 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2518 _monitor_send->set_display_to_user (false);
2522 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2523 configure_processors (0);
2528 /** Add an internal send to a route.
2529 * @param route route to send to.
2530 * @param placement placement for the send.
2533 Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
2535 assert (route != _session.monitor_out ());
2538 Glib::RWLock::ReaderLock rm (_processor_lock);
2540 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2542 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2544 if (d && d->target_route() == route) {
2545 /* already listening via the specified IO: do nothing */
2552 boost::shared_ptr<InternalSend> listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2553 add_processor (listener, placement);
2555 } catch (failed_constructor& err) {
2563 Route::drop_listen (boost::shared_ptr<Route> route)
2565 ProcessorStreams err;
2566 ProcessorList::iterator tmp;
2568 Glib::RWLock::ReaderLock rl(_processor_lock);
2572 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2574 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2576 if (d && d->target_route() == route) {
2578 remove_processor (*x, &err);
2581 /* list could have been demolished while we dropped the lock
2591 if (route == _session.monitor_out()) {
2592 _monitor_send.reset ();
2597 Route::set_comment (string cmt, void *src)
2600 comment_changed (src);
2601 _session.set_dirty ();
2605 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2607 FeedRecord fr (other, via_sends_only);
2609 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
2611 if (!result.second) {
2613 /* already a record for "other" - make sure sends-only information is correct */
2614 if (!via_sends_only && result.first->sends_only) {
2615 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2616 frp->sends_only = false;
2620 return result.second;
2624 Route::clear_fed_by ()
2630 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2632 const FedBy& fed_by (other->fed_by());
2634 for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2635 boost::shared_ptr<Route> sr = f->r.lock();
2637 if (sr && (sr.get() == this)) {
2639 if (via_sends_only) {
2640 *via_sends_only = f->sends_only;
2651 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2653 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2655 if (_output->connected_to (other->input())) {
2656 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2665 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2667 boost::shared_ptr<IOProcessor> iop;
2669 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2670 if (iop->feeds (other)) {
2671 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2677 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2680 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2685 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
2689 /** Called from the (non-realtime) butler thread when the transport is stopped */
2691 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2693 framepos_t now = _session.transport_frame();
2696 Glib::RWLock::ReaderLock lm (_processor_lock);
2699 automation_snapshot (now, true);
2702 Automatable::transport_stopped (now);
2704 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2706 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2710 (*i)->transport_stopped (now);
2714 _roll_delay = _initial_delay;
2717 /** Called with the process lock held if change contains ConfigurationChanged */
2719 Route::input_change_handler (IOChange change, void * /*src*/)
2721 if ((change.type & IOChange::ConfigurationChanged)) {
2722 configure_processors (0);
2723 _phase_invert.resize (_input->n_ports().n_audio ());
2724 io_changed (); /* EMIT SIGNAL */
2729 Route::pans_required () const
2731 if (n_outputs().n_audio() < 2) {
2735 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2739 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
2741 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2746 if (n_outputs().n_total() == 0) {
2750 if (!_active || n_inputs() == ChanCount::ZERO) {
2751 silence_unlocked (nframes);
2754 if (session_state_changing) {
2755 if (_session.transport_speed() != 0.0f) {
2756 /* we're rolling but some state is changing (e.g. our diskstream contents)
2757 so we cannot use them. Be silent till this is over.
2759 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2761 silence_unlocked (nframes);
2764 /* we're really not rolling, so we're either delivery silence or actually
2765 monitoring, both of which are safe to do while session_state_changing is true.
2769 _amp->apply_gain_automation (false);
2770 passthru (start_frame, end_frame, nframes, 0);
2776 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
2778 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2783 automation_snapshot (_session.transport_frame(), false);
2785 if (n_outputs().n_total() == 0) {
2789 if (!_active || n_inputs().n_total() == 0) {
2790 silence_unlocked (nframes);
2794 framecnt_t unused = 0;
2796 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2802 passthru (start_frame, end_frame, nframes, declick);
2808 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
2815 Route::toggle_monitor_input ()
2817 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2818 i->ensure_monitor_input( ! i->monitoring_input());
2823 Route::has_external_redirects () const
2825 // FIXME: what about sends? - they don't return a signal back to ardour?
2827 boost::shared_ptr<const PortInsert> pi;
2829 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2831 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2833 for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2835 string port_name = port->name();
2836 string client_name = port_name.substr (0, port_name.find(':'));
2838 /* only say "yes" if the redirect is actually in use */
2840 if (client_name != "ardour" && pi->active()) {
2851 Route::flush_processors ()
2853 /* XXX shouldn't really try to take this lock, since
2854 this is called from the RT audio thread.
2857 Glib::RWLock::ReaderLock lm (_processor_lock);
2859 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2865 Route::set_meter_point (MeterPoint p, bool force)
2867 /* CAN BE CALLED FROM PROCESS CONTEXT */
2869 if (_meter_point == p && !force) {
2875 bool meter_was_visible_to_user = _meter->display_to_user ();
2878 Glib::RWLock::WriterLock lm (_processor_lock);
2880 if (_meter_point != MeterCustom) {
2882 _meter->set_display_to_user (false);
2884 setup_invisible_processors ();
2886 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2890 if (loc == _processors.begin()) {
2891 m_in = _input->n_ports();
2893 ProcessorList::iterator before = loc;
2895 m_in = (*before)->output_streams ();
2898 _meter->reflect_inputs (m_in);
2900 /* we do not need to reconfigure the processors, because the meter
2901 (a) is always ready to handle processor_max_streams
2902 (b) is always an N-in/N-out processor, and thus moving
2903 it doesn't require any changes to the other processors.
2908 // just make it visible and let the user move it
2910 _meter->set_display_to_user (true);
2914 meter_change (); /* EMIT SIGNAL */
2916 bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2918 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2922 Route::listen_position_changed ()
2925 Glib::RWLock::WriterLock lm (_processor_lock);
2926 ProcessorState pstate (this);
2929 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2931 if (configure_processors_unlocked (0)) {
2933 configure_processors_unlocked (0); // it worked before we tried to add it ...
2939 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2940 _session.set_dirty ();
2943 boost::shared_ptr<CapturingProcessor>
2944 Route::add_export_point()
2946 if (!_capturing_processor) {
2948 _capturing_processor.reset (new CapturingProcessor (_session));
2949 _capturing_processor->activate ();
2952 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2953 configure_processors (0);
2958 return _capturing_processor;
2962 Route::update_signal_latency ()
2964 framecnt_t l = _output->user_latency();
2966 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2967 if ((*i)->active ()) {
2968 l += (*i)->signal_latency ();
2972 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
2974 if (_signal_latency != l) {
2975 _signal_latency = l;
2976 signal_latency_changed (); /* EMIT SIGNAL */
2979 return _signal_latency;
2983 Route::set_user_latency (framecnt_t nframes)
2985 _output->set_user_latency (nframes);
2986 _session.update_latency_compensation ();
2990 Route::set_latency_compensation (framecnt_t longest_session_latency)
2992 framecnt_t old = _initial_delay;
2994 if (_signal_latency < longest_session_latency) {
2995 _initial_delay = longest_session_latency - _signal_latency;
3000 DEBUG_TRACE (DEBUG::Latency, string_compose (
3001 "%1: compensate for maximum latency of %2,"
3002 "given own latency of %3, using initial delay of %4\n",
3003 name(), longest_session_latency, _signal_latency, _initial_delay));
3005 if (_initial_delay != old) {
3006 initial_delay_changed (); /* EMIT SIGNAL */
3009 if (_session.transport_stopped()) {
3010 _roll_delay = _initial_delay;
3015 Route::automation_snapshot (framepos_t now, bool force)
3018 _pannable->automation_snapshot (now, force);
3021 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3022 (*i)->automation_snapshot (now, force);
3026 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3027 : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3028 boost::shared_ptr<AutomationList>(), name)
3031 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3036 Route::SoloControllable::set_value (double val)
3038 bool bval = ((val >= 0.5f) ? true: false);
3040 boost::shared_ptr<RouteList> rl (new RouteList);
3042 boost::shared_ptr<Route> r = _route.lock ();
3049 if (Config->get_solo_control_is_listen_control()) {
3050 _session.set_listen (rl, bval);
3052 _session.set_solo (rl, bval);
3057 Route::SoloControllable::get_value () const
3059 boost::shared_ptr<Route> r = _route.lock ();
3064 if (Config->get_solo_control_is_listen_control()) {
3065 return r->listening_via_monitor() ? 1.0f : 0.0f;
3067 return r->self_soloed() ? 1.0f : 0.0f;
3071 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3072 : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3073 boost::shared_ptr<AutomationList>(), name)
3076 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3081 Route::MuteControllable::set_value (double val)
3083 bool bval = ((val >= 0.5f) ? true: false);
3085 boost::shared_ptr<RouteList> rl (new RouteList);
3087 boost::shared_ptr<Route> r = _route.lock ();
3093 _session.set_mute (rl, bval);
3097 Route::MuteControllable::get_value () const
3099 boost::shared_ptr<Route> r = _route.lock ();
3104 return r->muted() ? 1.0f : 0.0f;
3108 Route::set_block_size (pframes_t nframes)
3110 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3111 (*i)->set_block_size (nframes);
3114 _session.ensure_buffers (n_process_buffers ());
3118 Route::protect_automation ()
3120 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3121 (*i)->protect_automation();
3125 Route::set_pending_declick (int declick)
3128 /* this call is not allowed to turn off a pending declick unless "force" is true */
3130 _pending_declick = declick;
3132 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3134 _pending_declick = 0;
3139 /** Shift automation forwards from a particular place, thereby inserting time.
3140 * Adds undo commands for any shifts that are performed.
3142 * @param pos Position to start shifting from.
3143 * @param frames Amount to shift forwards by.
3147 Route::shift (framepos_t pos, framecnt_t frames)
3149 /* gain automation */
3151 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3153 XMLNode &before = gc->alist()->get_state ();
3154 gc->alist()->shift (pos, frames);
3155 XMLNode &after = gc->alist()->get_state ();
3156 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3159 /* pan automation */
3161 ControlSet::Controls& c (_pannable->controls());
3163 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3164 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3166 boost::shared_ptr<AutomationList> al = pc->alist();
3167 XMLNode& before = al->get_state ();
3168 al->shift (pos, frames);
3169 XMLNode& after = al->get_state ();
3170 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3175 /* redirect automation */
3177 Glib::RWLock::ReaderLock lm (_processor_lock);
3178 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3180 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3182 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3183 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3185 boost::shared_ptr<AutomationList> al = ac->alist();
3186 XMLNode &before = al->get_state ();
3187 al->shift (pos, frames);
3188 XMLNode &after = al->get_state ();
3189 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3198 Route::save_as_template (const string& path, const string& name)
3200 XMLNode& node (state (false));
3203 IO::set_name_in_state (*node.children().front(), name);
3205 tree.set_root (&node);
3206 return tree.write (path.c_str());
3211 Route::set_name (const string& str)
3217 name = Route::ensure_track_or_route_name (str, _session);
3218 SessionObject::set_name (name);
3220 ret = (_input->set_name(name) && _output->set_name(name));
3223 /* rename the main outs. Leave other IO processors
3224 * with whatever name they already have, because its
3225 * just fine as it is (it will not contain the route
3226 * name if its a port insert, port send or port return).
3230 if (_main_outs->set_name (name)) {
3231 /* XXX returning false here is stupid because
3232 we already changed the route name.
3242 boost::shared_ptr<Send>
3243 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3245 Glib::RWLock::ReaderLock lm (_processor_lock);
3247 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3248 boost::shared_ptr<InternalSend> send;
3250 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3251 if (send->target_route() == target) {
3257 return boost::shared_ptr<Send>();
3260 /** @param c Audio channel index.
3261 * @param yn true to invert phase, otherwise false.
3264 Route::set_phase_invert (uint32_t c, bool yn)
3266 if (_phase_invert[c] != yn) {
3267 _phase_invert[c] = yn;
3268 phase_invert_changed (); /* EMIT SIGNAL */
3269 _session.set_dirty ();
3274 Route::set_phase_invert (boost::dynamic_bitset<> p)
3276 if (_phase_invert != p) {
3278 phase_invert_changed (); /* EMIT SIGNAL */
3279 _session.set_dirty ();
3284 Route::phase_invert (uint32_t c) const
3286 return _phase_invert[c];
3289 boost::dynamic_bitset<>
3290 Route::phase_invert () const
3292 return _phase_invert;
3296 Route::set_denormal_protection (bool yn)
3298 if (_denormal_protection != yn) {
3299 _denormal_protection = yn;
3300 denormal_protection_changed (); /* EMIT SIGNAL */
3305 Route::denormal_protection () const
3307 return _denormal_protection;
3311 Route::set_active (bool yn, void* src)
3313 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3314 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3318 if (_active != yn) {
3320 _input->set_active (yn);
3321 _output->set_active (yn);
3322 active_changed (); // EMIT SIGNAL
3329 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3335 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3337 boost::shared_ptr<Send> s;
3338 boost::shared_ptr<Return> r;
3340 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3341 s->meter()->meter();
3342 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3343 r->meter()->meter ();
3348 boost::shared_ptr<Pannable>
3349 Route::pannable() const
3354 boost::shared_ptr<Panner>
3355 Route::panner() const
3358 return _main_outs->panner_shell()->panner();
3361 boost::shared_ptr<PannerShell>
3362 Route::panner_shell() const
3364 return _main_outs->panner_shell();
3367 boost::shared_ptr<AutomationControl>
3368 Route::gain_control() const
3370 return _amp->gain_control();
3373 boost::shared_ptr<AutomationControl>
3374 Route::get_control (const Evoral::Parameter& param)
3376 /* either we own the control or .... */
3378 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3382 /* maybe one of our processors does or ... */
3384 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3385 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3386 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3394 /* nobody does so we'll make a new one */
3396 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3403 boost::shared_ptr<Processor>
3404 Route::nth_plugin (uint32_t n)
3406 Glib::RWLock::ReaderLock lm (_processor_lock);
3407 ProcessorList::iterator i;
3409 for (i = _processors.begin(); i != _processors.end(); ++i) {
3410 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3417 return boost::shared_ptr<Processor> ();
3420 boost::shared_ptr<Processor>
3421 Route::nth_send (uint32_t n)
3423 Glib::RWLock::ReaderLock lm (_processor_lock);
3424 ProcessorList::iterator i;
3426 for (i = _processors.begin(); i != _processors.end(); ++i) {
3427 if (boost::dynamic_pointer_cast<Send> (*i)) {
3434 return boost::shared_ptr<Processor> ();
3438 Route::has_io_processor_named (const string& name)
3440 Glib::RWLock::ReaderLock lm (_processor_lock);
3441 ProcessorList::iterator i;
3443 for (i = _processors.begin(); i != _processors.end(); ++i) {
3444 if (boost::dynamic_pointer_cast<Send> (*i) ||
3445 boost::dynamic_pointer_cast<PortInsert> (*i)) {
3446 if ((*i)->name() == name) {
3455 MuteMaster::MutePoint
3456 Route::mute_points () const
3458 return _mute_master->mute_points ();
3462 Route::set_processor_positions ()
3464 Glib::RWLock::ReaderLock lm (_processor_lock);
3466 bool had_amp = false;
3467 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3468 (*i)->set_pre_fader (!had_amp);
3469 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3475 /** Called when there is a proposed change to the input port count */
3477 Route::input_port_count_changing (ChanCount to)
3479 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3481 /* The processors cannot be configured with the new input arrangement, so
3487 /* The change is ok */
3492 Route::unknown_processors () const
3496 Glib::RWLock::ReaderLock lm (_processor_lock);
3497 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3498 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3499 p.push_back ((*i)->name ());
3508 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3510 /* we assume that all our input ports feed all our output ports. its not
3511 universally true, but the alternative is way too corner-case to worry about.
3514 jack_latency_range_t all_connections;
3517 all_connections.min = 0;
3518 all_connections.max = 0;
3520 all_connections.min = ~((jack_nframes_t) 0);
3521 all_connections.max = 0;
3523 /* iterate over all "from" ports and determine the latency range for all of their
3524 connections to the "outside" (outside of this Route).
3527 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3529 jack_latency_range_t range;
3531 p->get_connected_latency_range (range, playback);
3533 all_connections.min = min (all_connections.min, range.min);
3534 all_connections.max = max (all_connections.max, range.max);
3538 /* set the "from" port latencies to the max/min range of all their connections */
3540 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3541 p->set_private_latency_range (all_connections, playback);
3544 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3546 all_connections.min += our_latency;
3547 all_connections.max += our_latency;
3549 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3550 p->set_private_latency_range (all_connections, playback);
3553 return all_connections.max;
3557 Route::set_private_port_latencies (bool playback) const
3559 framecnt_t own_latency = 0;
3561 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3562 OR LATENCY CALLBACK.
3564 This is called (early) from the latency callback. It computes the REAL
3565 latency associated with each port and stores the result as the "private"
3566 latency of the port. A later call to Route::set_public_port_latencies()
3567 sets all ports to the same value to reflect the fact that we do latency
3568 compensation and so all signals are delayed by the same amount as they
3569 flow through ardour.
3572 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3573 if ((*i)->active ()) {
3574 own_latency += (*i)->signal_latency ();
3579 /* playback: propagate latency from "outside the route" to outputs to inputs */
3580 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3582 /* capture: propagate latency from "outside the route" to inputs to outputs */
3583 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3588 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3590 /* this is called to set the JACK-visible port latencies, which take
3591 latency compensation into account.
3594 jack_latency_range_t range;
3600 const PortSet& ports (_input->ports());
3601 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3602 p->set_public_latency_range (range, playback);
3607 const PortSet& ports (_output->ports());
3608 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3609 p->set_public_latency_range (range, playback);
3614 /** Put the invisible processors in the right place in _processors.
3615 * Must be called with a writer lock on _processor_lock held.
3618 Route::setup_invisible_processors ()
3621 Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3622 assert (!lm.locked ());
3626 /* too early to be doing this stuff */
3630 /* we'll build this new list here and then use it */
3632 ProcessorList new_processors;
3634 /* find visible processors */
3636 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3637 if ((*i)->display_to_user ()) {
3638 new_processors.push_back (*i);
3644 ProcessorList::iterator amp = new_processors.begin ();
3645 while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3649 assert (amp != _processors.end ());
3651 /* and the processor after the amp */
3653 ProcessorList::iterator after_amp = amp;
3659 switch (_meter_point) {
3661 assert (!_meter->display_to_user ());
3662 new_processors.push_front (_meter);
3665 assert (!_meter->display_to_user ());
3666 new_processors.insert (amp, _meter);
3668 case MeterPostFader:
3669 /* do nothing here */
3672 /* do nothing here */
3675 /* the meter is visible, so we don't touch it here */
3682 assert (_main_outs);
3683 assert (!_main_outs->display_to_user ());
3684 new_processors.push_back (_main_outs);
3686 /* iterator for the main outs */
3688 ProcessorList::iterator main = new_processors.end();
3691 /* OUTPUT METERING */
3693 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3694 assert (!_meter->display_to_user ());
3696 /* add the processor just before or just after the main outs */
3698 ProcessorList::iterator meter_point = main;
3700 if (_meter_point == MeterOutput) {
3703 new_processors.insert (meter_point, _meter);
3708 if (_monitor_send && !is_monitor ()) {
3709 assert (!_monitor_send->display_to_user ());
3710 if (Config->get_solo_control_is_listen_control()) {
3711 switch (Config->get_listen_position ()) {
3712 case PreFaderListen:
3713 switch (Config->get_pfl_position ()) {
3714 case PFLFromBeforeProcessors:
3715 new_processors.push_front (_monitor_send);
3717 case PFLFromAfterProcessors:
3718 new_processors.insert (amp, _monitor_send);
3721 _monitor_send->set_can_pan (false);
3723 case AfterFaderListen:
3724 switch (Config->get_afl_position ()) {
3725 case AFLFromBeforeProcessors:
3726 new_processors.insert (after_amp, _monitor_send);
3728 case AFLFromAfterProcessors:
3729 new_processors.insert (new_processors.end(), _monitor_send);
3732 _monitor_send->set_can_pan (true);
3736 new_processors.insert (new_processors.end(), _monitor_send);
3737 _monitor_send->set_can_pan (false);
3741 /* MONITOR CONTROL */
3743 if (_monitor_control && is_monitor ()) {
3744 assert (!_monitor_control->display_to_user ());
3745 new_processors.push_front (_monitor_control);
3748 /* INTERNAL RETURN */
3750 /* doing this here means that any monitor control will come just after
3755 assert (!_intreturn->display_to_user ());
3756 new_processors.push_front (_intreturn);
3759 /* EXPORT PROCESSOR */
3761 if (_capturing_processor) {
3762 assert (!_capturing_processor->display_to_user ());
3763 new_processors.push_front (_capturing_processor);
3766 _processors = new_processors;
3768 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3769 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3770 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3775 Route::should_monitor () const
3777 switch (Config->get_monitoring_model()) {
3778 case HardwareMonitoring:
3779 case ExternalMonitoring:
3780 return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
3792 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3793 Glib::RWLock::ReaderLock lp (_processor_lock);
3797 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3798 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);