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;
1631 Route::all_processors_flip ()
1633 Glib::RWLock::ReaderLock lm (_processor_lock);
1635 if (_processors.empty()) {
1639 bool first_is_on = _processors.front()->active();
1641 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1643 (*i)->deactivate ();
1649 _session.set_dirty ();
1652 /** Set all processors with a given placement to a given active state.
1653 * @param p Placement of processors to change.
1654 * @param state New active state for those processors.
1657 Route::all_processors_active (Placement p, bool state)
1659 Glib::RWLock::ReaderLock lm (_processor_lock);
1661 if (_processors.empty()) {
1665 ProcessorList::iterator start, end;
1666 placement_range(p, start, end);
1668 for (ProcessorList::iterator i = start; i != end; ++i) {
1672 (*i)->deactivate ();
1676 _session.set_dirty ();
1680 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1682 bool pre_fader = true;
1683 Glib::RWLock::ReaderLock lm (_processor_lock);
1685 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1687 /* semantic note: if p == amp, we want to return true, so test
1688 for equality before checking if this is the amp
1705 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1707 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1708 NOTE: all processors in "new_order" MUST be marked as display_to_user(). There maybe additional
1709 processors in the current actual processor list that are hidden. Any visible processors
1710 in the current list but not in "new_order" will be assumed to be deleted.
1714 Glib::RWLock::WriterLock lm (_processor_lock);
1715 ProcessorState pstate (this);
1717 ProcessorList::iterator oiter;
1718 ProcessorList::const_iterator niter;
1719 ProcessorList as_it_will_be;
1721 oiter = _processors.begin();
1722 niter = new_order.begin();
1724 while (niter != new_order.end()) {
1726 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1727 then append it to the temp list.
1729 Otherwise, see if the next processor in the old list is in the new list. if not,
1730 its been deleted. If its there, append it to the temp list.
1733 if (oiter == _processors.end()) {
1735 /* no more elements in the old list, so just stick the rest of
1736 the new order onto the temp list.
1739 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1740 while (niter != new_order.end()) {
1747 if (!(*oiter)->display_to_user()) {
1749 as_it_will_be.push_back (*oiter);
1753 /* visible processor: check that its in the new order */
1755 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1756 /* deleted: do nothing, shared_ptr<> will clean up */
1758 /* ignore this one, and add the next item from the new order instead */
1759 as_it_will_be.push_back (*niter);
1764 /* now remove from old order - its taken care of no matter what */
1765 oiter = _processors.erase (oiter);
1770 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1773 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
1775 if (configure_processors_unlocked (err)) {
1782 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
1783 set_processor_positions ();
1795 Route::get_template()
1797 return state(false);
1801 Route::state(bool full_state)
1803 XMLNode *node = new XMLNode("Route");
1804 ProcessorList::iterator i;
1807 id().print (buf, sizeof (buf));
1808 node->add_property("id", buf);
1809 node->add_property ("name", _name);
1810 node->add_property("default-type", _default_type.to_string());
1813 node->add_property("flags", enum_2_string (_flags));
1816 node->add_property("active", _active?"yes":"no");
1818 boost::to_string (_phase_invert, p);
1819 node->add_property("phase-invert", p);
1820 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1821 node->add_property("meter-point", enum_2_string (_meter_point));
1824 node->add_property("route-group", _route_group->name());
1827 string order_string;
1828 OrderKeys::iterator x = order_keys.begin();
1830 while (x != order_keys.end()) {
1831 order_string += string ((*x).first);
1832 order_string += '=';
1833 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1834 order_string += buf;
1838 if (x == order_keys.end()) {
1842 order_string += ':';
1844 node->add_property ("order-keys", order_string);
1845 node->add_property ("self-solo", (_self_solo ? "yes" : "no"));
1846 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_upstream);
1847 node->add_property ("soloed-by-upstream", buf);
1848 snprintf (buf, sizeof (buf), "%d", _soloed_by_others_downstream);
1849 node->add_property ("soloed-by-downstream", buf);
1850 node->add_property ("solo-isolated", solo_isolated() ? "yes" : "no");
1851 node->add_property ("solo-safe", _solo_safe ? "yes" : "no");
1853 node->add_child_nocopy (_input->state (full_state));
1854 node->add_child_nocopy (_output->state (full_state));
1855 node->add_child_nocopy (_solo_control->get_state ());
1856 node->add_child_nocopy (_mute_control->get_state ());
1857 node->add_child_nocopy (_mute_master->get_state ());
1859 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1860 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1861 remote_control_node->add_property (X_("id"), buf);
1862 node->add_child_nocopy (*remote_control_node);
1864 if (_comment.length()) {
1865 XMLNode *cmt = node->add_child ("Comment");
1866 cmt->add_content (_comment);
1870 node->add_child_nocopy (_pannable->state (full_state));
1873 for (i = _processors.begin(); i != _processors.end(); ++i) {
1874 node->add_child_nocopy((*i)->state (full_state));
1878 node->add_child_copy (*_extra_xml);
1885 Route::set_state (const XMLNode& node, int version)
1887 return _set_state (node, version);
1891 Route::_set_state (const XMLNode& node, int version)
1893 if (version < 3000) {
1894 return _set_state_2X (node, version);
1898 XMLNodeConstIterator niter;
1900 const XMLProperty *prop;
1902 if (node.name() != "Route"){
1903 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1907 if ((prop = node.property (X_("name"))) != 0) {
1908 Route::set_name (prop->value());
1913 if ((prop = node.property (X_("flags"))) != 0) {
1914 _flags = Flag (string_2_enum (prop->value(), _flags));
1919 if (is_master() || is_monitor() || is_hidden()) {
1920 _mute_master->set_solo_ignore (true);
1924 /* monitor bus does not get a panner, but if (re)created
1925 via XML, it will already have one by the time we
1926 call ::set_state(). so ... remove it.
1931 /* add all processors (except amp, which is always present) */
1933 nlist = node.children();
1934 XMLNode processor_state (X_("processor_state"));
1936 Stateful::save_extra_xml (node);
1938 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1942 if (child->name() == IO::state_node_name) {
1943 if ((prop = child->property (X_("direction"))) == 0) {
1947 if (prop->value() == "Input") {
1948 _input->set_state (*child, version);
1949 } else if (prop->value() == "Output") {
1950 _output->set_state (*child, version);
1954 if (child->name() == X_("Processor")) {
1955 processor_state.add_child_copy (*child);
1959 if (child->name() == X_("Pannable")) {
1961 _pannable->set_state (*child, version);
1963 warning << string_compose (_("Pannable state found for route (%1) without a panner!"), name()) << endmsg;
1968 set_processor_state (processor_state);
1970 if ((prop = node.property ("self-solo")) != 0) {
1971 set_self_solo (string_is_affirmative (prop->value()));
1974 if ((prop = node.property ("soloed-by-upstream")) != 0) {
1975 _soloed_by_others_upstream = 0; // needed for mod_.... () to work
1976 mod_solo_by_others_upstream (atoi (prop->value()));
1979 if ((prop = node.property ("soloed-by-downstream")) != 0) {
1980 _soloed_by_others_downstream = 0; // needed for mod_.... () to work
1981 mod_solo_by_others_downstream (atoi (prop->value()));
1984 if ((prop = node.property ("solo-isolated")) != 0) {
1985 set_solo_isolated (string_is_affirmative (prop->value()), this);
1988 if ((prop = node.property ("solo-safe")) != 0) {
1989 set_solo_safe (string_is_affirmative (prop->value()), this);
1992 if ((prop = node.property (X_("phase-invert"))) != 0) {
1993 set_phase_invert (boost::dynamic_bitset<> (prop->value ()));
1996 if ((prop = node.property (X_("denormal-protection"))) != 0) {
1997 set_denormal_protection (string_is_affirmative (prop->value()));
2000 if ((prop = node.property (X_("active"))) != 0) {
2001 bool yn = string_is_affirmative (prop->value());
2002 _active = !yn; // force switch
2003 set_active (yn, this);
2006 if ((prop = node.property (X_("meter-point"))) != 0) {
2007 MeterPoint mp = MeterPoint (string_2_enum (prop->value (), _meter_point));
2008 set_meter_point (mp, true);
2010 _meter->set_display_to_user (_meter_point == MeterCustom);
2014 if ((prop = node.property (X_("order-keys"))) != 0) {
2018 string::size_type colon, equal;
2019 string remaining = prop->value();
2021 while (remaining.length()) {
2023 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2024 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2027 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2028 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2031 set_order_key (remaining.substr (0, equal), n);
2035 colon = remaining.find_first_of (':');
2037 if (colon != string::npos) {
2038 remaining = remaining.substr (colon+1);
2045 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2048 if (child->name() == X_("Comment")) {
2050 /* XXX this is a terrible API design in libxml++ */
2052 XMLNode *cmt = *(child->children().begin());
2053 _comment = cmt->content();
2055 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2056 if (prop->value() == "solo") {
2057 _solo_control->set_state (*child, version);
2060 } else if (child->name() == X_("RemoteControl")) {
2061 if ((prop = child->property (X_("id"))) != 0) {
2063 sscanf (prop->value().c_str(), "%d", &x);
2064 set_remote_control_id (x);
2067 } else if (child->name() == X_("MuteMaster")) {
2068 _mute_master->set_state (*child, version);
2076 Route::_set_state_2X (const XMLNode& node, int version)
2079 XMLNodeConstIterator niter;
2081 const XMLProperty *prop;
2083 /* 2X things which still remain to be handled:
2089 if (node.name() != "Route") {
2090 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
2094 if ((prop = node.property (X_("flags"))) != 0) {
2095 _flags = Flag (string_2_enum (prop->value(), _flags));
2100 if ((prop = node.property (X_("phase-invert"))) != 0) {
2101 boost::dynamic_bitset<> p (_input->n_ports().n_audio ());
2102 if (string_is_affirmative (prop->value ())) {
2105 set_phase_invert (p);
2108 if ((prop = node.property (X_("denormal-protection"))) != 0) {
2109 set_denormal_protection (string_is_affirmative (prop->value()));
2112 if ((prop = node.property (X_("soloed"))) != 0) {
2113 bool yn = string_is_affirmative (prop->value());
2115 /* XXX force reset of solo status */
2117 set_solo (yn, this);
2120 if ((prop = node.property (X_("muted"))) != 0) {
2123 bool muted = string_is_affirmative (prop->value());
2129 if ((prop = node.property (X_("mute-affects-pre-fader"))) != 0) {
2131 if (string_is_affirmative (prop->value())){
2132 mute_point = mute_point + "PreFader";
2137 if ((prop = node.property (X_("mute-affects-post-fader"))) != 0) {
2139 if (string_is_affirmative (prop->value())){
2142 mute_point = mute_point + ",";
2145 mute_point = mute_point + "PostFader";
2150 if ((prop = node.property (X_("mute-affects-control-outs"))) != 0) {
2152 if (string_is_affirmative (prop->value())){
2155 mute_point = mute_point + ",";
2158 mute_point = mute_point + "Listen";
2163 if ((prop = node.property (X_("mute-affects-main-outs"))) != 0) {
2165 if (string_is_affirmative (prop->value())){
2168 mute_point = mute_point + ",";
2171 mute_point = mute_point + "Main";
2175 _mute_master->set_mute_points (mute_point);
2176 _mute_master->set_muted_by_self (true);
2180 if ((prop = node.property (X_("meter-point"))) != 0) {
2181 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
2184 /* do not carry over edit/mix groups from 2.X because (a) its hard (b) they
2185 don't mean the same thing.
2188 if ((prop = node.property (X_("order-keys"))) != 0) {
2192 string::size_type colon, equal;
2193 string remaining = prop->value();
2195 while (remaining.length()) {
2197 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
2198 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2201 if (sscanf (remaining.substr (equal+1).c_str(), "%d", &n) != 1) {
2202 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
2205 set_order_key (remaining.substr (0, equal), n);
2209 colon = remaining.find_first_of (':');
2211 if (colon != string::npos) {
2212 remaining = remaining.substr (colon+1);
2221 nlist = node.children ();
2222 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2226 if (child->name() == IO::state_node_name) {
2228 /* there is a note in IO::set_state_2X() about why we have to call
2232 _input->set_state_2X (*child, version, true);
2233 _output->set_state_2X (*child, version, false);
2235 if ((prop = child->property (X_("name"))) != 0) {
2236 Route::set_name (prop->value ());
2241 if ((prop = child->property (X_("active"))) != 0) {
2242 bool yn = string_is_affirmative (prop->value());
2243 _active = !yn; // force switch
2244 set_active (yn, this);
2247 if ((prop = child->property (X_("gain"))) != 0) {
2250 if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
2251 _amp->gain_control()->set_value (val);
2255 /* Set up Panners in the IO */
2256 XMLNodeList io_nlist = child->children ();
2258 XMLNodeConstIterator io_niter;
2261 for (io_niter = io_nlist.begin(); io_niter != io_nlist.end(); ++io_niter) {
2263 io_child = *io_niter;
2265 if (io_child->name() == X_("Panner")) {
2266 _main_outs->panner_shell()->set_state(*io_child, version);
2267 } else if (io_child->name() == X_("Automation")) {
2268 /* IO's automation is for the fader */
2269 _amp->set_automation_xml_state (*io_child, Evoral::Parameter (GainAutomation));
2275 XMLNodeList redirect_nodes;
2277 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2281 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
2282 redirect_nodes.push_back(child);
2287 set_processor_state_2X (redirect_nodes, version);
2289 Stateful::save_extra_xml (node);
2291 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2294 if (child->name() == X_("Comment")) {
2296 /* XXX this is a terrible API design in libxml++ */
2298 XMLNode *cmt = *(child->children().begin());
2299 _comment = cmt->content();
2301 } else if (child->name() == Controllable::xml_node_name && (prop = child->property("name")) != 0) {
2302 if (prop->value() == X_("solo")) {
2303 _solo_control->set_state (*child, version);
2304 } else if (prop->value() == X_("mute")) {
2305 _mute_control->set_state (*child, version);
2308 } else if (child->name() == X_("RemoteControl")) {
2309 if ((prop = child->property (X_("id"))) != 0) {
2311 sscanf (prop->value().c_str(), "%d", &x);
2312 set_remote_control_id (x);
2322 Route::get_processor_state ()
2324 XMLNode* root = new XMLNode (X_("redirects"));
2325 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2326 root->add_child_nocopy ((*i)->state (true));
2333 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2335 /* We don't bother removing existing processors not in nList, as this
2336 method will only be called when creating a Route from scratch, not
2337 for undo purposes. Just put processors in at the appropriate place
2341 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2342 add_processor_from_xml_2X (**i, version);
2347 Route::set_processor_state (const XMLNode& node)
2349 const XMLNodeList &nlist = node.children();
2350 XMLNodeConstIterator niter;
2351 ProcessorList new_order;
2352 bool must_configure = false;
2354 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2356 XMLProperty* prop = (*niter)->property ("type");
2358 if (prop->value() == "amp") {
2359 _amp->set_state (**niter, Stateful::current_state_version);
2360 new_order.push_back (_amp);
2361 } else if (prop->value() == "meter") {
2362 _meter->set_state (**niter, Stateful::current_state_version);
2363 } else if (prop->value() == "main-outs") {
2364 _main_outs->set_state (**niter, Stateful::current_state_version);
2365 } else if (prop->value() == "intreturn") {
2367 _intreturn.reset (new InternalReturn (_session));
2368 must_configure = true;
2370 _intreturn->set_state (**niter, Stateful::current_state_version);
2371 } else if (is_monitor() && prop->value() == "monitor") {
2372 if (!_monitor_control) {
2373 _monitor_control.reset (new MonitorProcessor (_session));
2374 must_configure = true;
2376 _monitor_control->set_state (**niter, Stateful::current_state_version);
2377 } else if (prop->value() == "capture") {
2378 _capturing_processor.reset (new CapturingProcessor (_session));
2380 ProcessorList::iterator o;
2382 for (o = _processors.begin(); o != _processors.end(); ++o) {
2383 XMLProperty* id_prop = (*niter)->property(X_("id"));
2384 if (id_prop && (*o)->id() == id_prop->value()) {
2385 (*o)->set_state (**niter, Stateful::current_state_version);
2386 new_order.push_back (*o);
2391 // If the processor (*niter) is not on the route then create it
2393 if (o == _processors.end()) {
2395 boost::shared_ptr<Processor> processor;
2397 if (prop->value() == "intsend") {
2399 processor.reset (new InternalSend (_session, _pannable, _mute_master, boost::shared_ptr<Route>(), Delivery::Role (0)));
2401 } else if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
2402 prop->value() == "lv2" ||
2403 prop->value() == "vst" ||
2404 prop->value() == "lxvst" ||
2405 prop->value() == "audiounit") {
2407 processor.reset (new PluginInsert(_session));
2409 } else if (prop->value() == "port") {
2411 processor.reset (new PortInsert (_session, _pannable, _mute_master));
2413 } else if (prop->value() == "send") {
2415 processor.reset (new Send (_session, _pannable, _mute_master));
2418 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
2422 if (processor->set_state (**niter, Stateful::current_state_version) != 0) {
2423 /* This processor could not be configured. Turn it into a UnknownProcessor */
2424 processor.reset (new UnknownProcessor (_session, **niter));
2427 /* we have to note the monitor send here, otherwise a new one will be created
2428 and the state of this one will be lost.
2430 boost::shared_ptr<InternalSend> isend = boost::dynamic_pointer_cast<InternalSend> (processor);
2431 if (isend && isend->role() == Delivery::Listen) {
2432 _monitor_send = isend;
2435 /* it doesn't matter if invisible processors are added here, as they
2436 will be sorted out by setup_invisible_processors () shortly.
2439 new_order.push_back (processor);
2440 must_configure = true;
2446 Glib::RWLock::WriterLock lm (_processor_lock);
2447 _processors = new_order;
2449 if (must_configure) {
2450 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2451 configure_processors_unlocked (0);
2454 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2456 (*i)->ActiveChanged.connect_same_thread (*this, boost::bind (&Session::update_latency_compensation, &_session, false));
2458 boost::shared_ptr<PluginInsert> pi;
2460 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
2461 if (pi->has_no_inputs ()) {
2462 _have_internal_generator = true;
2469 processors_changed (RouteProcessorChange ());
2470 set_processor_positions ();
2474 Route::curve_reallocate ()
2476 // _gain_automation_curve.finish_resize ();
2477 // _pan_automation_curve.finish_resize ();
2481 Route::silence (framecnt_t nframes)
2483 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2488 silence_unlocked (nframes);
2492 Route::silence_unlocked (framecnt_t nframes)
2494 /* Must be called with the processor lock held */
2498 _output->silence (nframes);
2500 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2501 boost::shared_ptr<PluginInsert> pi;
2503 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2504 // skip plugins, they don't need anything when we're not active
2508 (*i)->silence (nframes);
2511 if (nframes == _session.get_block_size()) {
2518 Route::add_internal_return ()
2521 _intreturn.reset (new InternalReturn (_session));
2522 add_processor (_intreturn, PreFader);
2527 Route::add_send_to_internal_return (InternalSend* send)
2529 Glib::RWLock::ReaderLock rm (_processor_lock);
2531 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2532 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2535 return d->add_send (send);
2541 Route::remove_send_from_internal_return (InternalSend* send)
2543 Glib::RWLock::ReaderLock rm (_processor_lock);
2545 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2546 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2549 return d->remove_send (send);
2554 /** Add a monitor send (if we don't already have one) but don't activate it */
2556 Route::listen_via_monitor ()
2558 /* master never sends to control outs */
2559 assert (!is_master ());
2561 /* make sure we have one */
2562 if (!_monitor_send) {
2563 _monitor_send.reset (new InternalSend (_session, _pannable, _mute_master, _session.monitor_out(), Delivery::Listen));
2564 _monitor_send->set_display_to_user (false);
2568 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2569 configure_processors (0);
2574 /** Add an internal send to a route.
2575 * @param route route to send to.
2576 * @param placement placement for the send.
2579 Route::listen_via (boost::shared_ptr<Route> route, Placement placement)
2581 assert (route != _session.monitor_out ());
2584 Glib::RWLock::ReaderLock rm (_processor_lock);
2586 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2588 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend> (*x);
2590 if (d && d->target_route() == route) {
2591 /* already listening via the specified IO: do nothing */
2598 boost::shared_ptr<InternalSend> listener (new InternalSend (_session, _pannable, _mute_master, route, Delivery::Aux));
2599 add_processor (listener, placement);
2601 } catch (failed_constructor& err) {
2609 Route::drop_listen (boost::shared_ptr<Route> route)
2611 ProcessorStreams err;
2612 ProcessorList::iterator tmp;
2614 Glib::RWLock::ReaderLock rl(_processor_lock);
2618 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2620 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2622 if (d && d->target_route() == route) {
2624 remove_processor (*x, &err);
2627 /* list could have been demolished while we dropped the lock
2637 if (route == _session.monitor_out()) {
2638 _monitor_send.reset ();
2643 Route::set_comment (string cmt, void *src)
2646 comment_changed (src);
2647 _session.set_dirty ();
2651 Route::add_fed_by (boost::shared_ptr<Route> other, bool via_sends_only)
2653 FeedRecord fr (other, via_sends_only);
2655 pair<FedBy::iterator,bool> result = _fed_by.insert (fr);
2657 if (!result.second) {
2659 /* already a record for "other" - make sure sends-only information is correct */
2660 if (!via_sends_only && result.first->sends_only) {
2661 FeedRecord* frp = const_cast<FeedRecord*>(&(*result.first));
2662 frp->sends_only = false;
2666 return result.second;
2670 Route::clear_fed_by ()
2676 Route::feeds (boost::shared_ptr<Route> other, bool* via_sends_only)
2678 const FedBy& fed_by (other->fed_by());
2680 for (FedBy::iterator f = fed_by.begin(); f != fed_by.end(); ++f) {
2681 boost::shared_ptr<Route> sr = f->r.lock();
2683 if (sr && (sr.get() == this)) {
2685 if (via_sends_only) {
2686 *via_sends_only = f->sends_only;
2697 Route::direct_feeds (boost::shared_ptr<Route> other, bool* only_send)
2699 DEBUG_TRACE (DEBUG::Graph, string_compose ("Feeds? %1\n", _name));
2701 if (_output->connected_to (other->input())) {
2702 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdirect FEEDS %2\n", other->name()));
2711 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
2713 boost::shared_ptr<IOProcessor> iop;
2715 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2716 if (iop->feeds (other)) {
2717 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does feed %2\n", iop->name(), other->name()));
2723 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tIOP %1 does NOT feed %2\n", iop->name(), other->name()));
2726 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tPROC %1 is not an IOP\n", (*r)->name()));
2731 DEBUG_TRACE (DEBUG::Graph, string_compose ("\tdoes NOT feed %1\n", other->name()));
2735 /** Called from the (non-realtime) butler thread when the transport is stopped */
2737 Route::nonrealtime_handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2739 framepos_t now = _session.transport_frame();
2742 Glib::RWLock::ReaderLock lm (_processor_lock);
2745 automation_snapshot (now, true);
2748 Automatable::transport_stopped (now);
2750 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2752 if (!_have_internal_generator && (Config->get_plugins_stop_with_transport() && can_flush_processors)) {
2756 (*i)->transport_stopped (now);
2760 _roll_delay = _initial_delay;
2763 /** Called with the process lock held if change contains ConfigurationChanged */
2765 Route::input_change_handler (IOChange change, void * /*src*/)
2767 if ((change.type & IOChange::ConfigurationChanged)) {
2768 configure_processors (0);
2769 _phase_invert.resize (_input->n_ports().n_audio ());
2770 io_changed (); /* EMIT SIGNAL */
2775 Route::pans_required () const
2777 if (n_outputs().n_audio() < 2) {
2781 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2785 Route::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
2787 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2792 if (n_outputs().n_total() == 0) {
2796 if (!_active || n_inputs() == ChanCount::ZERO) {
2797 silence_unlocked (nframes);
2800 if (session_state_changing) {
2801 if (_session.transport_speed() != 0.0f) {
2802 /* we're rolling but some state is changing (e.g. our diskstream contents)
2803 so we cannot use them. Be silent till this is over.
2805 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
2807 silence_unlocked (nframes);
2810 /* we're really not rolling, so we're either delivery silence or actually
2811 monitoring, both of which are safe to do while session_state_changing is true.
2815 _amp->apply_gain_automation (false);
2816 passthru (start_frame, end_frame, nframes, 0);
2822 Route::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& /* need_butler */)
2824 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2829 automation_snapshot (_session.transport_frame(), false);
2831 if (n_outputs().n_total() == 0) {
2835 if (!_active || n_inputs().n_total() == 0) {
2836 silence_unlocked (nframes);
2840 framecnt_t unused = 0;
2842 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2848 passthru (start_frame, end_frame, nframes, declick);
2854 Route::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& /* need_butler */)
2861 Route::toggle_monitor_input ()
2863 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2864 i->ensure_monitor_input( ! i->monitoring_input());
2869 Route::has_external_redirects () const
2871 // FIXME: what about sends? - they don't return a signal back to ardour?
2873 boost::shared_ptr<const PortInsert> pi;
2875 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2877 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2879 for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2881 string port_name = port->name();
2882 string client_name = port_name.substr (0, port_name.find(':'));
2884 /* only say "yes" if the redirect is actually in use */
2886 if (client_name != "ardour" && pi->active()) {
2897 Route::flush_processors ()
2899 /* XXX shouldn't really try to take this lock, since
2900 this is called from the RT audio thread.
2903 Glib::RWLock::ReaderLock lm (_processor_lock);
2905 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2911 Route::set_meter_point (MeterPoint p, bool force)
2913 /* CAN BE CALLED FROM PROCESS CONTEXT */
2915 if (_meter_point == p && !force) {
2921 bool meter_was_visible_to_user = _meter->display_to_user ();
2924 Glib::RWLock::WriterLock lm (_processor_lock);
2926 if (_meter_point != MeterCustom) {
2928 _meter->set_display_to_user (false);
2930 setup_invisible_processors ();
2932 ProcessorList::iterator loc = find (_processors.begin(), _processors.end(), _meter);
2936 if (loc == _processors.begin()) {
2937 m_in = _input->n_ports();
2939 ProcessorList::iterator before = loc;
2941 m_in = (*before)->output_streams ();
2944 _meter->reflect_inputs (m_in);
2946 /* we do not need to reconfigure the processors, because the meter
2947 (a) is always ready to handle processor_max_streams
2948 (b) is always an N-in/N-out processor, and thus moving
2949 it doesn't require any changes to the other processors.
2954 // just make it visible and let the user move it
2956 _meter->set_display_to_user (true);
2960 meter_change (); /* EMIT SIGNAL */
2962 bool const meter_visibly_changed = (_meter->display_to_user() != meter_was_visible_to_user);
2964 processors_changed (RouteProcessorChange (RouteProcessorChange::MeterPointChange, meter_visibly_changed)); /* EMIT SIGNAL */
2968 Route::listen_position_changed ()
2971 Glib::RWLock::WriterLock lm (_processor_lock);
2972 ProcessorState pstate (this);
2975 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2977 if (configure_processors_unlocked (0)) {
2979 configure_processors_unlocked (0); // it worked before we tried to add it ...
2985 processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
2986 _session.set_dirty ();
2989 boost::shared_ptr<CapturingProcessor>
2990 Route::add_export_point()
2992 if (!_capturing_processor) {
2994 _capturing_processor.reset (new CapturingProcessor (_session));
2995 _capturing_processor->activate ();
2998 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
2999 configure_processors (0);
3004 return _capturing_processor;
3008 Route::update_signal_latency ()
3010 framecnt_t l = _output->user_latency();
3012 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3013 if ((*i)->active ()) {
3014 l += (*i)->signal_latency ();
3018 DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: internal signal latency = %2\n", _name, l));
3020 if (_signal_latency != l) {
3021 _signal_latency = l;
3022 signal_latency_changed (); /* EMIT SIGNAL */
3025 return _signal_latency;
3029 Route::set_user_latency (framecnt_t nframes)
3031 _output->set_user_latency (nframes);
3032 _session.update_latency_compensation ();
3036 Route::set_latency_compensation (framecnt_t longest_session_latency)
3038 framecnt_t old = _initial_delay;
3040 if (_signal_latency < longest_session_latency) {
3041 _initial_delay = longest_session_latency - _signal_latency;
3046 DEBUG_TRACE (DEBUG::Latency, string_compose (
3047 "%1: compensate for maximum latency of %2,"
3048 "given own latency of %3, using initial delay of %4\n",
3049 name(), longest_session_latency, _signal_latency, _initial_delay));
3051 if (_initial_delay != old) {
3052 initial_delay_changed (); /* EMIT SIGNAL */
3055 if (_session.transport_stopped()) {
3056 _roll_delay = _initial_delay;
3061 Route::automation_snapshot (framepos_t now, bool force)
3064 _pannable->automation_snapshot (now, force);
3067 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3068 (*i)->automation_snapshot (now, force);
3072 Route::SoloControllable::SoloControllable (std::string name, boost::shared_ptr<Route> r)
3073 : AutomationControl (r->session(), Evoral::Parameter (SoloAutomation),
3074 boost::shared_ptr<AutomationList>(), name)
3077 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
3082 Route::SoloControllable::set_value (double val)
3084 bool bval = ((val >= 0.5f) ? true: false);
3086 boost::shared_ptr<RouteList> rl (new RouteList);
3088 boost::shared_ptr<Route> r = _route.lock ();
3095 if (Config->get_solo_control_is_listen_control()) {
3096 _session.set_listen (rl, bval);
3098 _session.set_solo (rl, bval);
3103 Route::SoloControllable::get_value () const
3105 boost::shared_ptr<Route> r = _route.lock ();
3110 if (Config->get_solo_control_is_listen_control()) {
3111 return r->listening_via_monitor() ? 1.0f : 0.0f;
3113 return r->self_soloed() ? 1.0f : 0.0f;
3117 Route::MuteControllable::MuteControllable (std::string name, boost::shared_ptr<Route> r)
3118 : AutomationControl (r->session(), Evoral::Parameter (MuteAutomation),
3119 boost::shared_ptr<AutomationList>(), name)
3122 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(MuteAutomation)));
3127 Route::MuteControllable::set_value (double val)
3129 bool bval = ((val >= 0.5f) ? true: false);
3131 boost::shared_ptr<RouteList> rl (new RouteList);
3133 boost::shared_ptr<Route> r = _route.lock ();
3139 _session.set_mute (rl, bval);
3143 Route::MuteControllable::get_value () const
3145 boost::shared_ptr<Route> r = _route.lock ();
3150 return r->muted() ? 1.0f : 0.0f;
3154 Route::set_block_size (pframes_t nframes)
3156 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3157 (*i)->set_block_size (nframes);
3160 _session.ensure_buffers (n_process_buffers ());
3164 Route::protect_automation ()
3166 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
3167 (*i)->protect_automation();
3171 Route::set_pending_declick (int declick)
3174 /* this call is not allowed to turn off a pending declick unless "force" is true */
3176 _pending_declick = declick;
3178 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
3180 _pending_declick = 0;
3185 /** Shift automation forwards from a particular place, thereby inserting time.
3186 * Adds undo commands for any shifts that are performed.
3188 * @param pos Position to start shifting from.
3189 * @param frames Amount to shift forwards by.
3193 Route::shift (framepos_t pos, framecnt_t frames)
3195 /* gain automation */
3197 boost::shared_ptr<AutomationControl> gc = _amp->gain_control();
3199 XMLNode &before = gc->alist()->get_state ();
3200 gc->alist()->shift (pos, frames);
3201 XMLNode &after = gc->alist()->get_state ();
3202 _session.add_command (new MementoCommand<AutomationList> (*gc->alist().get(), &before, &after));
3205 /* pan automation */
3207 ControlSet::Controls& c (_pannable->controls());
3209 for (ControlSet::Controls::const_iterator ci = c.begin(); ci != c.end(); ++ci) {
3210 boost::shared_ptr<AutomationControl> pc = boost::dynamic_pointer_cast<AutomationControl> (ci->second);
3212 boost::shared_ptr<AutomationList> al = pc->alist();
3213 XMLNode& before = al->get_state ();
3214 al->shift (pos, frames);
3215 XMLNode& after = al->get_state ();
3216 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3221 /* redirect automation */
3223 Glib::RWLock::ReaderLock lm (_processor_lock);
3224 for (ProcessorList::iterator i = _processors.begin (); i != _processors.end (); ++i) {
3226 set<Evoral::Parameter> parameters = (*i)->what_can_be_automated();
3228 for (set<Evoral::Parameter>::const_iterator p = parameters.begin (); p != parameters.end (); ++p) {
3229 boost::shared_ptr<AutomationControl> ac = (*i)->automation_control (*p);
3231 boost::shared_ptr<AutomationList> al = ac->alist();
3232 XMLNode &before = al->get_state ();
3233 al->shift (pos, frames);
3234 XMLNode &after = al->get_state ();
3235 _session.add_command (new MementoCommand<AutomationList> (*al.get(), &before, &after));
3244 Route::save_as_template (const string& path, const string& name)
3246 XMLNode& node (state (false));
3249 IO::set_name_in_state (*node.children().front(), name);
3251 tree.set_root (&node);
3252 return tree.write (path.c_str());
3257 Route::set_name (const string& str)
3263 name = Route::ensure_track_or_route_name (str, _session);
3264 SessionObject::set_name (name);
3266 ret = (_input->set_name(name) && _output->set_name(name));
3269 /* rename the main outs. Leave other IO processors
3270 * with whatever name they already have, because its
3271 * just fine as it is (it will not contain the route
3272 * name if its a port insert, port send or port return).
3276 if (_main_outs->set_name (name)) {
3277 /* XXX returning false here is stupid because
3278 we already changed the route name.
3288 boost::shared_ptr<Send>
3289 Route::internal_send_for (boost::shared_ptr<const Route> target) const
3291 Glib::RWLock::ReaderLock lm (_processor_lock);
3293 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3294 boost::shared_ptr<InternalSend> send;
3296 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
3297 if (send->target_route() == target) {
3303 return boost::shared_ptr<Send>();
3306 /** @param c Audio channel index.
3307 * @param yn true to invert phase, otherwise false.
3310 Route::set_phase_invert (uint32_t c, bool yn)
3312 if (_phase_invert[c] != yn) {
3313 _phase_invert[c] = yn;
3314 phase_invert_changed (); /* EMIT SIGNAL */
3315 _session.set_dirty ();
3320 Route::set_phase_invert (boost::dynamic_bitset<> p)
3322 if (_phase_invert != p) {
3324 phase_invert_changed (); /* EMIT SIGNAL */
3325 _session.set_dirty ();
3330 Route::phase_invert (uint32_t c) const
3332 return _phase_invert[c];
3335 boost::dynamic_bitset<>
3336 Route::phase_invert () const
3338 return _phase_invert;
3342 Route::set_denormal_protection (bool yn)
3344 if (_denormal_protection != yn) {
3345 _denormal_protection = yn;
3346 denormal_protection_changed (); /* EMIT SIGNAL */
3351 Route::denormal_protection () const
3353 return _denormal_protection;
3357 Route::set_active (bool yn, void* src)
3359 if (_route_group && src != _route_group && _route_group->is_active() && _route_group->is_route_active()) {
3360 _route_group->foreach_route (boost::bind (&Route::set_active, _1, yn, _route_group));
3364 if (_active != yn) {
3366 _input->set_active (yn);
3367 _output->set_active (yn);
3368 active_changed (); // EMIT SIGNAL
3375 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3381 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3383 boost::shared_ptr<Send> s;
3384 boost::shared_ptr<Return> r;
3386 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
3387 s->meter()->meter();
3388 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
3389 r->meter()->meter ();
3394 boost::shared_ptr<Pannable>
3395 Route::pannable() const
3400 boost::shared_ptr<Panner>
3401 Route::panner() const
3404 return _main_outs->panner_shell()->panner();
3407 boost::shared_ptr<PannerShell>
3408 Route::panner_shell() const
3410 return _main_outs->panner_shell();
3413 boost::shared_ptr<AutomationControl>
3414 Route::gain_control() const
3416 return _amp->gain_control();
3419 boost::shared_ptr<AutomationControl>
3420 Route::get_control (const Evoral::Parameter& param)
3422 /* either we own the control or .... */
3424 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(control (param));
3428 /* maybe one of our processors does or ... */
3430 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
3431 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3432 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->control (param))) != 0) {
3440 /* nobody does so we'll make a new one */
3442 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));
3449 boost::shared_ptr<Processor>
3450 Route::nth_plugin (uint32_t n)
3452 Glib::RWLock::ReaderLock lm (_processor_lock);
3453 ProcessorList::iterator i;
3455 for (i = _processors.begin(); i != _processors.end(); ++i) {
3456 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
3463 return boost::shared_ptr<Processor> ();
3466 boost::shared_ptr<Processor>
3467 Route::nth_send (uint32_t n)
3469 Glib::RWLock::ReaderLock lm (_processor_lock);
3470 ProcessorList::iterator i;
3472 for (i = _processors.begin(); i != _processors.end(); ++i) {
3473 if (boost::dynamic_pointer_cast<Send> (*i)) {
3480 return boost::shared_ptr<Processor> ();
3484 Route::has_io_processor_named (const string& name)
3486 Glib::RWLock::ReaderLock lm (_processor_lock);
3487 ProcessorList::iterator i;
3489 for (i = _processors.begin(); i != _processors.end(); ++i) {
3490 if (boost::dynamic_pointer_cast<Send> (*i) ||
3491 boost::dynamic_pointer_cast<PortInsert> (*i)) {
3492 if ((*i)->name() == name) {
3501 MuteMaster::MutePoint
3502 Route::mute_points () const
3504 return _mute_master->mute_points ();
3508 Route::set_processor_positions ()
3510 Glib::RWLock::ReaderLock lm (_processor_lock);
3512 bool had_amp = false;
3513 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3514 (*i)->set_pre_fader (!had_amp);
3515 if (boost::dynamic_pointer_cast<Amp> (*i)) {
3521 /** Called when there is a proposed change to the input port count */
3523 Route::input_port_count_changing (ChanCount to)
3525 list<pair<ChanCount, ChanCount> > c = try_configure_processors (to, 0);
3527 /* The processors cannot be configured with the new input arrangement, so
3533 /* The change is ok */
3538 Route::unknown_processors () const
3542 Glib::RWLock::ReaderLock lm (_processor_lock);
3543 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3544 if (boost::dynamic_pointer_cast<UnknownProcessor const> (*i)) {
3545 p.push_back ((*i)->name ());
3554 Route::update_port_latencies (PortSet& from, PortSet& to, bool playback, framecnt_t our_latency) const
3556 /* we assume that all our input ports feed all our output ports. its not
3557 universally true, but the alternative is way too corner-case to worry about.
3560 jack_latency_range_t all_connections;
3563 all_connections.min = 0;
3564 all_connections.max = 0;
3566 all_connections.min = ~((jack_nframes_t) 0);
3567 all_connections.max = 0;
3569 /* iterate over all "from" ports and determine the latency range for all of their
3570 connections to the "outside" (outside of this Route).
3573 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3575 jack_latency_range_t range;
3577 p->get_connected_latency_range (range, playback);
3579 all_connections.min = min (all_connections.min, range.min);
3580 all_connections.max = max (all_connections.max, range.max);
3584 /* set the "from" port latencies to the max/min range of all their connections */
3586 for (PortSet::iterator p = from.begin(); p != from.end(); ++p) {
3587 p->set_private_latency_range (all_connections, playback);
3590 /* set the ports "in the direction of the flow" to the same value as above plus our own signal latency */
3592 all_connections.min += our_latency;
3593 all_connections.max += our_latency;
3595 for (PortSet::iterator p = to.begin(); p != to.end(); ++p) {
3596 p->set_private_latency_range (all_connections, playback);
3599 return all_connections.max;
3603 Route::set_private_port_latencies (bool playback) const
3605 framecnt_t own_latency = 0;
3607 /* Processor list not protected by lock: MUST BE CALLED FROM PROCESS THREAD
3608 OR LATENCY CALLBACK.
3610 This is called (early) from the latency callback. It computes the REAL
3611 latency associated with each port and stores the result as the "private"
3612 latency of the port. A later call to Route::set_public_port_latencies()
3613 sets all ports to the same value to reflect the fact that we do latency
3614 compensation and so all signals are delayed by the same amount as they
3615 flow through ardour.
3618 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
3619 if ((*i)->active ()) {
3620 own_latency += (*i)->signal_latency ();
3625 /* playback: propagate latency from "outside the route" to outputs to inputs */
3626 return update_port_latencies (_output->ports (), _input->ports (), true, own_latency);
3628 /* capture: propagate latency from "outside the route" to inputs to outputs */
3629 return update_port_latencies (_input->ports (), _output->ports (), false, own_latency);
3634 Route::set_public_port_latencies (framecnt_t value, bool playback) const
3636 /* this is called to set the JACK-visible port latencies, which take
3637 latency compensation into account.
3640 jack_latency_range_t range;
3646 const PortSet& ports (_input->ports());
3647 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3648 p->set_public_latency_range (range, playback);
3653 const PortSet& ports (_output->ports());
3654 for (PortSet::const_iterator p = ports.begin(); p != ports.end(); ++p) {
3655 p->set_public_latency_range (range, playback);
3660 /** Put the invisible processors in the right place in _processors.
3661 * Must be called with a writer lock on _processor_lock held.
3664 Route::setup_invisible_processors ()
3667 Glib::RWLock::WriterLock lm (_processor_lock, Glib::TRY_LOCK);
3668 assert (!lm.locked ());
3672 /* too early to be doing this stuff */
3676 /* we'll build this new list here and then use it */
3678 ProcessorList new_processors;
3680 /* find visible processors */
3682 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3683 if ((*i)->display_to_user ()) {
3684 new_processors.push_back (*i);
3690 ProcessorList::iterator amp = new_processors.begin ();
3691 while (amp != new_processors.end() && boost::dynamic_pointer_cast<Amp> (*amp) == 0) {
3695 assert (amp != _processors.end ());
3697 /* and the processor after the amp */
3699 ProcessorList::iterator after_amp = amp;
3705 switch (_meter_point) {
3707 assert (!_meter->display_to_user ());
3708 new_processors.push_front (_meter);
3711 assert (!_meter->display_to_user ());
3712 new_processors.insert (amp, _meter);
3714 case MeterPostFader:
3715 /* do nothing here */
3718 /* do nothing here */
3721 /* the meter is visible, so we don't touch it here */
3728 assert (_main_outs);
3729 assert (!_main_outs->display_to_user ());
3730 new_processors.push_back (_main_outs);
3732 /* iterator for the main outs */
3734 ProcessorList::iterator main = new_processors.end();
3737 /* OUTPUT METERING */
3739 if (_meter && (_meter_point == MeterOutput || _meter_point == MeterPostFader)) {
3740 assert (!_meter->display_to_user ());
3742 /* add the processor just before or just after the main outs */
3744 ProcessorList::iterator meter_point = main;
3746 if (_meter_point == MeterOutput) {
3749 new_processors.insert (meter_point, _meter);
3754 if (_monitor_send && !is_monitor ()) {
3755 assert (!_monitor_send->display_to_user ());
3756 if (Config->get_solo_control_is_listen_control()) {
3757 switch (Config->get_listen_position ()) {
3758 case PreFaderListen:
3759 switch (Config->get_pfl_position ()) {
3760 case PFLFromBeforeProcessors:
3761 new_processors.push_front (_monitor_send);
3763 case PFLFromAfterProcessors:
3764 new_processors.insert (amp, _monitor_send);
3767 _monitor_send->set_can_pan (false);
3769 case AfterFaderListen:
3770 switch (Config->get_afl_position ()) {
3771 case AFLFromBeforeProcessors:
3772 new_processors.insert (after_amp, _monitor_send);
3774 case AFLFromAfterProcessors:
3775 new_processors.insert (new_processors.end(), _monitor_send);
3778 _monitor_send->set_can_pan (true);
3782 new_processors.insert (new_processors.end(), _monitor_send);
3783 _monitor_send->set_can_pan (false);
3787 /* MONITOR CONTROL */
3789 if (_monitor_control && is_monitor ()) {
3790 assert (!_monitor_control->display_to_user ());
3791 new_processors.push_front (_monitor_control);
3794 /* INTERNAL RETURN */
3796 /* doing this here means that any monitor control will come just after
3801 assert (!_intreturn->display_to_user ());
3802 new_processors.push_front (_intreturn);
3805 /* EXPORT PROCESSOR */
3807 if (_capturing_processor) {
3808 assert (!_capturing_processor->display_to_user ());
3809 new_processors.push_front (_capturing_processor);
3812 _processors = new_processors;
3814 DEBUG_TRACE (DEBUG::Processors, string_compose ("%1: setup_invisible_processors\n", _name));
3815 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3816 DEBUG_TRACE (DEBUG::Processors, string_compose ("\t%1\n", (*i)->name ()));
3821 Route::should_monitor () const
3823 switch (Config->get_monitoring_model()) {
3824 case HardwareMonitoring:
3825 case ExternalMonitoring:
3826 return !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
3838 Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
3839 Glib::RWLock::ReaderLock lp (_processor_lock);
3843 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
3844 boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery>(*i);