2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <sigc++/bind.h>
26 #include "pbd/xml++.h"
27 #include "pbd/enumwriter.h"
28 #include "pbd/stacktrace.h"
29 #include "pbd/memento_command.h"
31 #include "evoral/Curve.hpp"
33 #include "ardour/amp.h"
34 #include "ardour/audio_port.h"
35 #include "ardour/audioengine.h"
36 #include "ardour/buffer.h"
37 #include "ardour/buffer_set.h"
38 #include "ardour/configuration.h"
39 #include "ardour/cycle_timer.h"
40 #include "ardour/delivery.h"
41 #include "ardour/dB.h"
42 #include "ardour/internal_send.h"
43 #include "ardour/internal_return.h"
44 #include "ardour/ladspa_plugin.h"
45 #include "ardour/meter.h"
46 #include "ardour/mix.h"
47 #include "ardour/panner.h"
48 #include "ardour/plugin_insert.h"
49 #include "ardour/port.h"
50 #include "ardour/port_insert.h"
51 #include "ardour/processor.h"
52 #include "ardour/profile.h"
53 #include "ardour/route.h"
54 #include "ardour/route_group.h"
55 #include "ardour/send.h"
56 #include "ardour/session.h"
57 #include "ardour/timestamps.h"
58 #include "ardour/utils.h"
63 using namespace ARDOUR;
66 uint32_t Route::order_key_cnt = 0;
67 sigc::signal<void, string const &> Route::SyncOrderKeys;
69 Route::Route (Session& sess, string name, Flag flg, DataType default_type)
70 : SessionObject (sess, name)
71 , AutomatableControls (sess)
73 , _solo_control (new SoloControllable (X_("solo"), *this))
74 , _mute_master (new MuteMaster (sess, name))
75 , _default_type (default_type)
80 /* add standard processors other than amp (added by ::init()) */
82 _meter.reset (new PeakMeter (_session));
83 add_processor (_meter, PreFader);
85 if (_flags & ControlOut) {
86 /* where we listen to tracks */
87 _intreturn.reset (new InternalReturn (_session));
88 add_processor (_intreturn, PreFader);
91 _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
92 add_processor (_main_outs, PostFader);
94 /* now that we have _meter, its safe to connect to this */
96 _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
99 Route::Route (Session& sess, const XMLNode& node, DataType default_type)
100 : SessionObject (sess, "toBeReset")
101 , AutomatableControls (sess)
102 , _solo_control (new SoloControllable (X_("solo"), *this))
103 , _mute_master (new MuteMaster (sess, "toBeReset"))
104 , _default_type (default_type)
108 _set_state (node, Stateful::loading_state_version, false);
110 /* now that we have _meter, its safe to connect to this */
112 _meter_connection = Metering::connect (mem_fun (*this, &Route::meter));
119 _solo_isolated = false;
121 processor_max_streams.reset();
124 order_keys[N_("signal")] = order_key_cnt++;
126 _meter_point = MeterPostFader;
129 _have_internal_generator = false;
130 _declickable = false;
131 _pending_declick = true;
132 _remote_control_id = 0;
133 _in_configure_processors = false;
138 _denormal_protection = false;
140 /* add standard controls */
142 add_control (_solo_control);
143 add_control (_mute_master);
145 /* input and output objects */
147 _input.reset (new IO (_session, _name, IO::Input, _default_type));
148 _output.reset (new IO (_session, _name, IO::Output, _default_type));
150 _input->changed.connect (mem_fun (this, &Route::input_change_handler));
151 _output->changed.connect (mem_fun (this, &Route::output_change_handler));
153 /* add amp processor */
155 _amp.reset (new Amp (_session, _mute_master));
156 add_processor (_amp, PostFader);
161 Metering::disconnect (_meter_connection);
163 clear_processors (PreFader);
164 clear_processors (PostFader);
168 Route::set_remote_control_id (uint32_t id)
170 if (id != _remote_control_id) {
171 _remote_control_id = id;
172 RemoteControlIDChanged ();
177 Route::remote_control_id() const
179 return _remote_control_id;
183 Route::order_key (std::string const & name) const
185 OrderKeys::const_iterator i = order_keys.find (name);
186 if (i == order_keys.end()) {
194 Route::set_order_key (std::string const & name, long n)
196 order_keys[name] = n;
198 if (Config->get_sync_all_route_ordering()) {
199 for (OrderKeys::iterator x = order_keys.begin(); x != order_keys.end(); ++x) {
204 _session.set_dirty ();
207 /** Set all order keys to be the same as that for `base', if such a key
208 * exists in this route.
209 * @param base Base key.
212 Route::sync_order_keys (std::string const & base)
214 if (order_keys.empty()) {
218 OrderKeys::iterator i;
221 if ((i = order_keys.find (base)) == order_keys.end()) {
222 /* key doesn't exist, use the first existing key (during session initialization) */
223 i = order_keys.begin();
227 /* key exists - use it and reset all others (actually, itself included) */
229 i = order_keys.begin();
232 for (; i != order_keys.end(); ++i) {
238 Route::ensure_track_or_route_name(string name, Session &session)
240 string newname = name;
242 while (session.route_by_name (newname) != NULL) {
243 newname = bump_name_once (newname);
251 Route::inc_gain (gain_t fraction, void *src)
253 _amp->inc_gain (fraction, src);
257 Route::set_gain (gain_t val, void *src)
259 if (src != 0 && _route_group && src != _route_group && _route_group->active_property (RouteGroup::Gain)) {
261 if (_route_group->is_relative()) {
263 gain_t usable_gain = _amp->gain();
264 if (usable_gain < 0.000001f) {
265 usable_gain = 0.000001f;
269 if (delta < 0.000001f) {
273 delta -= usable_gain;
278 gain_t factor = delta / usable_gain;
281 factor = _route_group->get_max_factor(factor);
282 if (factor == 0.0f) {
283 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
287 factor = _route_group->get_min_factor(factor);
288 if (factor == 0.0f) {
289 _amp->gain_control()->Changed(); /* EMIT SIGNAL */
294 _route_group->apply (&Route::inc_gain, factor, _route_group);
298 _route_group->apply (&Route::set_gain, val, _route_group);
304 if (val == _amp->gain()) {
308 _amp->set_gain (val, src);
311 /** Process this route for one (sub) cycle (process thread)
313 * @param bufs Scratch buffers to use for the signal path
314 * @param start_frame Initial transport frame
315 * @param end_frame Final transport frame
316 * @param nframes Number of frames to output (to ports)
318 * Note that (end_frame - start_frame) may not be equal to nframes when the
319 * transport speed isn't 1.0 (eg varispeed).
322 Route::process_output_buffers (BufferSet& bufs,
323 sframes_t start_frame, sframes_t end_frame, nframes_t nframes,
324 bool /*with_processors*/, int declick)
328 bufs.is_silent (false);
330 switch (Config->get_monitoring_model()) {
331 case HardwareMonitoring:
332 case ExternalMonitoring:
333 monitor = !record_enabled() || (_session.config.get_auto_input() && !_session.actively_recording());
340 declick = _pending_declick;
343 /* figure out if we're going to use gain automation */
344 _amp->setup_gain_automation (start_frame, end_frame, nframes);
347 /* tell main outs what to do about monitoring */
348 _main_outs->no_outs_cuz_we_no_monitor (!monitor);
351 /* -------------------------------------------------------------------------------------------
352 GLOBAL DECLICK (for transport changes etc.)
353 ----------------------------------------------------------------------------------------- */
356 Amp::apply_gain (bufs, nframes, 0.0, 1.0);
357 } else if (declick < 0) {
358 Amp::apply_gain (bufs, nframes, 1.0, 0.0);
361 _pending_declick = 0;
363 /* -------------------------------------------------------------------------------------------
364 DENORMAL CONTROL/PHASE INVERT
365 ----------------------------------------------------------------------------------------- */
371 if (_denormal_protection || Config->get_denormal_protection()) {
373 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
374 Sample* const sp = i->data();
376 if (_phase_invert & chn) {
377 for (nframes_t nx = 0; nx < nframes; ++nx) {
382 for (nframes_t nx = 0; nx < nframes; ++nx) {
390 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i, ++chn) {
391 Sample* const sp = i->data();
393 if (_phase_invert & chn) {
394 for (nframes_t nx = 0; nx < nframes; ++nx) {
403 if (_denormal_protection || Config->get_denormal_protection()) {
405 for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
406 Sample* const sp = i->data();
407 for (nframes_t nx = 0; nx < nframes; ++nx) {
415 /* -------------------------------------------------------------------------------------------
417 ----------------------------------------------------------------------------------------- */
419 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
422 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
423 if (bufs.count() != (*i)->input_streams()) {
424 cerr << _name << " bufs = " << bufs.count()
425 << " input for " << (*i)->name() << " = " << (*i)->input_streams()
428 assert (bufs.count() == (*i)->input_streams());
429 (*i)->run (bufs, start_frame, end_frame, nframes);
430 bufs.set_count (ChanCount::max(bufs.count(), (*i)->output_streams()));
433 if (!_processors.empty()) {
434 bufs.set_count (ChanCount::max (bufs.count(), _processors.back()->output_streams()));
440 Route::n_process_buffers ()
442 return max (_input->n_ports(), processor_max_streams);
446 Route::passthru (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
448 BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
452 assert (bufs.available() >= _input->n_ports());
454 if (_input->n_ports() == ChanCount::ZERO) {
458 bufs.set_count (_input->n_ports());
460 if (is_control() && _session.listening()) {
462 /* control/monitor bus ignores input ports when something is
463 feeding the listen "stream". data will "arrive" into the
464 route from the intreturn processor element.
467 bufs.silence (nframes, 0);
471 for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
473 BufferSet::iterator o = bufs.begin(*t);
474 PortSet& ports (_input->ports());
476 for (PortSet::iterator i = ports.begin(*t); i != ports.end(*t); ++i, ++o) {
477 o->read_from (i->get_buffer(nframes), nframes);
482 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
483 process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
487 Route::passthru_silence (sframes_t start_frame, sframes_t end_frame, nframes_t nframes, int declick)
489 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
490 bufs.set_count (_input->n_ports());
491 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
492 process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
496 Route::set_listen (bool yn, void* src)
499 if (yn != _control_outs->active()) {
501 _control_outs->activate ();
503 _control_outs->deactivate ();
506 listen_changed (src); /* EMIT SIGNAL */
512 Route::listening () const
515 return _control_outs->active ();
522 Route::set_solo (bool yn, void *src)
524 if (_solo_safe || _solo_isolated) {
528 if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
529 _route_group->apply (&Route::set_solo, yn, _route_group);
533 if (soloed() != yn) {
534 mod_solo_level (yn ? 1 : -1);
535 solo_changed (src); /* EMIT SIGNAL */
536 _solo_control->Changed (); /* EMIT SIGNAL */
541 Route::mod_solo_level (int32_t delta)
544 if (_solo_level >= (uint32_t) delta) {
545 _solo_level += delta;
550 _solo_level += delta;
553 /* tell main outs what the solo situation is
556 _main_outs->set_solo_level (_solo_level);
557 _main_outs->set_solo_isolated (_solo_isolated);
561 Route::set_solo_isolated (bool yn, void *src)
563 if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
564 _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
568 if (yn != _solo_isolated) {
571 /* tell main outs what the solo situation is
574 _main_outs->set_solo_level (_solo_level);
575 _main_outs->set_solo_isolated (_solo_isolated);
577 solo_isolated_changed (src);
582 Route::solo_isolated () const
584 return _solo_isolated;
588 Route::set_mute (bool yn, void *src)
590 if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
591 _route_group->apply (&Route::set_mute, yn, _route_group);
596 _mute_master->mute (yn);
604 return _mute_master->muted ();
609 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
611 cerr << name << " {" << endl;
612 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
613 p != procs.end(); ++p) {
614 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
621 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
623 ProcessorList::iterator loc;
625 /* XXX this is not thread safe - we don't hold the lock across determining the iter
626 to add before and actually doing the insertion. dammit.
629 if (placement == PreFader) {
630 /* generic pre-fader: insert immediately before the amp */
631 loc = find (_processors.begin(), _processors.end(), _amp);
633 /* generic post-fader: insert right before the main outs */
634 loc = find (_processors.begin(), _processors.end(), _main_outs);
637 return add_processor (processor, loc, err);
641 /** Add a processor to the route.
642 * If @a iter is not NULL, it must point to an iterator in _processors and the new
643 * processor will be inserted immediately before this location. Otherwise,
644 * @a position is used.
647 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err)
649 ChanCount old_pms = processor_max_streams;
651 if (!_session.engine().connected() || !processor) {
656 Glib::RWLock::WriterLock lm (_processor_lock);
658 boost::shared_ptr<PluginInsert> pi;
659 boost::shared_ptr<PortInsert> porti;
661 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
663 if (processor == _amp || processor == _meter || processor == _main_outs) {
664 // Ensure only one of these are in the list at any time
665 if (loc != _processors.end()) {
666 if (iter == loc) { // Already in place, do nothing
668 } else { // New position given, relocate
669 _processors.erase (loc);
674 if (loc != _processors.end()) {
675 cerr << "ERROR: Processor added to route twice!" << endl;
682 _processors.insert (loc, processor);
684 // Set up processor list channels. This will set processor->[input|output]_streams(),
685 // configure redirect ports properly, etc.
687 if (configure_processors_unlocked (err)) {
688 ProcessorList::iterator ploc = loc;
690 _processors.erase(ploc);
691 configure_processors_unlocked (0); // it worked before we tried to add it ...
692 cerr << "configure failed\n";
696 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(processor)) != 0) {
698 if (pi->natural_input_streams() == ChanCount::ZERO) {
699 /* generator plugin */
700 _have_internal_generator = true;
705 if (_control_outs != processor) {
706 // XXX: do we want to emit the signal here ? change call order.
707 processor->activate ();
709 processor->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
711 _output->set_user_latency (0);
714 processors_changed (); /* EMIT SIGNAL */
720 Route::add_processor_from_xml (const XMLNode& node, ProcessorList::iterator iter)
722 const XMLProperty *prop;
724 if (node.name() != "Processor") {
729 if ((prop = node.property ("type")) != 0) {
731 boost::shared_ptr<Processor> processor;
733 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
734 prop->value() == "lv2" ||
735 prop->value() == "vst" ||
736 prop->value() == "audiounit") {
738 processor.reset (new PluginInsert(_session, node));
740 } else if (prop->value() == "port") {
742 processor.reset (new PortInsert (_session, _mute_master, node));
744 } else if (prop->value() == "send") {
746 processor.reset (new Send (_session, _mute_master, node));
748 } else if (prop->value() == "meter") {
751 if (_meter->set_state (node, Stateful::loading_state_version)) {
758 _meter.reset (new PeakMeter (_session, node));
761 } else if (prop->value() == "amp") {
763 /* amp always exists */
766 if (processor->set_state (node, Stateful::loading_state_version)) {
769 /* never any reason to add it */
773 } else if (prop->value() == "intsend") {
775 processor.reset (new InternalSend (_session, _mute_master, node));
777 } else if (prop->value() == "intreturn") {
780 if (_intreturn->set_state (node, Stateful::loading_state_version)) {
786 _intreturn.reset (new InternalReturn (_session, node));
787 processor = _intreturn;
789 } else if (prop->value() == "main-outs") {
792 if (_main_outs->set_state (node, Stateful::loading_state_version)) {
799 _main_outs.reset (new Delivery (_session, _output, _mute_master, node));
800 processor = _main_outs;
803 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
807 if (iter == _processors.end() && processor->visible() && !_processors.empty()) {
808 /* check for invisible processors stacked at the end and leave them there */
809 ProcessorList::iterator p;
810 p = _processors.end();
812 while (!(*p)->visible() && p != _processors.begin()) {
819 return (add_processor (processor, iter) == 0);
822 error << _("Processor XML node has no type property") << endmsg;
827 catch (failed_constructor &err) {
828 warning << _("processor could not be created. Ignored.") << endmsg;
835 Route::add_processor_from_xml_2X (const XMLNode& node, int version, ProcessorList::iterator iter)
837 const XMLProperty *prop;
840 boost::shared_ptr<Processor> processor;
842 if (node.name() == "Insert") {
844 if ((prop = node.property ("type")) != 0) {
846 if (prop->value() == "ladspa" || prop->value() == "Ladspa" ||
847 prop->value() == "lv2" ||
848 prop->value() == "vst" ||
849 prop->value() == "audiounit") {
851 processor.reset (new PluginInsert (_session, node));
855 processor.reset (new PortInsert (_session, _mute_master, node));
860 } else if (node.name() == "Send") {
862 processor.reset (new Send (_session, _mute_master, node, version));
866 error << string_compose(_("unknown Processor type \"%1\"; ignored"), node.name()) << endmsg;
870 if (iter == _processors.end() && processor->visible() && !_processors.empty()) {
871 /* check for invisible processors stacked at the end and leave them there */
872 ProcessorList::iterator p;
873 p = _processors.end();
875 while (!(*p)->visible() && p != _processors.begin()) {
882 return (add_processor (processor, iter) == 0);
885 catch (failed_constructor &err) {
886 warning << _("processor could not be created. Ignored.") << endmsg;
892 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
894 ProcessorList::iterator loc;
897 loc = find(_processors.begin(), _processors.end(), before);
899 /* nothing specified - at end but before main outs */
900 loc = find (_processors.begin(), _processors.end(), _main_outs);
903 return add_processors (others, loc, err);
907 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
909 /* NOTE: this is intended to be used ONLY when copying
910 processors from another Route. Hence the subtle
911 differences between this and ::add_processor()
914 ChanCount old_pms = processor_max_streams;
916 if (!_session.engine().connected()) {
920 if (others.empty()) {
925 Glib::RWLock::WriterLock lm (_processor_lock);
926 ProcessorList::iterator existing_end = _processors.end();
929 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
931 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
933 // Ensure meter only appears in the list once
935 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
936 if (m != _processors.end()) {
937 _processors.erase(m);
941 boost::shared_ptr<PluginInsert> pi;
943 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
946 ChanCount m = max (pi->input_streams(), pi->output_streams());
948 if (m > potential_max_streams) {
949 potential_max_streams = m;
953 _processors.insert (iter, *i);
955 if (configure_processors_unlocked (err)) {
957 _processors.erase (existing_end, _processors.end());
958 configure_processors_unlocked (0); // it worked before we tried to add it ...
962 (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
965 _output->set_user_latency (0);
968 processors_changed (); /* EMIT SIGNAL */
974 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
977 start = _processors.begin();
978 end = find(_processors.begin(), _processors.end(), _amp);
980 start = find(_processors.begin(), _processors.end(), _amp);
982 end = _processors.end();
986 /** Turn off all processors with a given placement
987 * @param p Placement of processors to disable
990 Route::disable_processors (Placement p)
992 Glib::RWLock::ReaderLock lm (_processor_lock);
994 ProcessorList::iterator start, end;
995 placement_range(p, start, end);
997 for (ProcessorList::iterator i = start; i != end; ++i) {
1001 _session.set_dirty ();
1004 /** Turn off all redirects
1007 Route::disable_processors ()
1009 Glib::RWLock::ReaderLock lm (_processor_lock);
1011 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1012 (*i)->deactivate ();
1015 _session.set_dirty ();
1018 /** Turn off all redirects with a given placement
1019 * @param p Placement of redirects to disable
1022 Route::disable_plugins (Placement p)
1024 Glib::RWLock::ReaderLock lm (_processor_lock);
1026 ProcessorList::iterator start, end;
1027 placement_range(p, start, end);
1029 for (ProcessorList::iterator i = start; i != end; ++i) {
1030 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1031 (*i)->deactivate ();
1035 _session.set_dirty ();
1038 /** Turn off all plugins
1041 Route::disable_plugins ()
1043 Glib::RWLock::ReaderLock lm (_processor_lock);
1045 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1046 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1047 (*i)->deactivate ();
1051 _session.set_dirty ();
1056 Route::ab_plugins (bool forward)
1058 Glib::RWLock::ReaderLock lm (_processor_lock);
1062 /* forward = turn off all active redirects, and mark them so that the next time
1063 we go the other way, we will revert them
1066 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1067 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1071 if ((*i)->active()) {
1072 (*i)->deactivate ();
1073 (*i)->set_next_ab_is_active (true);
1075 (*i)->set_next_ab_is_active (false);
1081 /* backward = if the redirect was marked to go active on the next ab, do so */
1083 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1085 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1089 if ((*i)->get_next_ab_is_active()) {
1092 (*i)->deactivate ();
1097 _session.set_dirty ();
1101 /** Remove processors with a given placement.
1102 * @param p Placement of processors to remove.
1105 Route::clear_processors (Placement p)
1107 const ChanCount old_pms = processor_max_streams;
1109 if (!_session.engine().connected()) {
1113 bool already_deleting = _session.deletion_in_progress();
1114 if (!already_deleting) {
1115 _session.set_deletion_in_progress();
1119 Glib::RWLock::WriterLock lm (_processor_lock);
1120 ProcessorList new_list;
1121 ProcessorStreams err;
1122 bool seen_amp = false;
1124 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1130 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1132 /* you can't remove these */
1134 new_list.push_back (*i);
1141 new_list.push_back (*i);
1144 (*i)->drop_references ();
1152 (*i)->drop_references ();
1155 new_list.push_back (*i);
1162 _processors = new_list;
1163 configure_processors_unlocked (&err); // this can't fail
1166 processor_max_streams.reset();
1167 _have_internal_generator = false;
1168 processors_changed (); /* EMIT SIGNAL */
1170 if (!already_deleting) {
1171 _session.clear_deletion_in_progress();
1176 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1178 /* these can never be removed */
1180 if (processor == _amp || processor == _meter || processor == _main_outs) {
1184 ChanCount old_pms = processor_max_streams;
1186 if (!_session.engine().connected()) {
1190 processor_max_streams.reset();
1193 Glib::RWLock::WriterLock lm (_processor_lock);
1194 ProcessorList::iterator i;
1195 bool removed = false;
1197 for (i = _processors.begin(); i != _processors.end(); ) {
1198 if (*i == processor) {
1200 /* move along, see failure case for configure_processors()
1201 where we may need to reconfigure the processor.
1204 /* stop redirects that send signals to JACK ports
1205 from causing noise as a result of no longer being
1209 boost::shared_ptr<IOProcessor> iop;
1211 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1213 iop->input()->disconnect (this);
1215 if (iop->output()) {
1216 iop->output()->disconnect (this);
1220 i = _processors.erase (i);
1228 _output->set_user_latency (0);
1236 if (configure_processors_unlocked (err)) {
1237 /* get back to where we where */
1238 _processors.insert (i, processor);
1239 /* we know this will work, because it worked before :) */
1240 configure_processors_unlocked (0);
1244 _have_internal_generator = false;
1246 for (i = _processors.begin(); i != _processors.end(); ++i) {
1247 boost::shared_ptr<PluginInsert> pi;
1249 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1250 if (pi->is_generator()) {
1251 _have_internal_generator = true;
1258 processor->drop_references ();
1259 processors_changed (); /* EMIT SIGNAL */
1265 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1267 ProcessorList deleted;
1268 ProcessorList as_we_were;
1270 if (!_session.engine().connected()) {
1274 processor_max_streams.reset();
1277 Glib::RWLock::WriterLock lm (_processor_lock);
1278 ProcessorList::iterator i;
1279 boost::shared_ptr<Processor> processor;
1281 as_we_were = _processors;
1283 for (i = _processors.begin(); i != _processors.end(); ) {
1287 /* these can never be removed */
1289 if (processor == _amp || processor == _meter || processor == _main_outs) {
1294 /* see if its in the list of processors to delete */
1296 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1301 /* stop IOProcessors that send to JACK ports
1302 from causing noise as a result of no longer being
1306 boost::shared_ptr<IOProcessor> iop;
1308 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1312 deleted.push_back (processor);
1313 i = _processors.erase (i);
1316 if (deleted.empty()) {
1317 /* none of those in the requested list were found */
1321 _output->set_user_latency (0);
1323 if (configure_processors_unlocked (err)) {
1324 /* get back to where we where */
1325 _processors = as_we_were;
1326 /* we know this will work, because it worked before :) */
1327 configure_processors_unlocked (0);
1331 _have_internal_generator = false;
1333 for (i = _processors.begin(); i != _processors.end(); ++i) {
1334 boost::shared_ptr<PluginInsert> pi;
1336 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1337 if (pi->is_generator()) {
1338 _have_internal_generator = true;
1345 /* now try to do what we need to so that those that were removed will be deleted */
1347 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1348 (*i)->drop_references ();
1351 processors_changed (); /* EMIT SIGNAL */
1358 Route::configure_processors (ProcessorStreams* err)
1360 if (!_in_configure_processors) {
1361 Glib::RWLock::WriterLock lm (_processor_lock);
1362 return configure_processors_unlocked (err);
1367 /** Configure the input/output configuration of each processor in the processors list.
1368 * Return 0 on success, otherwise configuration is impossible.
1371 Route::configure_processors_unlocked (ProcessorStreams* err)
1373 if (_in_configure_processors) {
1377 _in_configure_processors = true;
1379 // Check each processor in order to see if we can configure as requested
1380 ChanCount in = _input->n_ports ();
1382 list< pair<ChanCount,ChanCount> > configuration;
1385 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1387 if ((*p)->can_support_io_configuration(in, out)) {
1388 configuration.push_back(make_pair(in, out));
1395 _in_configure_processors = false;
1400 // We can, so configure everything
1401 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1402 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1403 (*p)->configure_io(c->first, c->second);
1404 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1405 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1409 // Ensure route outputs match last processor's outputs
1410 if (out != _output->n_ports ()) {
1411 _output->ensure_io (out, false, this);
1414 _in_configure_processors = false;
1419 Route::all_processors_flip ()
1421 Glib::RWLock::ReaderLock lm (_processor_lock);
1423 if (_processors.empty()) {
1427 bool first_is_on = _processors.front()->active();
1429 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1431 (*i)->deactivate ();
1437 _session.set_dirty ();
1440 /** Set all processors with a given placement to a given active state.
1441 * @param p Placement of processors to change.
1442 * @param state New active state for those processors.
1445 Route::all_processors_active (Placement p, bool state)
1447 Glib::RWLock::ReaderLock lm (_processor_lock);
1449 if (_processors.empty()) {
1452 ProcessorList::iterator start, end;
1453 placement_range(p, start, end);
1455 bool before_amp = true;
1456 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1461 if (p == PreFader && before_amp) {
1465 (*i)->deactivate ();
1470 _session.set_dirty ();
1474 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1476 bool pre_fader = true;
1477 Glib::RWLock::ReaderLock lm (_processor_lock);
1479 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1481 /* semantic note: if p == amp, we want to return true, so test
1482 for equality before checking if this is the amp
1499 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1501 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1502 NOTE: all processors in "new_order" MUST be marked as visible. There maybe additional
1503 processors in the current actual processor list that are hidden. Any visible processors
1504 in the current list but not in "new_order" will be assumed to be deleted.
1508 Glib::RWLock::WriterLock lm (_processor_lock);
1509 ChanCount old_pms = processor_max_streams;
1510 ProcessorList::iterator oiter;
1511 ProcessorList::const_iterator niter;
1512 ProcessorList as_it_was_before = _processors;
1513 ProcessorList as_it_will_be;
1515 oiter = _processors.begin();
1516 niter = new_order.begin();
1518 while (niter != new_order.end()) {
1520 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1521 then append it to the temp list.
1523 Otherwise, see if the next processor in the old list is in the new list. if not,
1524 its been deleted. If its there, append it to the temp list.
1527 if (oiter == _processors.end()) {
1529 /* no more elements in the old list, so just stick the rest of
1530 the new order onto the temp list.
1533 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1534 while (niter != new_order.end()) {
1541 if (!(*oiter)->visible()) {
1543 as_it_will_be.push_back (*oiter);
1547 /* visible processor: check that its in the new order */
1549 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1550 /* deleted: do nothing, shared_ptr<> will clean up */
1552 /* ignore this one, and add the next item from the new order instead */
1553 as_it_will_be.push_back (*niter);
1558 /* now remove from old order - its taken care of no matter what */
1559 oiter = _processors.erase (oiter);
1564 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1566 if (configure_processors_unlocked (err)) {
1567 _processors = as_it_was_before;
1568 processor_max_streams = old_pms;
1573 processors_changed (); /* EMIT SIGNAL */
1585 Route::get_template()
1587 return state(false);
1591 Route::state(bool full_state)
1593 XMLNode *node = new XMLNode("Route");
1594 ProcessorList::iterator i;
1597 id().print (buf, sizeof (buf));
1598 node->add_property("id", buf);
1599 node->add_property ("name", _name);
1600 node->add_property("default-type", _default_type.to_string());
1603 node->add_property("flags", enum_2_string (_flags));
1606 node->add_property("active", _active?"yes":"no");
1607 node->add_property("phase-invert", _phase_invert?"yes":"no");
1608 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1609 node->add_property("meter-point", enum_2_string (_meter_point));
1612 node->add_property("route-group", _route_group->name());
1615 string order_string;
1616 OrderKeys::iterator x = order_keys.begin();
1618 while (x != order_keys.end()) {
1619 order_string += string ((*x).first);
1620 order_string += '=';
1621 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1622 order_string += buf;
1626 if (x == order_keys.end()) {
1630 order_string += ':';
1632 node->add_property ("order-keys", order_string);
1634 node->add_child_nocopy (_input->state (full_state));
1635 node->add_child_nocopy (_output->state (full_state));
1636 node->add_child_nocopy (_solo_control->get_state ());
1637 node->add_child_nocopy (_mute_master->get_state ());
1639 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1640 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1641 remote_control_node->add_property (X_("id"), buf);
1642 node->add_child_nocopy (*remote_control_node);
1644 if (_comment.length()) {
1645 XMLNode *cmt = node->add_child ("Comment");
1646 cmt->add_content (_comment);
1649 for (i = _processors.begin(); i != _processors.end(); ++i) {
1650 node->add_child_nocopy((*i)->state (full_state));
1654 node->add_child_copy (*_extra_xml);
1661 Route::set_state (const XMLNode& node, int version)
1663 return _set_state (node, version, true);
1667 Route::_set_state (const XMLNode& node, int version, bool /*call_base*/)
1669 if (version < 3000) {
1670 return _set_state_2X (node, version);
1674 XMLNodeConstIterator niter;
1676 XMLPropertyList plist;
1677 const XMLProperty *prop;
1679 if (node.name() != "Route"){
1680 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1684 if ((prop = node.property (X_("name"))) != 0) {
1685 Route::set_name (prop->value());
1688 if ((prop = node.property ("id")) != 0) {
1689 _id = prop->value ();
1692 if ((prop = node.property (X_("flags"))) != 0) {
1693 _flags = Flag (string_2_enum (prop->value(), _flags));
1698 /* add all processors (except amp, which is always present) */
1700 nlist = node.children();
1701 XMLNode processor_state (X_("processor_state"));
1703 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1707 if (child->name() == IO::state_node_name) {
1708 if ((prop = child->property (X_("direction"))) == 0) {
1712 if (prop->value() == "Input") {
1713 _input->set_state (*child, version);
1714 } else if (prop->value() == "Output") {
1715 _output->set_state (*child, version);
1719 if (child->name() == X_("Processor")) {
1720 processor_state.add_child_copy (*child);
1724 set_processor_state (processor_state);
1726 if ((prop = node.property ("solo_level")) != 0) {
1727 _solo_level = 0; // needed for mod_solo_level() to work
1728 mod_solo_level (atoi (prop->value()));
1731 if ((prop = node.property ("solo-isolated")) != 0) {
1732 set_solo_isolated (string_is_affirmative (prop->value()), this);
1735 if ((prop = node.property (X_("phase-invert"))) != 0) {
1736 set_phase_invert (string_is_affirmative (prop->value()));
1739 if ((prop = node.property (X_("denormal-protection"))) != 0) {
1740 set_denormal_protection (string_is_affirmative (prop->value()));
1743 if ((prop = node.property (X_("active"))) != 0) {
1744 bool yn = string_is_affirmative (prop->value());
1745 _active = !yn; // force switch
1749 if ((prop = node.property (X_("soloed"))) != 0) {
1750 bool yn = string_is_affirmative (prop->value());
1752 /* XXX force reset of solo status */
1754 set_solo (yn, this);
1757 if ((prop = node.property (X_("meter-point"))) != 0) {
1758 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1761 if ((prop = node.property (X_("route-group"))) != 0) {
1762 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1763 if (route_group == 0) {
1764 error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1766 set_route_group (route_group, this);
1770 if ((prop = node.property (X_("order-keys"))) != 0) {
1774 string::size_type colon, equal;
1775 string remaining = prop->value();
1777 while (remaining.length()) {
1779 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1780 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1783 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1784 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1787 set_order_key (remaining.substr (0, equal), n);
1791 colon = remaining.find_first_of (':');
1793 if (colon != string::npos) {
1794 remaining = remaining.substr (colon+1);
1801 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1804 if (child->name() == X_("Comment")) {
1806 /* XXX this is a terrible API design in libxml++ */
1808 XMLNode *cmt = *(child->children().begin());
1809 _comment = cmt->content();
1811 } else if (child->name() == X_("Extra")) {
1813 _extra_xml = new XMLNode (*child);
1815 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1817 if (prop->value() == "solo") {
1818 _solo_control->set_state (*child, version);
1819 _session.add_controllable (_solo_control);
1822 } else if (child->name() == X_("RemoteControl")) {
1823 if ((prop = child->property (X_("id"))) != 0) {
1825 sscanf (prop->value().c_str(), "%d", &x);
1826 set_remote_control_id (x);
1829 } else if (child->name() == X_("MuteMaster")) {
1830 _mute_master->set_state (*child, version);
1838 Route::_set_state_2X (const XMLNode& node, int version)
1841 XMLNodeConstIterator niter;
1843 XMLPropertyList plist;
1844 const XMLProperty *prop;
1846 /* 2X things which still remain to be handled:
1849 * mute-affects-pre-fader
1850 * mute-affects-post-fader
1851 * mute-affects-control-outs
1852 * mute-affects-main-outs
1857 if (node.name() != "Route") {
1858 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1862 if ((prop = node.property (X_("flags"))) != 0) {
1863 _flags = Flag (string_2_enum (prop->value(), _flags));
1868 /* add standard processors */
1870 _meter.reset (new PeakMeter (_session));
1871 add_processor (_meter, PreFader);
1873 if (_flags & ControlOut) {
1874 /* where we listen to tracks */
1875 _intreturn.reset (new InternalReturn (_session));
1876 add_processor (_intreturn, PreFader);
1879 _main_outs.reset (new Delivery (_session, _output, _mute_master, _name, Delivery::Main));
1880 add_processor (_main_outs, PostFader);
1884 nlist = node.children ();
1885 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1889 if (child->name() == IO::state_node_name) {
1891 /* there is a note in IO::set_state_2X() about why we have to call
1895 _input->set_state_2X (*child, version, true);
1896 _output->set_state_2X (*child, version, false);
1898 if ((prop = child->property (X_("name"))) != 0) {
1899 set_name (prop->value ());
1902 if ((prop = child->property (X_("id"))) != 0) {
1903 _id = prop->value ();
1906 if ((prop = child->property (X_("active"))) != 0) {
1907 bool yn = string_is_affirmative (prop->value());
1908 _active = !yn; // force switch
1916 if ((prop = node.property (X_("phase-invert"))) != 0) {
1917 set_phase_invert (string_is_affirmative (prop->value()));
1920 if ((prop = node.property (X_("denormal-protection"))) != 0) {
1921 set_denormal_protection (string_is_affirmative (prop->value()));
1924 if ((prop = node.property (X_("soloed"))) != 0) {
1925 bool yn = string_is_affirmative (prop->value());
1927 /* XXX force reset of solo status */
1929 set_solo (yn, this);
1932 if ((prop = node.property (X_("meter-point"))) != 0) {
1933 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1936 /* XXX: if the route was in both a mix group and an edit group, it'll end up
1937 just in the edit group. */
1939 if ((prop = node.property (X_("mix-group"))) != 0) {
1940 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1941 if (route_group == 0) {
1942 error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1944 set_route_group (route_group, this);
1948 if ((prop = node.property (X_("edit-group"))) != 0) {
1949 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1950 if (route_group == 0) {
1951 error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1953 set_route_group (route_group, this);
1957 if ((prop = node.property (X_("order-keys"))) != 0) {
1961 string::size_type colon, equal;
1962 string remaining = prop->value();
1964 while (remaining.length()) {
1966 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1967 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1970 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1971 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1974 set_order_key (remaining.substr (0, equal), n);
1978 colon = remaining.find_first_of (':');
1980 if (colon != string::npos) {
1981 remaining = remaining.substr (colon+1);
1988 XMLNodeList redirect_nodes;
1990 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1994 if (child->name() == X_("Send") || child->name() == X_("Insert")) {
1995 redirect_nodes.push_back(child);
2000 set_processor_state_2X (redirect_nodes, version);
2002 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
2005 if (child->name() == X_("Comment")) {
2007 /* XXX this is a terrible API design in libxml++ */
2009 XMLNode *cmt = *(child->children().begin());
2010 _comment = cmt->content();
2012 } else if (child->name() == X_("Extra")) {
2014 _extra_xml = new XMLNode (*child);
2016 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
2018 if (prop->value() == "solo") {
2019 _solo_control->set_state (*child, version);
2020 _session.add_controllable (_solo_control);
2023 } else if (child->name() == X_("RemoteControl")) {
2024 if ((prop = child->property (X_("id"))) != 0) {
2026 sscanf (prop->value().c_str(), "%d", &x);
2027 set_remote_control_id (x);
2037 Route::get_processor_state ()
2039 XMLNode* root = new XMLNode (X_("redirects"));
2040 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2041 root->add_child_nocopy ((*i)->state (true));
2048 Route::set_processor_state_2X (XMLNodeList const & nList, int version)
2050 /* We don't bother removing existing processors not in nList, as this
2051 method will only be called when creating a Route from scratch, not
2052 for undo purposes. Just put processors in at the appropriate place
2056 for (XMLNodeConstIterator i = nList.begin(); i != nList.end(); ++i) {
2057 add_processor_from_xml_2X (**i, version, _processors.begin ());
2062 Route::set_processor_state (const XMLNode& node)
2064 const XMLNodeList &nlist = node.children();
2065 XMLNodeConstIterator niter;
2066 ProcessorList::iterator i, o;
2068 // Iterate through existing processors, remove those which are not in the state list
2070 for (i = _processors.begin(); i != _processors.end(); ) {
2072 /* leave amp alone, always */
2079 ProcessorList::iterator tmp = i;
2082 bool processorInStateList = false;
2084 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2086 XMLProperty* id_prop = (*niter)->property(X_("id"));
2088 if (id_prop && (*i)->id() == id_prop->value()) {
2089 processorInStateList = true;
2094 if (!processorInStateList) {
2095 remove_processor (*i);
2101 // Iterate through state list and make sure all processors are on the track and in the correct order,
2102 // set the state of existing processors according to the new state on the same go
2104 i = _processors.begin();
2106 for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
2108 XMLProperty* prop = (*niter)->property ("type");
2112 // Check whether the next processor in the list is the right one,
2113 // except for "amp" which is always there and may not have the
2114 // old ID since it is always created anew in every Route
2116 if (prop->value() != "amp") {
2117 while (o != _processors.end()) {
2118 XMLProperty* id_prop = (*niter)->property(X_("id"));
2119 if (id_prop && (*o)->id() == id_prop->value()) {
2127 // If the processor (*niter) is not on the route,
2128 // create it and move it to the correct location
2130 if (o == _processors.end()) {
2132 if (add_processor_from_xml (**niter, i)) {
2133 --i; // move iterator to the newly inserted processor
2135 cerr << "Error restoring route: unable to restore processor" << endl;
2140 // Otherwise, the processor already exists; just
2141 // ensure it is at the location provided in the XML state
2144 boost::shared_ptr<Processor> tmp = (*o);
2145 _processors.erase (o); // remove the old copy
2146 _processors.insert (i, tmp); // insert the processor at the correct location
2147 --i; // move iterator to the correct processor
2150 // and make it (just) so
2152 (*i)->set_state (**niter, Stateful::current_state_version);
2156 /* note: there is no configure_processors() call because we figure that
2157 the XML state represents a working signal route.
2160 processors_changed ();
2164 Route::curve_reallocate ()
2166 // _gain_automation_curve.finish_resize ();
2167 // _pan_automation_curve.finish_resize ();
2171 Route::silence (nframes_t nframes)
2175 _output->silence (nframes);
2178 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2181 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2182 boost::shared_ptr<PluginInsert> pi;
2184 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2185 // skip plugins, they don't need anything when we're not active
2189 (*i)->silence (nframes);
2192 if (nframes == _session.get_block_size()) {
2202 Route::add_internal_return ()
2205 _intreturn.reset (new InternalReturn (_session));
2206 add_processor (_intreturn, PreFader);
2211 Route::get_return_buffer () const
2213 Glib::RWLock::ReaderLock rm (_processor_lock);
2215 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2216 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2219 BufferSet* bs = d->get_buffers ();
2228 Route::release_return_buffer () const
2230 Glib::RWLock::ReaderLock rm (_processor_lock);
2232 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
2233 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
2236 return d->release_buffers ();
2242 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
2244 vector<string> ports;
2245 vector<string>::const_iterator i;
2248 Glib::RWLock::ReaderLock rm (_processor_lock);
2250 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
2252 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2254 if (d && d->target_route() == route) {
2256 /* if the target is the control outs, then make sure
2257 we take note of which i-send is doing that.
2260 if (route == _session.control_out()) {
2261 _control_outs = boost::dynamic_pointer_cast<Delivery>(d);
2264 /* already listening via the specified IO: do nothing */
2271 boost::shared_ptr<InternalSend> listener;
2274 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2276 } catch (failed_constructor& err) {
2280 if (route == _session.control_out()) {
2281 _control_outs = listener;
2284 add_processor (listener, placement);
2290 Route::drop_listen (boost::shared_ptr<Route> route)
2292 ProcessorStreams err;
2293 ProcessorList::iterator tmp;
2295 Glib::RWLock::ReaderLock rl(_processor_lock);
2299 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2301 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2303 if (d && d->target_route() == route) {
2305 remove_processor (*x, &err);
2308 /* list could have been demolished while we dropped the lock
2318 if (route == _session.control_out()) {
2319 _control_outs.reset ();
2324 Route::set_route_group (RouteGroup *rg, void *src)
2326 if (rg == _route_group) {
2331 _route_group->remove (this);
2334 if ((_route_group = rg) != 0) {
2335 _route_group->add (this);
2338 _session.set_dirty ();
2339 route_group_changed (src); /* EMIT SIGNAL */
2343 Route::drop_route_group (void *src)
2346 _session.set_dirty ();
2347 route_group_changed (src); /* EMIT SIGNAL */
2351 Route::set_comment (string cmt, void *src)
2354 comment_changed (src);
2355 _session.set_dirty ();
2359 Route::feeds (boost::shared_ptr<Route> other)
2361 // cerr << _name << endl;
2363 if (_output->connected_to (other->input())) {
2364 // cerr << "\tdirect FEEDS " << other->name() << endl;
2368 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
2370 boost::shared_ptr<IOProcessor> iop;
2372 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2373 if (iop->feeds (other)) {
2374 // cerr << "\tIOP " << iop->name() << " feeds " << other->name() << endl;
2377 // cerr << "\tIOP " << iop->name() << " does NOT feeds " << other->name() << endl;
2382 // cerr << "\tdoes NOT FEED " << other->name() << endl;
2387 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2389 nframes_t now = _session.transport_frame();
2392 Glib::RWLock::ReaderLock lm (_processor_lock);
2395 automation_snapshot (now, true);
2398 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2400 if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2401 (*i)->deactivate ();
2405 (*i)->transport_stopped (now);
2409 _roll_delay = _initial_delay;
2413 Route::input_change_handler (IOChange change, void * /*src*/)
2415 if ((change & ConfigurationChanged)) {
2416 configure_processors (0);
2421 Route::output_change_handler (IOChange change, void * /*src*/)
2423 if ((change & ConfigurationChanged)) {
2425 /* XXX resize all listeners to match _main_outs? */
2427 // configure_processors (0);
2432 Route::pans_required () const
2434 if (n_outputs().n_audio() < 2) {
2438 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2442 Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2443 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2445 if (n_outputs().n_total() == 0) {
2449 if (session_state_changing || !_active || n_inputs() == ChanCount::ZERO) {
2454 _amp->apply_gain_automation (false);
2455 passthru (start_frame, end_frame, nframes, 0);
2461 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2463 if (_roll_delay > nframes) {
2465 _roll_delay -= nframes;
2467 /* transport frame is not legal for caller to use */
2470 } else if (_roll_delay > 0) {
2472 nframes -= _roll_delay;
2473 silence (_roll_delay);
2474 /* we've written _roll_delay of samples into the
2475 output ports, so make a note of that for
2478 _main_outs->increment_output_offset (_roll_delay);
2479 transport_frame += _roll_delay;
2488 Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
2489 bool /*can_record*/, bool /*rec_monitors_input*/)
2492 // automation snapshot can also be called from the non-rt context
2493 // and it uses the processor list, so we try to acquire the lock here
2494 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2497 automation_snapshot (_session.transport_frame(), false);
2501 if (n_outputs().n_total() == 0) {
2505 if (!_active || n_inputs().n_total() == 0) {
2510 nframes_t unused = 0;
2512 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2518 passthru (start_frame, end_frame, nframes, declick);
2524 Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
2525 bool /*can_record*/, bool /*rec_monitors_input*/)
2532 Route::toggle_monitor_input ()
2534 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2535 i->ensure_monitor_input( ! i->monitoring_input());
2540 Route::has_external_redirects () const
2542 // FIXME: what about sends? - they don't return a signal back to ardour?
2544 boost::shared_ptr<const PortInsert> pi;
2546 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2548 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2550 for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2552 string port_name = port->name();
2553 string client_name = port_name.substr (0, port_name.find(':'));
2555 /* only say "yes" if the redirect is actually in use */
2557 if (client_name != "ardour" && pi->active()) {
2568 Route::flush_processors ()
2570 /* XXX shouldn't really try to take this lock, since
2571 this is called from the RT audio thread.
2574 Glib::RWLock::ReaderLock lm (_processor_lock);
2576 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2577 (*i)->deactivate ();
2583 Route::set_meter_point (MeterPoint p, void *src)
2585 if (_meter_point != p) {
2588 // Move meter in the processors list
2589 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _meter);
2590 _processors.erase(loc);
2593 loc = _processors.begin();
2596 loc = find(_processors.begin(), _processors.end(), _amp);
2598 case MeterPostFader:
2599 loc = _processors.end();
2602 _processors.insert(loc, _meter);
2604 meter_change (src); /* EMIT SIGNAL */
2605 processors_changed (); /* EMIT SIGNAL */
2606 _session.set_dirty ();
2610 Route::put_control_outs_at (Placement p)
2612 if (!_control_outs) {
2616 // Move meter in the processors list
2617 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _control_outs);
2618 _processors.erase(loc);
2622 loc = find(_processors.begin(), _processors.end(), _amp);
2623 if (loc != _processors.begin()) {
2628 loc = find(_processors.begin(), _processors.end(), _amp);
2629 assert (loc != _processors.end());
2634 _processors.insert(loc, _control_outs);
2636 processors_changed (); /* EMIT SIGNAL */
2637 _session.set_dirty ();
2641 Route::update_total_latency ()
2643 nframes_t old = _output->effective_latency();
2644 nframes_t own_latency = _output->user_latency();
2646 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2647 if ((*i)->active ()) {
2648 own_latency += (*i)->signal_latency ();
2652 #undef DEBUG_LATENCY
2653 #ifdef DEBUG_LATENCY
2654 cerr << _name << ": internal redirect latency = " << own_latency << endl;
2657 _output->set_port_latency (own_latency);
2659 if (_output->user_latency() == 0) {
2661 /* this (virtual) function is used for pure Routes,
2662 not derived classes like AudioTrack. this means
2663 that the data processed here comes from an input
2664 port, not prerecorded material, and therefore we
2665 have to take into account any input latency.
2668 own_latency += _input->signal_latency ();
2671 if (old != own_latency) {
2672 _output->set_latency_delay (own_latency);
2673 signal_latency_changed (); /* EMIT SIGNAL */
2676 #ifdef DEBUG_LATENCY
2677 cerr << _name << ": input latency = " << _input->signal_latency() << " total = "
2678 << own_latency << endl;
2681 return _output->effective_latency ();
2685 Route::set_user_latency (nframes_t nframes)
2687 _output->set_user_latency (nframes);
2688 _session.update_latency_compensation (false, false);
2692 Route::set_latency_delay (nframes_t longest_session_latency)
2694 nframes_t old = _initial_delay;
2696 if (_output->effective_latency() < longest_session_latency) {
2697 _initial_delay = longest_session_latency - _output->effective_latency();
2702 if (_initial_delay != old) {
2703 initial_delay_changed (); /* EMIT SIGNAL */
2706 if (_session.transport_stopped()) {
2707 _roll_delay = _initial_delay;
2712 Route::automation_snapshot (nframes_t now, bool force)
2714 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2715 (*i)->automation_snapshot (now, force);
2719 Route::SoloControllable::SoloControllable (std::string name, Route& r)
2720 : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
2721 boost::shared_ptr<AutomationList>(), name)
2724 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
2729 Route::SoloControllable::set_value (float val)
2731 bool bval = ((val >= 0.5f) ? true: false);
2733 route.set_solo (bval, this);
2737 Route::SoloControllable::get_value (void) const
2739 return route.soloed() ? 1.0f : 0.0f;
2743 Route::set_block_size (nframes_t nframes)
2745 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2746 (*i)->set_block_size (nframes);
2748 _session.ensure_buffers(processor_max_streams);
2752 Route::protect_automation ()
2754 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
2755 (*i)->protect_automation();
2759 Route::set_pending_declick (int declick)
2762 /* this call is not allowed to turn off a pending declick unless "force" is true */
2764 _pending_declick = declick;
2766 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2768 _pending_declick = 0;
2773 /** Shift automation forwards from a particular place, thereby inserting time.
2774 * Adds undo commands for any shifts that are performed.
2776 * @param pos Position to start shifting from.
2777 * @param frames Amount to shift forwards by.
2781 Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
2783 #ifdef THIS_NEEDS_FIXING_FOR_V3
2785 /* gain automation */
2786 XMLNode &before = _gain_control->get_state ();
2787 _gain_control->shift (pos, frames);
2788 XMLNode &after = _gain_control->get_state ();
2789 _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
2791 /* pan automation */
2792 for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
2793 Curve & c = (*i)->automation ();
2794 XMLNode &before = c.get_state ();
2795 c.shift (pos, frames);
2796 XMLNode &after = c.get_state ();
2797 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
2800 /* redirect automation */
2802 Glib::RWLock::ReaderLock lm (redirect_lock);
2803 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
2806 (*i)->what_has_automation (a);
2808 for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
2809 AutomationList & al = (*i)->automation_list (*j);
2810 XMLNode &before = al.get_state ();
2811 al.shift (pos, frames);
2812 XMLNode &after = al.get_state ();
2813 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
2823 Route::save_as_template (const string& path, const string& name)
2825 XMLNode& node (state (false));
2828 IO::set_name_in_state (*node.children().front(), name);
2830 tree.set_root (&node);
2831 return tree.write (path.c_str());
2836 Route::set_name (const string& str)
2842 name = Route::ensure_track_or_route_name (str, _session);
2843 SessionObject::set_name (name);
2845 ret = (_input->set_name(name) && _output->set_name(name));
2849 Glib::RWLock::ReaderLock lm (_processor_lock);
2851 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2853 /* rename all I/O processors that have inputs or outputs */
2855 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
2857 if (iop && (iop->output() || iop->input())) {
2858 if (!iop->set_name (name)) {
2869 boost::shared_ptr<Send>
2870 Route::internal_send_for (boost::shared_ptr<const Route> target) const
2872 Glib::RWLock::ReaderLock lm (_processor_lock);
2874 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2875 boost::shared_ptr<InternalSend> send;
2877 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
2878 if (send->target_route() == target) {
2884 return boost::shared_ptr<Send>();
2888 Route::set_phase_invert (bool yn)
2890 if (_phase_invert != yn) {
2891 _phase_invert = 0xffff; // XXX all channels
2892 phase_invert_changed (); /* EMIT SIGNAL */
2897 Route::phase_invert () const
2899 return _phase_invert != 0;
2903 Route::set_denormal_protection (bool yn)
2905 if (_denormal_protection != yn) {
2906 _denormal_protection = yn;
2907 denormal_protection_changed (); /* EMIT SIGNAL */
2912 Route::denormal_protection () const
2914 return _denormal_protection;
2918 Route::set_active (bool yn)
2920 if (_active != yn) {
2922 _input->set_active (yn);
2923 _output->set_active (yn);
2924 active_changed (); // EMIT SIGNAL
2931 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2937 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2939 boost::shared_ptr<Send> s;
2940 boost::shared_ptr<Return> r;
2942 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
2943 s->meter()->meter();
2944 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
2945 r->meter()->meter ();
2950 boost::shared_ptr<Panner>
2951 Route::panner() const
2954 return _main_outs->panner();
2957 boost::shared_ptr<AutomationControl>
2958 Route::gain_control() const
2961 return _amp->gain_control();
2964 boost::shared_ptr<AutomationControl>
2965 Route::get_control (const Evoral::Parameter& param)
2967 /* either we own the control or .... */
2969 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(data().control (param));
2973 /* maybe one of our processors does or ... */
2975 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2976 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2977 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->data().control (param))) != 0) {
2985 /* nobody does so we'll make a new one */
2987 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));