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, 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 write_out_of_band_data (bufs, start_frame, end_frame, nframes);
491 process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick);
495 Route::set_listen (bool yn, void* src)
498 if (yn != _control_outs->active()) {
500 _control_outs->activate ();
502 _control_outs->deactivate ();
505 listen_changed (src); /* EMIT SIGNAL */
511 Route::listening () const
514 return _control_outs->active ();
521 Route::set_solo (bool yn, void *src)
523 if (_solo_safe || _solo_isolated) {
527 if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
528 _route_group->apply (&Route::set_solo, yn, _route_group);
532 if (soloed() != yn) {
533 mod_solo_level (yn ? 1 : -1);
534 solo_changed (src); /* EMIT SIGNAL */
535 _solo_control->Changed (); /* EMIT SIGNAL */
540 Route::mod_solo_level (int32_t delta)
543 if (_solo_level >= (uint32_t) delta) {
544 _solo_level += delta;
549 _solo_level += delta;
552 /* tell main outs what the solo situation is
555 _main_outs->set_solo_level (_solo_level);
556 _main_outs->set_solo_isolated (_solo_isolated);
560 Route::set_solo_isolated (bool yn, void *src)
562 if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Solo)) {
563 _route_group->apply (&Route::set_solo_isolated, yn, _route_group);
567 if (yn != _solo_isolated) {
570 /* tell main outs what the solo situation is
573 _main_outs->set_solo_level (_solo_level);
574 _main_outs->set_solo_isolated (_solo_isolated);
576 solo_isolated_changed (src);
581 Route::solo_isolated () const
583 return _solo_isolated;
587 Route::set_mute (bool yn, void *src)
589 if (_route_group && src != _route_group && _route_group->active_property (RouteGroup::Mute)) {
590 _route_group->apply (&Route::set_mute, yn, _route_group);
595 _mute_master->mute (yn);
603 return _mute_master->muted ();
608 dump_processors(const string& name, const list<boost::shared_ptr<Processor> >& procs)
610 cerr << name << " {" << endl;
611 for (list<boost::shared_ptr<Processor> >::const_iterator p = procs.begin();
612 p != procs.end(); ++p) {
613 cerr << "\t" << (*p)->name() << " ID = " << (*p)->id() << endl;
620 Route::add_processor (boost::shared_ptr<Processor> processor, Placement placement, ProcessorStreams* err)
622 ProcessorList::iterator loc;
624 /* XXX this is not thread safe - we don't hold the lock across determining the iter
625 to add before and actually doing the insertion. dammit.
628 if (placement == PreFader) {
629 /* generic pre-fader: insert immediately before the amp */
630 loc = find (_processors.begin(), _processors.end(), _amp);
632 /* generic post-fader: insert right before the main outs */
633 loc = find (_processors.begin(), _processors.end(), _main_outs);
636 return add_processor (processor, loc, err);
640 /** Add a processor to the route.
641 * If @a iter is not NULL, it must point to an iterator in _processors and the new
642 * processor will be inserted immediately before this location. Otherwise,
643 * @a position is used.
646 Route::add_processor (boost::shared_ptr<Processor> processor, ProcessorList::iterator iter, ProcessorStreams* err)
648 ChanCount old_pms = processor_max_streams;
650 if (!_session.engine().connected() || !processor) {
655 Glib::RWLock::WriterLock lm (_processor_lock);
657 boost::shared_ptr<PluginInsert> pi;
658 boost::shared_ptr<PortInsert> porti;
660 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), processor);
662 if (processor == _amp || processor == _meter || processor == _main_outs) {
663 // Ensure only one of these are in the list at any time
664 if (loc != _processors.end()) {
665 if (iter == loc) { // Already in place, do nothing
667 } else { // New position given, relocate
668 _processors.erase (loc);
673 if (loc != _processors.end()) {
674 cerr << "ERROR: Processor added to route twice!" << endl;
681 _processors.insert (loc, processor);
683 // Set up processor list channels. This will set processor->[input|output]_streams(),
684 // 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)) {
758 _meter.reset (new PeakMeter (_session, node));
761 } else if (prop->value() == "amp") {
763 /* amp always exists */
766 if (processor->set_state (node)) {
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)) {
786 _intreturn.reset (new InternalReturn (_session, node));
787 processor = _intreturn;
789 } else if (prop->value() == "main-outs") {
792 if (_main_outs->set_state (node)) {
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;
834 Route::add_processors (const ProcessorList& others, boost::shared_ptr<Processor> before, ProcessorStreams* err)
836 ProcessorList::iterator loc;
839 loc = find(_processors.begin(), _processors.end(), before);
841 /* nothing specified - at end but before main outs */
842 loc = find (_processors.begin(), _processors.end(), _main_outs);
845 return add_processors (others, loc, err);
849 Route::add_processors (const ProcessorList& others, ProcessorList::iterator iter, ProcessorStreams* err)
851 /* NOTE: this is intended to be used ONLY when copying
852 processors from another Route. Hence the subtle
853 differences between this and ::add_processor()
856 ChanCount old_pms = processor_max_streams;
858 if (!_session.engine().connected()) {
862 if (others.empty()) {
867 Glib::RWLock::WriterLock lm (_processor_lock);
868 ProcessorList::iterator existing_end = _processors.end();
871 ChanCount potential_max_streams = ChanCount::max (_input->n_ports(), _output->n_ports());
873 for (ProcessorList::const_iterator i = others.begin(); i != others.end(); ++i) {
875 // Ensure meter only appears in the list once
877 ProcessorList::iterator m = find(_processors.begin(), _processors.end(), *i);
878 if (m != _processors.end()) {
879 _processors.erase(m);
883 boost::shared_ptr<PluginInsert> pi;
885 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
888 ChanCount m = max (pi->input_streams(), pi->output_streams());
890 if (m > potential_max_streams) {
891 potential_max_streams = m;
895 _processors.insert (iter, *i);
897 if (configure_processors_unlocked (err)) {
899 _processors.erase (existing_end, _processors.end());
900 configure_processors_unlocked (0); // it worked before we tried to add it ...
904 (*i)->ActiveChanged.connect (bind (mem_fun (_session, &Session::update_latency_compensation), false, false));
907 _output->set_user_latency (0);
910 processors_changed (); /* EMIT SIGNAL */
916 Route::placement_range(Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end)
919 start = _processors.begin();
920 end = find(_processors.begin(), _processors.end(), _amp);
922 start = find(_processors.begin(), _processors.end(), _amp);
924 end = _processors.end();
928 /** Turn off all processors with a given placement
929 * @param p Placement of processors to disable
932 Route::disable_processors (Placement p)
934 Glib::RWLock::ReaderLock lm (_processor_lock);
936 ProcessorList::iterator start, end;
937 placement_range(p, start, end);
939 for (ProcessorList::iterator i = start; i != end; ++i) {
943 _session.set_dirty ();
946 /** Turn off all redirects
949 Route::disable_processors ()
951 Glib::RWLock::ReaderLock lm (_processor_lock);
953 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
957 _session.set_dirty ();
960 /** Turn off all redirects with a given placement
961 * @param p Placement of redirects to disable
964 Route::disable_plugins (Placement p)
966 Glib::RWLock::ReaderLock lm (_processor_lock);
968 ProcessorList::iterator start, end;
969 placement_range(p, start, end);
971 for (ProcessorList::iterator i = start; i != end; ++i) {
972 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
977 _session.set_dirty ();
980 /** Turn off all plugins
983 Route::disable_plugins ()
985 Glib::RWLock::ReaderLock lm (_processor_lock);
987 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
988 if (boost::dynamic_pointer_cast<PluginInsert> (*i)) {
993 _session.set_dirty ();
998 Route::ab_plugins (bool forward)
1000 Glib::RWLock::ReaderLock lm (_processor_lock);
1004 /* forward = turn off all active redirects, and mark them so that the next time
1005 we go the other way, we will revert them
1008 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1009 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1013 if ((*i)->active()) {
1014 (*i)->deactivate ();
1015 (*i)->set_next_ab_is_active (true);
1017 (*i)->set_next_ab_is_active (false);
1023 /* backward = if the redirect was marked to go active on the next ab, do so */
1025 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1027 if (!boost::dynamic_pointer_cast<PluginInsert> (*i)) {
1031 if ((*i)->get_next_ab_is_active()) {
1034 (*i)->deactivate ();
1039 _session.set_dirty ();
1043 /** Remove processors with a given placement.
1044 * @param p Placement of processors to remove.
1047 Route::clear_processors (Placement p)
1049 const ChanCount old_pms = processor_max_streams;
1051 if (!_session.engine().connected()) {
1055 bool already_deleting = _session.deletion_in_progress();
1056 if (!already_deleting) {
1057 _session.set_deletion_in_progress();
1061 Glib::RWLock::WriterLock lm (_processor_lock);
1062 ProcessorList new_list;
1063 ProcessorStreams err;
1064 bool seen_amp = false;
1066 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1072 if ((*i) == _amp || (*i) == _meter || (*i) == _main_outs) {
1074 /* you can't remove these */
1076 new_list.push_back (*i);
1083 new_list.push_back (*i);
1086 (*i)->drop_references ();
1094 (*i)->drop_references ();
1097 new_list.push_back (*i);
1104 _processors = new_list;
1105 configure_processors_unlocked (&err); // this can't fail
1108 processor_max_streams.reset();
1109 _have_internal_generator = false;
1110 processors_changed (); /* EMIT SIGNAL */
1112 if (!already_deleting) {
1113 _session.clear_deletion_in_progress();
1118 Route::remove_processor (boost::shared_ptr<Processor> processor, ProcessorStreams* err)
1120 /* these can never be removed */
1122 if (processor == _amp || processor == _meter || processor == _main_outs) {
1126 ChanCount old_pms = processor_max_streams;
1128 if (!_session.engine().connected()) {
1132 processor_max_streams.reset();
1135 Glib::RWLock::WriterLock lm (_processor_lock);
1136 ProcessorList::iterator i;
1137 bool removed = false;
1139 for (i = _processors.begin(); i != _processors.end(); ) {
1140 if (*i == processor) {
1142 /* move along, see failure case for configure_processors()
1143 where we may need to reconfigure the processor.
1146 /* stop redirects that send signals to JACK ports
1147 from causing noise as a result of no longer being
1151 boost::shared_ptr<IOProcessor> iop;
1153 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (*i)) != 0) {
1155 iop->input()->disconnect (this);
1157 if (iop->output()) {
1158 iop->output()->disconnect (this);
1162 i = _processors.erase (i);
1170 _output->set_user_latency (0);
1178 if (configure_processors_unlocked (err)) {
1179 /* get back to where we where */
1180 _processors.insert (i, processor);
1181 /* we know this will work, because it worked before :) */
1182 configure_processors_unlocked (0);
1186 _have_internal_generator = false;
1188 for (i = _processors.begin(); i != _processors.end(); ++i) {
1189 boost::shared_ptr<PluginInsert> pi;
1191 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1192 if (pi->is_generator()) {
1193 _have_internal_generator = true;
1200 processor->drop_references ();
1201 processors_changed (); /* EMIT SIGNAL */
1207 Route::remove_processors (const ProcessorList& to_be_deleted, ProcessorStreams* err)
1209 ProcessorList deleted;
1210 ProcessorList as_we_were;
1212 if (!_session.engine().connected()) {
1216 processor_max_streams.reset();
1219 Glib::RWLock::WriterLock lm (_processor_lock);
1220 ProcessorList::iterator i;
1221 boost::shared_ptr<Processor> processor;
1223 as_we_were = _processors;
1225 for (i = _processors.begin(); i != _processors.end(); ) {
1229 /* these can never be removed */
1231 if (processor == _amp || processor == _meter || processor == _main_outs) {
1236 /* see if its in the list of processors to delete */
1238 if (find (to_be_deleted.begin(), to_be_deleted.end(), processor) == to_be_deleted.end()) {
1243 /* stop IOProcessors that send to JACK ports
1244 from causing noise as a result of no longer being
1248 boost::shared_ptr<IOProcessor> iop;
1250 if ((iop = boost::dynamic_pointer_cast<IOProcessor> (processor)) != 0) {
1254 deleted.push_back (processor);
1255 i = _processors.erase (i);
1258 if (deleted.empty()) {
1259 /* none of those in the requested list were found */
1263 _output->set_user_latency (0);
1265 if (configure_processors_unlocked (err)) {
1266 /* get back to where we where */
1267 _processors = as_we_were;
1268 /* we know this will work, because it worked before :) */
1269 configure_processors_unlocked (0);
1273 _have_internal_generator = false;
1275 for (i = _processors.begin(); i != _processors.end(); ++i) {
1276 boost::shared_ptr<PluginInsert> pi;
1278 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
1279 if (pi->is_generator()) {
1280 _have_internal_generator = true;
1287 /* now try to do what we need to so that those that were removed will be deleted */
1289 for (ProcessorList::iterator i = deleted.begin(); i != deleted.end(); ++i) {
1290 (*i)->drop_references ();
1293 processors_changed (); /* EMIT SIGNAL */
1300 Route::configure_processors (ProcessorStreams* err)
1302 if (!_in_configure_processors) {
1303 Glib::RWLock::WriterLock lm (_processor_lock);
1304 return configure_processors_unlocked (err);
1309 /** Configure the input/output configuration of each processor in the processors list.
1310 * Return 0 on success, otherwise configuration is impossible.
1313 Route::configure_processors_unlocked (ProcessorStreams* err)
1315 if (_in_configure_processors) {
1319 _in_configure_processors = true;
1321 // Check each processor in order to see if we can configure as requested
1322 ChanCount in = _input->n_ports ();
1324 list< pair<ChanCount,ChanCount> > configuration;
1327 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++index) {
1328 if ((*p)->can_support_io_configuration(in, out)) {
1329 configuration.push_back(make_pair(in, out));
1336 _in_configure_processors = false;
1341 // We can, so configure everything
1342 list< pair<ChanCount,ChanCount> >::iterator c = configuration.begin();
1343 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p, ++c) {
1344 (*p)->configure_io(c->first, c->second);
1345 processor_max_streams = ChanCount::max(processor_max_streams, c->first);
1346 processor_max_streams = ChanCount::max(processor_max_streams, c->second);
1350 // Ensure route outputs match last processor's outputs
1351 if (out != _output->n_ports ()) {
1352 _output->ensure_io (out, false, this);
1355 _in_configure_processors = false;
1360 Route::all_processors_flip ()
1362 Glib::RWLock::ReaderLock lm (_processor_lock);
1364 if (_processors.empty()) {
1368 bool first_is_on = _processors.front()->active();
1370 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1372 (*i)->deactivate ();
1378 _session.set_dirty ();
1381 /** Set all processors with a given placement to a given active state.
1382 * @param p Placement of processors to change.
1383 * @param state New active state for those processors.
1386 Route::all_processors_active (Placement p, bool state)
1388 Glib::RWLock::ReaderLock lm (_processor_lock);
1390 if (_processors.empty()) {
1393 ProcessorList::iterator start, end;
1394 placement_range(p, start, end);
1396 bool before_amp = true;
1397 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1402 if (p == PreFader && before_amp) {
1406 (*i)->deactivate ();
1411 _session.set_dirty ();
1415 Route::processor_is_prefader (boost::shared_ptr<Processor> p)
1417 bool pre_fader = true;
1418 Glib::RWLock::ReaderLock lm (_processor_lock);
1420 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1422 /* semantic note: if p == amp, we want to return true, so test
1423 for equality before checking if this is the amp
1440 Route::reorder_processors (const ProcessorList& new_order, ProcessorStreams* err)
1442 /* "new_order" is an ordered list of processors to be positioned according to "placement".
1443 NOTE: all processors in "new_order" MUST be marked as visible. There maybe additional
1444 processors in the current actual processor list that are hidden. Any visible processors
1445 in the current list but not in "new_order" will be assumed to be deleted.
1449 Glib::RWLock::WriterLock lm (_processor_lock);
1450 ChanCount old_pms = processor_max_streams;
1451 ProcessorList::iterator oiter;
1452 ProcessorList::const_iterator niter;
1453 ProcessorList as_it_was_before = _processors;
1454 ProcessorList as_it_will_be;
1456 oiter = _processors.begin();
1457 niter = new_order.begin();
1459 while (niter != new_order.end()) {
1461 /* if the next processor in the old list is invisible (i.e. should not be in the new order)
1462 then append it to the temp list.
1464 Otherwise, see if the next processor in the old list is in the new list. if not,
1465 its been deleted. If its there, append it to the temp list.
1468 if (oiter == _processors.end()) {
1470 /* no more elements in the old list, so just stick the rest of
1471 the new order onto the temp list.
1474 as_it_will_be.insert (as_it_will_be.end(), niter, new_order.end());
1475 while (niter != new_order.end()) {
1482 if (!(*oiter)->visible()) {
1484 as_it_will_be.push_back (*oiter);
1488 /* visible processor: check that its in the new order */
1490 if (find (new_order.begin(), new_order.end(), (*oiter)) == new_order.end()) {
1491 /* deleted: do nothing, shared_ptr<> will clean up */
1493 /* ignore this one, and add the next item from the new order instead */
1494 as_it_will_be.push_back (*niter);
1499 /* now remove from old order - its taken care of no matter what */
1500 oiter = _processors.erase (oiter);
1505 _processors.insert (oiter, as_it_will_be.begin(), as_it_will_be.end());
1507 if (configure_processors_unlocked (err)) {
1508 _processors = as_it_was_before;
1509 processor_max_streams = old_pms;
1514 processors_changed (); /* EMIT SIGNAL */
1526 Route::get_template()
1528 return state(false);
1532 Route::state(bool full_state)
1534 XMLNode *node = new XMLNode("Route");
1535 ProcessorList::iterator i;
1538 id().print (buf, sizeof (buf));
1539 node->add_property("id", buf);
1540 node->add_property ("name", _name);
1541 node->add_property("default-type", _default_type.to_string());
1544 node->add_property("flags", enum_2_string (_flags));
1547 node->add_property("active", _active?"yes":"no");
1548 node->add_property("phase-invert", _phase_invert?"yes":"no");
1549 node->add_property("denormal-protection", _denormal_protection?"yes":"no");
1550 node->add_property("meter-point", enum_2_string (_meter_point));
1553 node->add_property("route-group", _route_group->name());
1556 string order_string;
1557 OrderKeys::iterator x = order_keys.begin();
1559 while (x != order_keys.end()) {
1560 order_string += string ((*x).first);
1561 order_string += '=';
1562 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1563 order_string += buf;
1567 if (x == order_keys.end()) {
1571 order_string += ':';
1573 node->add_property ("order-keys", order_string);
1575 node->add_child_nocopy (_input->state (full_state));
1576 node->add_child_nocopy (_output->state (full_state));
1577 node->add_child_nocopy (_solo_control->get_state ());
1578 node->add_child_nocopy (_mute_master->get_state ());
1580 XMLNode* remote_control_node = new XMLNode (X_("RemoteControl"));
1581 snprintf (buf, sizeof (buf), "%d", _remote_control_id);
1582 remote_control_node->add_property (X_("id"), buf);
1583 node->add_child_nocopy (*remote_control_node);
1585 if (_comment.length()) {
1586 XMLNode *cmt = node->add_child ("Comment");
1587 cmt->add_content (_comment);
1590 for (i = _processors.begin(); i != _processors.end(); ++i) {
1591 node->add_child_nocopy((*i)->state (full_state));
1595 node->add_child_copy (*_extra_xml);
1602 Route::set_state (const XMLNode& node)
1604 return _set_state (node, true);
1608 Route::_set_state (const XMLNode& node, bool /*call_base*/)
1612 XMLNodeConstIterator niter;
1614 XMLPropertyList plist;
1615 const XMLProperty *prop;
1617 if (node.name() != "Route"){
1618 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1622 if ((prop = node.property (X_("name"))) != 0) {
1623 Route::set_name (prop->value());
1626 if ((prop = node.property ("id")) != 0) {
1627 _id = prop->value ();
1630 if ((prop = node.property (X_("flags"))) != 0) {
1631 _flags = Flag (string_2_enum (prop->value(), _flags));
1636 /* add all processors (except amp, which is always present) */
1638 nlist = node.children();
1639 XMLNode processor_state (X_("processor_state"));
1641 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1645 if (child->name() == IO::state_node_name) {
1646 if ((prop = child->property (X_("direction"))) == 0) {
1650 if (prop->value() == "Input") {
1651 _input->set_state (*child);
1652 } else if (prop->value() == "Output") {
1653 _output->set_state (*child);
1657 if (child->name() == X_("Processor")) {
1658 processor_state.add_child_copy (*child);
1662 set_processor_state (processor_state);
1664 if ((prop = node.property ("solo_level")) != 0) {
1665 _solo_level = 0; // needed for mod_solo_level() to work
1666 mod_solo_level (atoi (prop->value()));
1669 if ((prop = node.property ("solo-isolated")) != 0) {
1670 set_solo_isolated (prop->value() == "yes", this);
1673 if ((prop = node.property (X_("phase-invert"))) != 0) {
1674 set_phase_invert (prop->value()=="yes"?true:false);
1677 if ((prop = node.property (X_("denormal-protection"))) != 0) {
1678 set_denormal_protection (prop->value()=="yes"?true:false);
1681 if ((prop = node.property (X_("active"))) != 0) {
1682 bool yn = (prop->value() == "yes");
1683 _active = !yn; // force switch
1687 if ((prop = node.property (X_("soloed"))) != 0) {
1688 bool yn = (prop->value()=="yes");
1690 /* XXX force reset of solo status */
1692 set_solo (yn, this);
1695 if ((prop = node.property (X_("meter-point"))) != 0) {
1696 _meter_point = MeterPoint (string_2_enum (prop->value (), _meter_point));
1699 if ((prop = node.property (X_("route-group"))) != 0) {
1700 RouteGroup* route_group = _session.route_group_by_name(prop->value());
1701 if (route_group == 0) {
1702 error << string_compose(_("Route %1: unknown route group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1704 set_route_group (route_group, this);
1708 if ((prop = node.property (X_("order-keys"))) != 0) {
1712 string::size_type colon, equal;
1713 string remaining = prop->value();
1715 while (remaining.length()) {
1717 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1718 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1721 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1722 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1725 set_order_key (remaining.substr (0, equal), n);
1729 colon = remaining.find_first_of (':');
1731 if (colon != string::npos) {
1732 remaining = remaining.substr (colon+1);
1739 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1742 if (child->name() == X_("Comment")) {
1744 /* XXX this is a terrible API design in libxml++ */
1746 XMLNode *cmt = *(child->children().begin());
1747 _comment = cmt->content();
1749 } else if (child->name() == X_("Extra")) {
1751 _extra_xml = new XMLNode (*child);
1753 } else if (child->name() == X_("Controllable") && (prop = child->property("name")) != 0) {
1755 if (prop->value() == "solo") {
1756 _solo_control->set_state (*child);
1757 _session.add_controllable (_solo_control);
1760 } else if (child->name() == X_("RemoteControl")) {
1761 if ((prop = child->property (X_("id"))) != 0) {
1763 sscanf (prop->value().c_str(), "%d", &x);
1764 set_remote_control_id (x);
1767 } else if (child->name() == X_("MuteMaster")) {
1768 _mute_master->set_state (*child);
1776 Route::get_processor_state ()
1778 XMLNode* root = new XMLNode (X_("redirects"));
1779 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1780 root->add_child_nocopy ((*i)->state (true));
1787 Route::set_processor_state (const XMLNode& node)
1789 const XMLNodeList &nlist = node.children();
1790 XMLNodeConstIterator niter;
1791 ProcessorList::iterator i, o;
1793 // Iterate through existing processors, remove those which are not in the state list
1795 for (i = _processors.begin(); i != _processors.end(); ) {
1797 /* leave amp alone, always */
1804 ProcessorList::iterator tmp = i;
1807 bool processorInStateList = false;
1809 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1811 XMLProperty* id_prop = (*niter)->property(X_("id"));
1813 if (id_prop && (*i)->id() == id_prop->value()) {
1814 processorInStateList = true;
1819 if (!processorInStateList) {
1820 remove_processor (*i);
1826 // Iterate through state list and make sure all processors are on the track and in the correct order,
1827 // set the state of existing processors according to the new state on the same go
1829 i = _processors.begin();
1831 for (niter = nlist.begin(); niter != nlist.end(); ++niter, ++i) {
1833 XMLProperty* prop = (*niter)->property ("type");
1837 // Check whether the next processor in the list is the right one,
1838 // except for "amp" which is always there and may not have the
1839 // old ID since it is always created anew in every Route
1841 if (prop->value() != "amp") {
1842 while (o != _processors.end()) {
1843 XMLProperty* id_prop = (*niter)->property(X_("id"));
1844 if (id_prop && (*o)->id() == id_prop->value()) {
1852 // If the processor (*niter) is not on the route,
1853 // create it and move it to the correct location
1855 if (o == _processors.end()) {
1857 if (add_processor_from_xml (**niter, i)) {
1858 --i; // move iterator to the newly inserted processor
1860 cerr << "Error restoring route: unable to restore processor" << endl;
1865 // Otherwise, the processor already exists; just
1866 // ensure it is at the location provided in the XML state
1869 boost::shared_ptr<Processor> tmp = (*o);
1870 _processors.erase (o); // remove the old copy
1871 _processors.insert (i, tmp); // insert the processor at the correct location
1872 --i; // move iterator to the correct processor
1875 // and make it (just) so
1877 (*i)->set_state (**niter);
1881 /* note: there is no configure_processors() call because we figure that
1882 the XML state represents a working signal route.
1885 processors_changed ();
1889 Route::curve_reallocate ()
1891 // _gain_automation_curve.finish_resize ();
1892 // _pan_automation_curve.finish_resize ();
1896 Route::silence (nframes_t nframes)
1900 _output->silence (nframes);
1903 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
1906 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1907 boost::shared_ptr<PluginInsert> pi;
1909 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
1910 // skip plugins, they don't need anything when we're not active
1914 (*i)->silence (nframes);
1917 if (nframes == _session.get_block_size()) {
1927 Route::add_internal_return ()
1930 _intreturn.reset (new InternalReturn (_session));
1931 add_processor (_intreturn, PreFader);
1936 Route::get_return_buffer () const
1938 Glib::RWLock::ReaderLock rm (_processor_lock);
1940 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
1941 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
1944 BufferSet* bs = d->get_buffers ();
1953 Route::release_return_buffer () const
1955 Glib::RWLock::ReaderLock rm (_processor_lock);
1957 for (ProcessorList::const_iterator x = _processors.begin(); x != _processors.end(); ++x) {
1958 boost::shared_ptr<InternalReturn> d = boost::dynamic_pointer_cast<InternalReturn>(*x);
1961 return d->release_buffers ();
1967 Route::listen_via (boost::shared_ptr<Route> route, Placement placement, bool /*active*/, bool aux)
1969 vector<string> ports;
1970 vector<string>::const_iterator i;
1973 Glib::RWLock::ReaderLock rm (_processor_lock);
1975 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ++x) {
1977 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
1979 if (d && d->target_route() == route) {
1981 /* if the target is the control outs, then make sure
1982 we take note of which i-send is doing that.
1985 if (route == _session.control_out()) {
1986 _control_outs = boost::dynamic_pointer_cast<Delivery>(d);
1989 /* already listening via the specified IO: do nothing */
1996 boost::shared_ptr<InternalSend> listener;
1999 listener.reset (new InternalSend (_session, _mute_master, route, (aux ? Delivery::Aux : Delivery::Listen)));
2001 } catch (failed_constructor& err) {
2005 if (route == _session.control_out()) {
2006 _control_outs = listener;
2009 add_processor (listener, placement);
2015 Route::drop_listen (boost::shared_ptr<Route> route)
2017 ProcessorStreams err;
2018 ProcessorList::iterator tmp;
2020 Glib::RWLock::ReaderLock rl(_processor_lock);
2024 for (ProcessorList::iterator x = _processors.begin(); x != _processors.end(); ) {
2026 boost::shared_ptr<InternalSend> d = boost::dynamic_pointer_cast<InternalSend>(*x);
2028 if (d && d->target_route() == route) {
2030 remove_processor (*x, &err);
2033 /* list could have been demolished while we dropped the lock
2043 if (route == _session.control_out()) {
2044 _control_outs.reset ();
2049 Route::set_route_group (RouteGroup *rg, void *src)
2051 if (rg == _route_group) {
2056 _route_group->remove (this);
2059 if ((_route_group = rg) != 0) {
2060 _route_group->add (this);
2063 _session.set_dirty ();
2064 route_group_changed (src); /* EMIT SIGNAL */
2068 Route::drop_route_group (void *src)
2071 _session.set_dirty ();
2072 route_group_changed (src); /* EMIT SIGNAL */
2076 Route::set_comment (string cmt, void *src)
2079 comment_changed (src);
2080 _session.set_dirty ();
2084 Route::feeds (boost::shared_ptr<Route> other)
2086 // cerr << _name << endl;
2088 if (_output->connected_to (other->input())) {
2089 // cerr << "\tdirect FEEDS " << other->name() << endl;
2093 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); r++) {
2095 boost::shared_ptr<IOProcessor> iop;
2097 if ((iop = boost::dynamic_pointer_cast<IOProcessor>(*r)) != 0) {
2098 if (iop->feeds (other)) {
2099 // cerr << "\tIOP " << iop->name() << " feeds " << other->name() << endl;
2102 // cerr << "\tIOP " << iop->name() << " does NOT feeds " << other->name() << endl;
2107 // cerr << "\tdoes NOT FEED " << other->name() << endl;
2112 Route::handle_transport_stopped (bool /*abort_ignored*/, bool did_locate, bool can_flush_processors)
2114 nframes_t now = _session.transport_frame();
2117 Glib::RWLock::ReaderLock lm (_processor_lock);
2120 automation_snapshot (now, true);
2123 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2125 if (Config->get_plugins_stop_with_transport() && can_flush_processors) {
2126 (*i)->deactivate ();
2130 (*i)->transport_stopped (now);
2134 _roll_delay = _initial_delay;
2138 Route::input_change_handler (IOChange change, void * /*src*/)
2140 if ((change & ConfigurationChanged)) {
2141 configure_processors (0);
2146 Route::output_change_handler (IOChange change, void * /*src*/)
2148 if ((change & ConfigurationChanged)) {
2150 /* XXX resize all listeners to match _main_outs? */
2152 // configure_processors (0);
2157 Route::pans_required () const
2159 if (n_outputs().n_audio() < 2) {
2163 return max (n_inputs ().n_audio(), processor_max_streams.n_audio());
2167 Route::no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
2168 bool session_state_changing, bool /*can_record*/, bool /*rec_monitors_input*/)
2170 if (n_outputs().n_total() == 0) {
2174 if (session_state_changing || !_active || n_inputs() == ChanCount::ZERO) {
2179 _amp->apply_gain_automation (false);
2180 passthru (start_frame, end_frame, nframes, 0);
2186 Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
2188 if (_roll_delay > nframes) {
2190 _roll_delay -= nframes;
2192 /* transport frame is not legal for caller to use */
2195 } else if (_roll_delay > 0) {
2197 nframes -= _roll_delay;
2198 silence (_roll_delay);
2199 /* we've written _roll_delay of samples into the
2200 output ports, so make a note of that for
2203 _main_outs->increment_output_offset (_roll_delay);
2204 transport_frame += _roll_delay;
2213 Route::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
2214 bool /*can_record*/, bool /*rec_monitors_input*/)
2217 // automation snapshot can also be called from the non-rt context
2218 // and it uses the processor list, so we try to acquire the lock here
2219 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
2222 automation_snapshot (_session.transport_frame(), false);
2226 if (n_outputs().n_total() == 0) {
2230 if (!_active || n_inputs().n_total() == 0) {
2235 nframes_t unused = 0;
2237 if ((nframes = check_initial_delay (nframes, unused)) == 0) {
2243 passthru (start_frame, end_frame, nframes, declick);
2249 Route::silent_roll (nframes_t nframes, sframes_t /*start_frame*/, sframes_t /*end_frame*/,
2250 bool /*can_record*/, bool /*rec_monitors_input*/)
2257 Route::toggle_monitor_input ()
2259 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
2260 i->ensure_monitor_input( ! i->monitoring_input());
2265 Route::has_external_redirects () const
2267 // FIXME: what about sends? - they don't return a signal back to ardour?
2269 boost::shared_ptr<const PortInsert> pi;
2271 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2273 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2275 for (PortSet::const_iterator port = pi->output()->ports().begin(); port != pi->output()->ports().end(); ++port) {
2277 string port_name = port->name();
2278 string client_name = port_name.substr (0, port_name.find(':'));
2280 /* only say "yes" if the redirect is actually in use */
2282 if (client_name != "ardour" && pi->active()) {
2293 Route::flush_processors ()
2295 /* XXX shouldn't really try to take this lock, since
2296 this is called from the RT audio thread.
2299 Glib::RWLock::ReaderLock lm (_processor_lock);
2301 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2302 (*i)->deactivate ();
2308 Route::set_meter_point (MeterPoint p, void *src)
2310 if (_meter_point != p) {
2313 // Move meter in the processors list
2314 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _meter);
2315 _processors.erase(loc);
2318 loc = _processors.begin();
2321 loc = find(_processors.begin(), _processors.end(), _amp);
2323 case MeterPostFader:
2324 loc = _processors.end();
2327 _processors.insert(loc, _meter);
2329 meter_change (src); /* EMIT SIGNAL */
2330 processors_changed (); /* EMIT SIGNAL */
2331 _session.set_dirty ();
2335 Route::put_control_outs_at (Placement p)
2337 if (!_control_outs) {
2341 // Move meter in the processors list
2342 ProcessorList::iterator loc = find(_processors.begin(), _processors.end(), _control_outs);
2343 _processors.erase(loc);
2347 loc = find(_processors.begin(), _processors.end(), _amp);
2348 if (loc != _processors.begin()) {
2353 loc = find(_processors.begin(), _processors.end(), _amp);
2354 assert (loc != _processors.end());
2359 _processors.insert(loc, _control_outs);
2361 processors_changed (); /* EMIT SIGNAL */
2362 _session.set_dirty ();
2366 Route::update_total_latency ()
2368 nframes_t old = _output->effective_latency();
2369 nframes_t own_latency = _output->user_latency();
2371 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2372 if ((*i)->active ()) {
2373 own_latency += (*i)->signal_latency ();
2377 #undef DEBUG_LATENCY
2378 #ifdef DEBUG_LATENCY
2379 cerr << _name << ": internal redirect latency = " << own_latency << endl;
2382 _output->set_port_latency (own_latency);
2384 if (_output->user_latency() == 0) {
2386 /* this (virtual) function is used for pure Routes,
2387 not derived classes like AudioTrack. this means
2388 that the data processed here comes from an input
2389 port, not prerecorded material, and therefore we
2390 have to take into account any input latency.
2393 own_latency += _input->signal_latency ();
2396 if (old != own_latency) {
2397 _output->set_latency_delay (own_latency);
2398 signal_latency_changed (); /* EMIT SIGNAL */
2401 #ifdef DEBUG_LATENCY
2402 cerr << _name << ": input latency = " << _input->signal_latency() << " total = "
2403 << own_latency << endl;
2406 return _output->effective_latency ();
2410 Route::set_user_latency (nframes_t nframes)
2412 _output->set_user_latency (nframes);
2413 _session.update_latency_compensation (false, false);
2417 Route::set_latency_delay (nframes_t longest_session_latency)
2419 nframes_t old = _initial_delay;
2421 if (_output->effective_latency() < longest_session_latency) {
2422 _initial_delay = longest_session_latency - _output->effective_latency();
2427 if (_initial_delay != old) {
2428 initial_delay_changed (); /* EMIT SIGNAL */
2431 if (_session.transport_stopped()) {
2432 _roll_delay = _initial_delay;
2437 Route::automation_snapshot (nframes_t now, bool force)
2439 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2440 (*i)->automation_snapshot (now, force);
2444 Route::SoloControllable::SoloControllable (std::string name, Route& r)
2445 : AutomationControl (r.session(), Evoral::Parameter (SoloAutomation),
2446 boost::shared_ptr<AutomationList>(), name)
2449 boost::shared_ptr<AutomationList> gl(new AutomationList(Evoral::Parameter(SoloAutomation)));
2454 Route::SoloControllable::set_value (float val)
2456 bool bval = ((val >= 0.5f) ? true: false);
2458 route.set_solo (bval, this);
2462 Route::SoloControllable::get_value (void) const
2464 return route.soloed() ? 1.0f : 0.0f;
2468 Route::set_block_size (nframes_t nframes)
2470 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2471 (*i)->set_block_size (nframes);
2473 _session.ensure_buffers(processor_max_streams);
2477 Route::protect_automation ()
2479 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i)
2480 (*i)->protect_automation();
2484 Route::set_pending_declick (int declick)
2487 /* this call is not allowed to turn off a pending declick unless "force" is true */
2489 _pending_declick = declick;
2491 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2493 _pending_declick = 0;
2498 /** Shift automation forwards from a particular place, thereby inserting time.
2499 * Adds undo commands for any shifts that are performed.
2501 * @param pos Position to start shifting from.
2502 * @param frames Amount to shift forwards by.
2506 Route::shift (nframes64_t /*pos*/, nframes64_t /*frames*/)
2508 #ifdef THIS_NEEDS_FIXING_FOR_V3
2510 /* gain automation */
2511 XMLNode &before = _gain_control->get_state ();
2512 _gain_control->shift (pos, frames);
2513 XMLNode &after = _gain_control->get_state ();
2514 _session.add_command (new MementoCommand<AutomationList> (_gain_automation_curve, &before, &after));
2516 /* pan automation */
2517 for (std::vector<StreamPanner*>::iterator i = _panner->begin (); i != _panner->end (); ++i) {
2518 Curve & c = (*i)->automation ();
2519 XMLNode &before = c.get_state ();
2520 c.shift (pos, frames);
2521 XMLNode &after = c.get_state ();
2522 _session.add_command (new MementoCommand<AutomationList> (c, &before, &after));
2525 /* redirect automation */
2527 Glib::RWLock::ReaderLock lm (redirect_lock);
2528 for (RedirectList::iterator i = _redirects.begin (); i != _redirects.end (); ++i) {
2531 (*i)->what_has_automation (a);
2533 for (set<uint32_t>::const_iterator j = a.begin (); j != a.end (); ++j) {
2534 AutomationList & al = (*i)->automation_list (*j);
2535 XMLNode &before = al.get_state ();
2536 al.shift (pos, frames);
2537 XMLNode &after = al.get_state ();
2538 _session.add_command (new MementoCommand<AutomationList> (al, &before, &after));
2548 Route::save_as_template (const string& path, const string& name)
2550 XMLNode& node (state (false));
2553 IO::set_name_in_state (*node.children().front(), name);
2555 tree.set_root (&node);
2556 return tree.write (path.c_str());
2561 Route::set_name (const string& str)
2567 name = Route::ensure_track_or_route_name (str, _session);
2568 SessionObject::set_name (name);
2570 ret = (_input->set_name(name) && _output->set_name(name));
2574 Glib::RWLock::ReaderLock lm (_processor_lock);
2576 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2578 /* rename all I/O processors that have inputs or outputs */
2580 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
2582 if (iop && (iop->output() || iop->input())) {
2583 if (!iop->set_name (name)) {
2594 boost::shared_ptr<Send>
2595 Route::internal_send_for (boost::shared_ptr<const Route> target) const
2597 Glib::RWLock::ReaderLock lm (_processor_lock);
2599 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
2600 boost::shared_ptr<InternalSend> send;
2602 if ((send = boost::dynamic_pointer_cast<InternalSend>(*i)) != 0) {
2603 if (send->target_route() == target) {
2609 return boost::shared_ptr<Send>();
2613 Route::set_phase_invert (bool yn)
2615 if (_phase_invert != yn) {
2616 _phase_invert = 0xffff; // XXX all channels
2617 phase_invert_changed (); /* EMIT SIGNAL */
2622 Route::phase_invert () const
2624 return _phase_invert != 0;
2628 Route::set_denormal_protection (bool yn)
2630 if (_denormal_protection != yn) {
2631 _denormal_protection = yn;
2632 denormal_protection_changed (); /* EMIT SIGNAL */
2637 Route::denormal_protection () const
2639 return _denormal_protection;
2643 Route::set_active (bool yn)
2645 if (_active != yn) {
2647 _input->set_active (yn);
2648 _output->set_active (yn);
2649 active_changed (); // EMIT SIGNAL
2656 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2662 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2664 boost::shared_ptr<Send> s;
2665 boost::shared_ptr<Return> r;
2667 if ((s = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
2668 s->meter()->meter();
2669 } else if ((r = boost::dynamic_pointer_cast<Return> (*i)) != 0) {
2670 r->meter()->meter ();
2675 boost::shared_ptr<Panner>
2676 Route::panner() const
2679 return _main_outs->panner();
2682 boost::shared_ptr<AutomationControl>
2683 Route::gain_control() const
2686 return _amp->gain_control();
2689 boost::shared_ptr<AutomationControl>
2690 Route::get_control (const Evoral::Parameter& param)
2692 /* either we own the control or .... */
2694 boost::shared_ptr<AutomationControl> c = boost::dynamic_pointer_cast<AutomationControl>(data().control (param));
2698 /* maybe one of our processors does or ... */
2700 Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
2701 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
2702 if ((c = boost::dynamic_pointer_cast<AutomationControl>((*i)->data().control (param))) != 0) {
2710 /* nobody does so we'll make a new one */
2712 c = boost::dynamic_pointer_cast<AutomationControl>(control_factory(param));