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>
28 #include <ardour/timestamps.h>
29 #include <ardour/buffer.h>
30 #include <ardour/audioengine.h>
31 #include <ardour/route.h>
32 #include <ardour/insert.h>
33 #include <ardour/send.h>
34 #include <ardour/session.h>
35 #include <ardour/utils.h>
36 #include <ardour/configuration.h>
37 #include <ardour/cycle_timer.h>
38 #include <ardour/route_group.h>
39 #include <ardour/port.h>
40 #include <ardour/ladspa_plugin.h>
41 #include <ardour/panner.h>
42 #include <ardour/dB.h>
43 #include <ardour/mix.h>
48 using namespace ARDOUR;
52 uint32_t Route::order_key_cnt = 0;
55 Route::Route (Session& sess, string name, int input_min, int input_max, int output_min, int output_max, Flag flg, DataType default_type)
56 : IO (sess, name, input_min, input_max, output_min, output_max, default_type),
58 _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
59 _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
64 Route::Route (Session& sess, const XMLNode& node)
66 _solo_control (X_("solo"), *this, ToggleControllable::SoloControl),
67 _mute_control (X_("mute"), *this, ToggleControllable::MuteControl)
76 redirect_max_outs = 0;
80 _phase_invert = false;
81 order_keys[N_("signal")] = order_key_cnt++;
84 _meter_point = MeterPostFader;
88 _have_internal_generator = false;
90 _pending_declick = true;
91 _remote_control_id = 0;
96 _mute_affects_pre_fader = Config->get_mute_affects_pre_fader();
97 _mute_affects_post_fader = Config->get_mute_affects_post_fader();
98 _mute_affects_control_outs = Config->get_mute_affects_control_outs();
99 _mute_affects_main_outs = Config->get_mute_affects_main_outs();
102 desired_solo_gain = 1.0;
104 desired_mute_gain = 1.0;
108 input_changed.connect (mem_fun (this, &Route::input_change_handler));
109 output_changed.connect (mem_fun (this, &Route::output_change_handler));
114 clear_redirects (this);
117 delete _control_outs;
122 Route::set_remote_control_id (uint32_t id)
124 if (id != _remote_control_id) {
125 _remote_control_id = id;
126 RemoteControlIDChanged ();
131 Route::remote_control_id() const
133 return _remote_control_id;
137 Route::order_key (string name) const
139 OrderKeys::const_iterator i;
141 if ((i = order_keys.find (name)) == order_keys.end()) {
149 Route::set_order_key (string name, long n)
151 order_keys[name] = n;
152 _session.set_dirty ();
156 Route::inc_gain (gain_t fraction, void *src)
158 IO::inc_gain (fraction, src);
162 Route::set_gain (gain_t val, void *src)
164 if (src != 0 && _mix_group && src != _mix_group && _mix_group->is_active()) {
166 if (_mix_group->is_relative()) {
169 gain_t usable_gain = gain();
170 if (usable_gain < 0.000001f) {
171 usable_gain=0.000001f;
175 if (delta < 0.000001f) {
179 delta -= usable_gain;
181 if (delta == 0.0f) return;
183 gain_t factor = delta / usable_gain;
186 factor = _mix_group->get_max_factor(factor);
187 if (factor == 0.0f) {
192 factor = _mix_group->get_min_factor(factor);
193 if (factor == 0.0f) {
199 _mix_group->apply (&Route::inc_gain, factor, _mix_group);
203 _mix_group->apply (&Route::set_gain, val, _mix_group);
213 IO::set_gain (val, src);
217 Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
218 nframes_t start_frame, nframes_t end_frame,
219 nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
223 RedirectList::iterator i;
224 bool post_fader_work = false;
225 bool mute_declick_applied = false;
227 vector<Sample*>::iterator bufiter;
232 gain_t* gab = _session.gain_automation_buffer();
234 switch (Config->get_monitoring_model()) {
235 case HardwareMonitoring:
236 case ExternalMonitoring:
243 declick = _pending_declick;
246 Glib::Mutex::Lock cm (control_outs_lock, Glib::TRY_LOCK);
256 Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
259 dmg = desired_mute_gain;
260 dsg = desired_solo_gain;
269 /* ----------------------------------------------------------------------------------------------------
270 GLOBAL DECLICK (for transport changes etc.)
271 -------------------------------------------------------------------------------------------------- */
274 apply_declick (bufs, nbufs, nframes, 0.0, 1.0, false);
275 _pending_declick = 0;
276 } else if (declick < 0) {
277 apply_declick (bufs, nbufs, nframes, 1.0, 0.0, false);
278 _pending_declick = 0;
281 /* no global declick */
283 if (solo_gain != dsg) {
284 apply_declick (bufs, nbufs, nframes, solo_gain, dsg, false);
290 /* ----------------------------------------------------------------------------------------------------
291 INPUT METERING & MONITORING
292 -------------------------------------------------------------------------------------------------- */
294 if (meter && (_meter_point == MeterInput)) {
295 for (n = 0; n < nbufs; ++n) {
296 _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
300 if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
301 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
303 mute_declick_applied = true;
306 if ((_meter_point == MeterInput) && co) {
308 solo_audible = dsg > 0;
309 mute_audible = dmg > 0;// || !_mute_affects_pre_fader;
311 if ( // muted by solo of another track
315 // muted by mute of this track
319 // rec-enabled but not s/w monitoring
321 // TODO: this is probably wrong
323 (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
327 co->silence (nframes, offset);
331 co->deliver_output (bufs, nbufs, nframes, offset);
336 /* ----------------------------------------------------------------------------------------------------
338 -------------------------------------------------------------------------------------------------- */
340 if (with_redirects) {
341 Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
343 if (mute_gain > 0 || !_mute_affects_pre_fader) {
344 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
345 switch ((*i)->placement()) {
347 (*i)->run (bufs, nbufs, nframes, offset);
350 post_fader_work = true;
355 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
356 switch ((*i)->placement()) {
358 (*i)->silence (nframes, offset);
361 post_fader_work = true;
370 if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_post_fader) {
371 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
373 mute_declick_applied = true;
376 /* ----------------------------------------------------------------------------------------------------
377 PRE-FADER METERING & MONITORING
378 -------------------------------------------------------------------------------------------------- */
380 if (meter && (_meter_point == MeterPreFader)) {
381 for (n = 0; n < nbufs; ++n) {
382 _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
387 if ((_meter_point == MeterPreFader) && co) {
389 solo_audible = dsg > 0;
390 mute_audible = dmg > 0 || !_mute_affects_pre_fader;
392 if ( // muted by solo of another track
396 // muted by mute of this track
400 // rec-enabled but not s/w monitoring
402 (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
406 co->silence (nframes, offset);
410 co->deliver_output (bufs, nbufs, nframes, offset);
415 /* ----------------------------------------------------------------------------------------------------
417 -------------------------------------------------------------------------------------------------- */
419 /* if not recording or recording and requiring any monitor signal, then apply gain */
421 if ( // not recording
423 !(record_enabled() && _session.actively_recording()) ||
427 // h/w monitoring not in use
429 (!Config->get_monitoring_model() == HardwareMonitoring &&
431 // AND software monitoring required
433 Config->get_monitoring_model() == SoftwareMonitoring)) {
435 if (apply_gain_automation) {
438 for (n = 0; n < nbufs; ++n) {
439 Sample *sp = bufs[n];
441 for (nframes_t nx = 0; nx < nframes; ++nx) {
446 for (n = 0; n < nbufs; ++n) {
447 Sample *sp = bufs[n];
449 for (nframes_t nx = 0; nx < nframes; ++nx) {
455 if (apply_gain_automation && _session.transport_rolling() && nframes > 0) {
456 _effective_gain = gab[nframes-1];
461 /* manual (scalar) gain */
465 apply_declick (bufs, nbufs, nframes, _gain, dg, _phase_invert);
468 } else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
470 /* no need to interpolate current gain value,
471 but its non-unity, so apply it. if the gain
472 is zero, do nothing because we'll ship silence
484 for (n = 0; n < nbufs; ++n) {
485 Sample *sp = bufs[n];
486 apply_gain_to_buffer(sp,nframes,this_gain);
489 } else if (_gain == 0) {
490 for (n = 0; n < nbufs; ++n) {
491 memset (bufs[n], 0, sizeof (Sample) * nframes);
498 /* actively recording, no monitoring required; leave buffers as-is to save CPU cycles */
502 /* ----------------------------------------------------------------------------------------------------
504 -------------------------------------------------------------------------------------------------- */
506 /* note that post_fader_work cannot be true unless with_redirects was also true, so don't test both */
508 if (post_fader_work) {
510 Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
512 if (mute_gain > 0 || !_mute_affects_post_fader) {
513 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
514 switch ((*i)->placement()) {
518 (*i)->run (bufs, nbufs, nframes, offset);
523 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
524 switch ((*i)->placement()) {
528 (*i)->silence (nframes, offset);
536 if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
537 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
539 mute_declick_applied = true;
542 /* ----------------------------------------------------------------------------------------------------
544 -------------------------------------------------------------------------------------------------- */
546 if ((_meter_point == MeterPostFader) && co) {
548 solo_audible = solo_gain > 0;
549 mute_audible = dmg > 0 || !_mute_affects_control_outs;
551 if ( // silent anyway
553 (_gain == 0 && !apply_gain_automation) ||
555 // muted by solo of another track
559 // muted by mute of this track
563 // recording but not s/w monitoring
565 (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
569 co->silence (nframes, offset);
573 co->deliver_output_no_pan (bufs, nbufs, nframes, offset);
577 /* ----------------------------------------------------------------------
579 ----------------------------------------------------------------------*/
581 if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
582 apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
584 mute_declick_applied = true;
587 /* ----------------------------------------------------------------------------------------------------
589 -------------------------------------------------------------------------------------------------- */
591 solo_audible = dsg > 0;
592 mute_audible = dmg > 0 || !_mute_affects_main_outs;
594 if (n_outputs() == 0) {
598 } else if (no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording())) {
600 IO::silence (nframes, offset);
604 if ( // silent anyway
606 (_gain == 0 && !apply_gain_automation) ||
608 // muted by solo of another track, but not using control outs for solo
610 (!solo_audible && (Config->get_solo_model() != SoloBus)) ||
612 // muted by mute of this track
618 /* don't use Route::silence() here, because that causes
619 all outputs (sends, port inserts, etc. to be silent).
622 if (_meter_point == MeterPostFader) {
623 reset_peak_meters ();
626 IO::silence (nframes, offset);
630 if (_session.transport_speed() > 1.5f || _session.transport_speed() < -1.5f) {
631 pan (bufs, nbufs, nframes, offset, speed_quietning);
633 // cerr << _name << " panner state = " << _panner->automation_state() << endl;
634 if (!_panner->empty() &&
635 (_panner->automation_state() & Play ||
636 ((_panner->automation_state() & Touch) && !_panner->touching()))) {
637 pan_automated (bufs, nbufs, start_frame, end_frame, nframes, offset);
639 pan (bufs, nbufs, nframes, offset, 1.0);
646 /* ----------------------------------------------------------------------------------------------------
648 -------------------------------------------------------------------------------------------------- */
650 if (meter && (_meter_point == MeterPostFader)) {
651 // cerr << "meter post" << endl;
653 if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
654 uint32_t no = n_outputs();
655 for (n = 0; n < no; ++n) {
659 uint32_t no = n_outputs();
660 for (n = 0; n < no; ++n) {
661 _peak_power[n] = Session::compute_peak (output(n)->get_buffer (nframes) + offset, nframes, _peak_power[n]);
668 Route::n_process_buffers ()
670 return max (n_inputs(), redirect_max_outs);
675 Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
677 vector<Sample*>& bufs = _session.get_passthru_buffers();
678 uint32_t limit = n_process_buffers ();
682 collect_input (bufs, limit, nframes, offset);
684 #define meter_stream meter_first
687 for (uint32_t n = 0; n < limit; ++n) {
688 _peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
690 meter_stream = false;
695 process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
701 Route::set_phase_invert (bool yn, void *src)
703 if (_phase_invert != yn) {
706 // phase_invert_changed (src); /* EMIT SIGNAL */
710 Route::set_solo (bool yn, void *src)
716 if (_mix_group && src != _mix_group && _mix_group->is_active()) {
717 _mix_group->apply (&Route::set_solo, yn, _mix_group);
723 solo_changed (src); /* EMIT SIGNAL */
724 _solo_control.Changed (); /* EMIT SIGNAL */
729 Route::set_solo_mute (bool yn)
731 Glib::Mutex::Lock lm (declick_lock);
733 /* Called by Session in response to another Route being soloed.
736 desired_solo_gain = (yn?0.0:1.0);
740 Route::set_solo_safe (bool yn, void *src)
742 if (_solo_safe != yn) {
744 solo_safe_changed (src); /* EMIT SIGNAL */
749 Route::set_mute (bool yn, void *src)
752 if (_mix_group && src != _mix_group && _mix_group->is_active()) {
753 _mix_group->apply (&Route::set_mute, yn, _mix_group);
759 mute_changed (src); /* EMIT SIGNAL */
761 _mute_control.Changed (); /* EMIT SIGNAL */
763 Glib::Mutex::Lock lm (declick_lock);
764 desired_mute_gain = (yn?0.0f:1.0f);
769 Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
771 uint32_t old_rmo = redirect_max_outs;
773 if (!_session.engine().connected()) {
778 Glib::RWLock::WriterLock lm (redirect_lock);
780 boost::shared_ptr<PluginInsert> pi;
781 boost::shared_ptr<PortInsert> porti;
783 uint32_t potential_max_streams = 0;
785 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(redirect)) != 0) {
788 if (pi->input_streams() == 0) {
789 /* instrument plugin */
790 _have_internal_generator = true;
793 potential_max_streams = max(pi->input_streams(), pi->output_streams());
795 } else if ((porti = boost::dynamic_pointer_cast<PortInsert>(redirect)) != 0) {
797 /* force new port inserts to start out with an i/o configuration
798 that matches this route's i/o configuration.
800 the "inputs" for the port are supposed to match the output
803 the "outputs" of the route should match the inputs of this
804 route. XXX shouldn't they match the number of active signal
805 streams at the point of insertion?
809 porti->ensure_io (n_outputs (), n_inputs(), false, this);
812 // Ensure peak vector sizes before the plugin is activated
813 while (_peak_power.size() < potential_max_streams) {
814 _peak_power.push_back(0);
816 while (_visible_peak_power.size() < potential_max_streams) {
817 _visible_peak_power.push_back(0);
820 _redirects.push_back (redirect);
822 if (_reset_plugin_counts (err_streams)) {
823 _redirects.pop_back ();
824 _reset_plugin_counts (0); // it worked before we tried to add it ...
828 redirect->activate ();
829 redirect->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
832 if (redirect_max_outs != old_rmo || old_rmo == 0) {
837 redirects_changed (src); /* EMIT SIGNAL */
842 Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_streams)
844 uint32_t old_rmo = redirect_max_outs;
846 if (!_session.engine().connected()) {
851 Glib::RWLock::WriterLock lm (redirect_lock);
853 RedirectList::iterator existing_end = _redirects.end();
856 uint32_t potential_max_streams = 0;
858 for (RedirectList::const_iterator i = others.begin(); i != others.end(); ++i) {
860 boost::shared_ptr<PluginInsert> pi;
862 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
865 uint32_t m = max(pi->input_streams(), pi->output_streams());
866 if (m > potential_max_streams)
867 potential_max_streams = m;
870 // Ensure peak vector sizes before the plugin is activated
871 while (_peak_power.size() < potential_max_streams) {
872 _peak_power.push_back(0);
874 while (_visible_peak_power.size() < potential_max_streams) {
875 _visible_peak_power.push_back(0);
878 _redirects.push_back (*i);
880 if (_reset_plugin_counts (err_streams)) {
882 _redirects.erase (existing_end, _redirects.end());
883 _reset_plugin_counts (0); // it worked before we tried to add it ...
888 (*i)->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
892 if (redirect_max_outs != old_rmo || old_rmo == 0) {
896 redirects_changed (src); /* EMIT SIGNAL */
901 Route::clear_redirects (void *src)
903 uint32_t old_rmo = redirect_max_outs;
905 if (!_session.engine().connected()) {
910 Glib::RWLock::WriterLock lm (redirect_lock);
914 if (redirect_max_outs != old_rmo) {
918 redirect_max_outs = 0;
919 _have_internal_generator = false;
920 redirects_changed (src); /* EMIT SIGNAL */
924 Route::remove_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
926 uint32_t old_rmo = redirect_max_outs;
928 if (!_session.engine().connected()) {
932 redirect_max_outs = 0;
935 Glib::RWLock::WriterLock lm (redirect_lock);
936 RedirectList::iterator i;
937 bool removed = false;
939 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
940 if (*i == redirect) {
942 RedirectList::iterator tmp;
944 /* move along, see failure case for reset_plugin_counts()
945 where we may need to reinsert the redirect.
951 /* stop redirects that send signals to JACK ports
952 from causing noise as a result of no longer being
956 boost::shared_ptr<Send> send;
957 boost::shared_ptr<PortInsert> port_insert;
959 if ((send = boost::dynamic_pointer_cast<Send> (*i)) != 0) {
960 send->disconnect_inputs (this);
961 send->disconnect_outputs (this);
962 } else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (*i)) != 0) {
963 port_insert->disconnect_inputs (this);
964 port_insert->disconnect_outputs (this);
967 _redirects.erase (i);
980 if (_reset_plugin_counts (err_streams)) {
981 /* get back to where we where */
982 _redirects.insert (i, redirect);
983 /* we know this will work, because it worked before :) */
984 _reset_plugin_counts (0);
990 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
991 boost::shared_ptr<PluginInsert> pi;
993 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
994 if (pi->is_generator()) {
1000 _have_internal_generator = foo;
1003 if (old_rmo != redirect_max_outs) {
1007 redirects_changed (src); /* EMIT SIGNAL */
1012 Route::reset_plugin_counts (uint32_t* lpc)
1014 Glib::RWLock::WriterLock lm (redirect_lock);
1015 return _reset_plugin_counts (lpc);
1020 Route::_reset_plugin_counts (uint32_t* err_streams)
1022 RedirectList::iterator r;
1025 map<Placement,list<InsertCount> > insert_map;
1026 nframes_t initial_streams;
1028 redirect_max_outs = 0;
1032 /* divide inserts up by placement so we get the signal flow
1033 properly modelled. we need to do this because the _redirects
1034 list is not sorted by placement, and because other reasons may
1035 exist now or in the future for this separate treatment.
1038 for (r = _redirects.begin(); r != _redirects.end(); ++r) {
1040 boost::shared_ptr<Insert> insert;
1042 /* do this here in case we bomb out before we get to the end of
1046 redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
1048 if ((insert = boost::dynamic_pointer_cast<Insert>(*r)) != 0) {
1050 insert_map[insert->placement()].push_back (InsertCount (insert));
1052 /* reset plugin counts back to one for now so
1053 that we have a predictable, controlled
1054 state to try to configure.
1057 boost::shared_ptr<PluginInsert> pi;
1059 if ((pi = boost::dynamic_pointer_cast<PluginInsert>(insert)) != 0) {
1063 } else if (boost::dynamic_pointer_cast<Send> (*r) != 0) {
1076 /* Now process each placement in order, checking to see if we
1077 can really do what has been requested.
1082 if (check_some_plugin_counts (insert_map[PreFader], n_inputs (), err_streams)) {
1086 /* figure out the streams that will feed into PreFader */
1088 if (!insert_map[PreFader].empty()) {
1089 InsertCount& ic (insert_map[PreFader].back());
1090 initial_streams = ic.insert->compute_output_streams (ic.cnt);
1092 initial_streams = n_inputs ();
1097 if (check_some_plugin_counts (insert_map[PostFader], initial_streams, err_streams)) {
1101 /* OK, everything can be set up correctly, so lets do it */
1103 apply_some_plugin_counts (insert_map[PreFader]);
1104 apply_some_plugin_counts (insert_map[PostFader]);
1106 /* recompute max outs of any redirect */
1110 redirect_max_outs = 0;
1111 RedirectList::iterator prev = _redirects.end();
1113 for (r = _redirects.begin(); r != _redirects.end(); prev = r, ++r) {
1114 boost::shared_ptr<Send> s;
1116 if ((s = boost::dynamic_pointer_cast<Send> (*r)) != 0) {
1117 if (r == _redirects.begin()) {
1118 s->expect_inputs (n_inputs());
1120 s->expect_inputs ((*prev)->output_streams());
1124 redirect_max_outs = max ((*r)->output_streams (), redirect_max_outs);
1133 Route::apply_some_plugin_counts (list<InsertCount>& iclist)
1135 list<InsertCount>::iterator i;
1137 for (i = iclist.begin(); i != iclist.end(); ++i) {
1139 if ((*i).insert->configure_io ((*i).cnt, (*i).in, (*i).out)) {
1142 /* make sure that however many we have, they are all active */
1143 (*i).insert->activate ();
1150 Route::check_some_plugin_counts (list<InsertCount>& iclist, int32_t required_inputs, uint32_t* err_streams)
1152 list<InsertCount>::iterator i;
1154 for (i = iclist.begin(); i != iclist.end(); ++i) {
1156 if (((*i).cnt = (*i).insert->can_support_input_configuration (required_inputs)) < 0) {
1158 *err_streams = required_inputs;
1163 (*i).in = required_inputs;
1164 (*i).out = (*i).insert->compute_output_streams ((*i).cnt);
1166 required_inputs = (*i).out;
1173 Route::copy_redirects (const Route& other, Placement placement, uint32_t* err_streams)
1175 uint32_t old_rmo = redirect_max_outs;
1181 RedirectList to_be_deleted;
1184 Glib::RWLock::WriterLock lm (redirect_lock);
1185 RedirectList::iterator tmp;
1186 RedirectList the_copy;
1188 the_copy = _redirects;
1190 /* remove all relevant redirects */
1192 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
1196 if ((*i)->placement() == placement) {
1197 to_be_deleted.push_back (*i);
1198 _redirects.erase (i);
1204 /* now copy the relevant ones from "other" */
1206 for (RedirectList::const_iterator i = other._redirects.begin(); i != other._redirects.end(); ++i) {
1207 if ((*i)->placement() == placement) {
1208 _redirects.push_back (Redirect::clone (*i));
1212 /* reset plugin stream handling */
1214 if (_reset_plugin_counts (err_streams)) {
1216 /* FAILED COPY ATTEMPT: we have to restore order */
1218 /* delete all cloned redirects */
1220 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ) {
1225 if ((*i)->placement() == placement) {
1226 _redirects.erase (i);
1232 /* restore the natural order */
1234 _redirects = the_copy;
1235 redirect_max_outs = old_rmo;
1237 /* we failed, even though things are OK again */
1243 /* SUCCESSFUL COPY ATTEMPT: delete the redirects we removed pre-copy */
1244 to_be_deleted.clear ();
1248 if (redirect_max_outs != old_rmo || old_rmo == 0) {
1252 redirects_changed (this); /* EMIT SIGNAL */
1257 Route::all_redirects_flip ()
1259 Glib::RWLock::ReaderLock lm (redirect_lock);
1261 if (_redirects.empty()) {
1265 bool first_is_on = _redirects.front()->active();
1267 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1268 (*i)->set_active (!first_is_on, this);
1273 Route::all_redirects_active (bool state)
1275 Glib::RWLock::ReaderLock lm (redirect_lock);
1277 if (_redirects.empty()) {
1281 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1282 (*i)->set_active (state, this);
1286 struct RedirectSorter {
1287 bool operator() (boost::shared_ptr<const Redirect> a, boost::shared_ptr<const Redirect> b) {
1288 return a->sort_key() < b->sort_key();
1293 Route::sort_redirects (uint32_t* err_streams)
1296 RedirectSorter comparator;
1297 Glib::RWLock::WriterLock lm (redirect_lock);
1298 uint32_t old_rmo = redirect_max_outs;
1300 /* the sweet power of C++ ... */
1302 RedirectList as_it_was_before = _redirects;
1304 _redirects.sort (comparator);
1306 if (_reset_plugin_counts (err_streams)) {
1307 _redirects = as_it_was_before;
1308 redirect_max_outs = old_rmo;
1314 redirects_changed (this); /* EMIT SIGNAL */
1326 Route::get_template()
1328 return state(false);
1332 Route::state(bool full_state)
1334 XMLNode *node = new XMLNode("Route");
1336 RedirectList:: iterator i;
1340 snprintf (buf, sizeof (buf), "0x%x", _flags);
1341 node->add_property("flags", buf);
1344 node->add_property("default-type", _default_type.to_string());
1346 node->add_property("active", _active?"yes":"no");
1347 node->add_property("muted", _muted?"yes":"no");
1348 node->add_property("soloed", _soloed?"yes":"no");
1349 node->add_property("phase-invert", _phase_invert?"yes":"no");
1350 node->add_property("mute-affects-pre-fader", _mute_affects_pre_fader?"yes":"no");
1351 node->add_property("mute-affects-post-fader", _mute_affects_post_fader?"yes":"no");
1352 node->add_property("mute-affects-control-outs", _mute_affects_control_outs?"yes":"no");
1353 node->add_property("mute-affects-main-outs", _mute_affects_main_outs?"yes":"no");
1356 node->add_property("edit-group", _edit_group->name());
1359 node->add_property("mix-group", _mix_group->name());
1362 string order_string;
1363 OrderKeys::iterator x = order_keys.begin();
1365 while (x != order_keys.end()) {
1366 order_string += (*x).first;
1367 order_string += '=';
1368 snprintf (buf, sizeof(buf), "%ld", (*x).second);
1369 order_string += buf;
1373 if (x == order_keys.end()) {
1377 order_string += ':';
1379 node->add_property ("order-keys", order_string);
1381 node->add_child_nocopy (IO::state (full_state));
1382 node->add_child_nocopy (_solo_control.get_state ());
1383 node->add_child_nocopy (_mute_control.get_state ());
1385 if (_control_outs) {
1386 XMLNode* cnode = new XMLNode (X_("ControlOuts"));
1387 cnode->add_child_nocopy (_control_outs->state (full_state));
1388 node->add_child_nocopy (*cnode);
1391 if (_comment.length()) {
1392 XMLNode *cmt = node->add_child ("Comment");
1393 cmt->add_content (_comment);
1399 path = _session.snap_name();
1401 path += legalize_for_path (_name);
1402 path += ".automation";
1404 /* XXX we didn't ask for a state save, we asked for the current state.
1408 if (save_automation (path)) {
1409 error << _("Could not get state of route. Problem with save_automation") << endmsg;
1412 aevents = node->add_child ("Automation");
1413 aevents->add_property ("path", path);
1416 for (i = _redirects.begin(); i != _redirects.end(); ++i) {
1417 node->add_child_nocopy((*i)->state (full_state));
1421 node->add_child_copy (*_extra_xml);
1428 Route::set_deferred_state ()
1431 XMLNodeConstIterator niter;
1433 if (!deferred_state) {
1437 nlist = deferred_state->children();
1439 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1440 add_redirect_from_xml (**niter);
1443 delete deferred_state;
1448 Route::add_redirect_from_xml (const XMLNode& node)
1450 const XMLProperty *prop;
1452 if (node.name() == "Send") {
1456 boost::shared_ptr<Send> send (new Send (_session, node));
1457 add_redirect (send, this);
1460 catch (failed_constructor &err) {
1461 error << _("Send construction failed") << endmsg;
1465 } else if (node.name() == "Insert") {
1468 if ((prop = node.property ("type")) != 0) {
1470 boost::shared_ptr<Insert> insert;
1472 if (prop->value() == "ladspa" || prop->value() == "Ladspa" || prop->value() == "vst") {
1474 insert.reset (new PluginInsert(_session, node));
1476 } else if (prop->value() == "port") {
1479 insert.reset (new PortInsert (_session, node));
1483 error << string_compose(_("unknown Insert type \"%1\"; ignored"), prop->value()) << endmsg;
1486 add_redirect (insert, this);
1489 error << _("Insert XML node has no type property") << endmsg;
1493 catch (failed_constructor &err) {
1494 warning << _("insert could not be created. Ignored.") << endmsg;
1501 Route::set_state (const XMLNode& node)
1504 XMLNodeConstIterator niter;
1506 XMLPropertyList plist;
1507 const XMLProperty *prop;
1509 if (node.name() != "Route"){
1510 error << string_compose(_("Bad node sent to Route::set_state() [%1]"), node.name()) << endmsg;
1514 if ((prop = node.property ("flags")) != 0) {
1516 sscanf (prop->value().c_str(), "0x%x", &x);
1522 if ((prop = node.property ("default-type")) != 0) {
1523 _default_type = DataType(prop->value());
1524 assert(_default_type != DataType::NIL);
1527 if ((prop = node.property ("phase-invert")) != 0) {
1528 set_phase_invert(prop->value()=="yes"?true:false, this);
1531 if ((prop = node.property ("active")) != 0) {
1532 set_active (prop->value() == "yes");
1535 if ((prop = node.property ("muted")) != 0) {
1536 bool yn = prop->value()=="yes"?true:false;
1538 /* force reset of mute status */
1542 mute_gain = desired_mute_gain;
1545 if ((prop = node.property ("soloed")) != 0) {
1546 bool yn = prop->value()=="yes"?true:false;
1548 /* force reset of solo status */
1551 set_solo (yn, this);
1552 solo_gain = desired_solo_gain;
1555 if ((prop = node.property ("mute-affects-pre-fader")) != 0) {
1556 _mute_affects_pre_fader = (prop->value()=="yes")?true:false;
1559 if ((prop = node.property ("mute-affects-post-fader")) != 0) {
1560 _mute_affects_post_fader = (prop->value()=="yes")?true:false;
1563 if ((prop = node.property ("mute-affects-control-outs")) != 0) {
1564 _mute_affects_control_outs = (prop->value()=="yes")?true:false;
1567 if ((prop = node.property ("mute-affects-main-outs")) != 0) {
1568 _mute_affects_main_outs = (prop->value()=="yes")?true:false;
1571 if ((prop = node.property ("edit-group")) != 0) {
1572 RouteGroup* edit_group = _session.edit_group_by_name(prop->value());
1573 if(edit_group == 0) {
1574 error << string_compose(_("Route %1: unknown edit group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1576 set_edit_group(edit_group, this);
1580 if ((prop = node.property ("order-keys")) != 0) {
1584 string::size_type colon, equal;
1585 string remaining = prop->value();
1587 while (remaining.length()) {
1589 if ((equal = remaining.find_first_of ('=')) == string::npos || equal == remaining.length()) {
1590 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1593 if (sscanf (remaining.substr (equal+1).c_str(), "%ld", &n) != 1) {
1594 error << string_compose (_("badly formed order key string in state file! [%1] ... ignored."), remaining)
1597 set_order_key (remaining.substr (0, equal), n);
1601 colon = remaining.find_first_of (':');
1603 if (colon != string::npos) {
1604 remaining = remaining.substr (colon+1);
1611 nlist = node.children();
1613 if (deferred_state) {
1614 delete deferred_state;
1617 deferred_state = new XMLNode("deferred state");
1619 /* set parent class properties before anything else */
1621 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1625 if (child->name() == IO::state_node_name) {
1627 IO::set_state (*child);
1632 for (niter = nlist.begin(); niter != nlist.end(); ++niter){
1636 if (child->name() == "Send") {
1639 if (!IO::ports_legal) {
1641 deferred_state->add_child_copy (*child);
1644 add_redirect_from_xml (*child);
1647 } else if (child->name() == "Insert") {
1649 if (!IO::ports_legal) {
1651 deferred_state->add_child_copy (*child);
1655 add_redirect_from_xml (*child);
1658 } else if (child->name() == "Automation") {
1660 XMLPropertyList plist;
1661 XMLPropertyConstIterator piter;
1664 plist = child->properties();
1665 for (piter = plist.begin(); piter != plist.end(); ++piter) {
1667 if (prop->name() == "path") {
1668 load_automation (prop->value());
1672 } else if (child->name() == "ControlOuts") {
1674 string coutname = _name;
1675 coutname += _("[control]");
1677 _control_outs = new IO (_session, coutname);
1678 _control_outs->set_state (**(child->children().begin()));
1680 } else if (child->name() == "Comment") {
1682 /* XXX this is a terrible API design in libxml++ */
1684 XMLNode *cmt = *(child->children().begin());
1685 _comment = cmt->content();
1687 } else if (child->name() == "extra") {
1688 _extra_xml = new XMLNode (*child);
1689 } else if (child->name() == "solo") {
1690 _solo_control.set_state (*child);
1691 _session.add_controllable (&_solo_control);
1692 } else if (child->name() == "mute") {
1693 _mute_control.set_state (*child);
1694 _session.add_controllable (&_mute_control);
1698 if ((prop = node.property ("mix-group")) != 0) {
1699 RouteGroup* mix_group = _session.mix_group_by_name(prop->value());
1700 if (mix_group == 0) {
1701 error << string_compose(_("Route %1: unknown mix group \"%2 in saved state (ignored)"), _name, prop->value()) << endmsg;
1703 set_mix_group(mix_group, this);
1711 Route::curve_reallocate ()
1713 // _gain_automation_curve.finish_resize ();
1714 // _pan_automation_curve.finish_resize ();
1718 Route::silence (nframes_t nframes, nframes_t offset)
1722 // reset_peak_meters ();
1724 IO::silence (nframes, offset);
1726 if (_control_outs) {
1727 _control_outs->silence (nframes, offset);
1731 Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
1734 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1735 boost::shared_ptr<PluginInsert> pi;
1736 if (!_active && (pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
1737 // skip plugins, they don't need anything when we're not active
1741 (*i)->silence (nframes, offset);
1744 if (nframes == _session.get_block_size() && offset == 0) {
1754 Route::set_control_outs (const vector<string>& ports)
1756 Glib::Mutex::Lock lm (control_outs_lock);
1757 vector<string>::const_iterator i;
1759 if (_control_outs) {
1760 delete _control_outs;
1764 if (ports.empty()) {
1768 string coutname = _name;
1769 coutname += _("[control]");
1771 _control_outs = new IO (_session, coutname);
1773 /* our control outs need as many outputs as we
1774 have outputs. we track the changes in ::output_change_handler().
1777 _control_outs->ensure_io (0, n_outputs(), true, this);
1783 Route::set_edit_group (RouteGroup *eg, void *src)
1786 if (eg == _edit_group) {
1791 _edit_group->remove (this);
1794 if ((_edit_group = eg) != 0) {
1795 _edit_group->add (this);
1798 _session.set_dirty ();
1799 edit_group_changed (src); /* EMIT SIGNAL */
1803 Route::drop_edit_group (void *src)
1806 _session.set_dirty ();
1807 edit_group_changed (src); /* EMIT SIGNAL */
1811 Route::set_mix_group (RouteGroup *mg, void *src)
1814 if (mg == _mix_group) {
1819 _mix_group->remove (this);
1822 if ((_mix_group = mg) != 0) {
1823 _mix_group->add (this);
1826 _session.set_dirty ();
1827 mix_group_changed (src); /* EMIT SIGNAL */
1831 Route::drop_mix_group (void *src)
1834 _session.set_dirty ();
1835 mix_group_changed (src); /* EMIT SIGNAL */
1839 Route::set_comment (string cmt, void *src)
1842 comment_changed (src);
1843 _session.set_dirty ();
1847 Route::feeds (boost::shared_ptr<Route> other)
1852 uint32_t no = self.n_outputs();
1853 uint32_t ni = other->n_inputs ();
1855 for (i = 0; i < no; ++i) {
1856 for (j = 0; j < ni; ++j) {
1857 if (self.output(i)->connected_to (other->input(j)->name())) {
1863 /* check Redirects which may also interconnect Routes */
1865 for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); r++) {
1867 no = (*r)->n_outputs();
1869 for (i = 0; i < no; ++i) {
1870 for (j = 0; j < ni; ++j) {
1871 if ((*r)->output(i)->connected_to (other->input (j)->name())) {
1878 /* check for control room outputs which may also interconnect Routes */
1880 if (_control_outs) {
1882 no = _control_outs->n_outputs();
1884 for (i = 0; i < no; ++i) {
1885 for (j = 0; j < ni; ++j) {
1886 if (_control_outs->output(i)->connected_to (other->input (j)->name())) {
1897 Route::set_mute_config (mute_type t, bool onoff, void *src)
1901 _mute_affects_pre_fader = onoff;
1902 pre_fader_changed(src); /* EMIT SIGNAL */
1906 _mute_affects_post_fader = onoff;
1907 post_fader_changed(src); /* EMIT SIGNAL */
1911 _mute_affects_control_outs = onoff;
1912 control_outs_changed(src); /* EMIT SIGNAL */
1916 _mute_affects_main_outs = onoff;
1917 main_outs_changed(src); /* EMIT SIGNAL */
1923 Route::get_mute_config (mute_type t)
1929 onoff = _mute_affects_pre_fader;
1932 onoff = _mute_affects_post_fader;
1935 onoff = _mute_affects_control_outs;
1938 onoff = _mute_affects_main_outs;
1946 Route::set_active (bool yn)
1949 active_changed(); /* EMIT SIGNAL */
1953 Route::handle_transport_stopped (bool abort_ignored, bool did_locate, bool can_flush_redirects)
1955 nframes_t now = _session.transport_frame();
1958 Glib::RWLock::ReaderLock lm (redirect_lock);
1961 automation_snapshot (now);
1964 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
1966 if (Config->get_plugins_stop_with_transport() && can_flush_redirects) {
1967 (*i)->deactivate ();
1971 (*i)->transport_stopped (now);
1975 IO::transport_stopped (now);
1977 _roll_delay = _initial_delay;
1981 Route::get_memento() const
1983 void (Route::*pmf)(state_id_t) = &Route::set_state;
1984 return sigc::bind (mem_fun (*(const_cast<Route *>(this)), pmf), _current_state_id);
1988 Route::set_state (state_id_t id)
1994 Route::input_change_handler (IOChange change, void *ignored)
1996 if (change & ConfigurationChanged) {
1997 reset_plugin_counts (0);
2002 Route::output_change_handler (IOChange change, void *ignored)
2004 if (change & ConfigurationChanged) {
2005 if (_control_outs) {
2006 _control_outs->ensure_io (0, n_outputs(), true, this);
2009 reset_plugin_counts (0);
2014 Route::pans_required () const
2016 if (n_outputs() < 2) {
2020 return max (n_inputs (), redirect_max_outs);
2024 Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2025 bool session_state_changing, bool can_record, bool rec_monitors_input)
2027 if (n_outputs() == 0) {
2031 if (session_state_changing || !_active) {
2032 silence (nframes, offset);
2036 apply_gain_automation = false;
2039 passthru (start_frame, end_frame, nframes, offset, 0, false);
2041 silence (nframes, offset);
2048 Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
2050 if (_roll_delay > nframes) {
2052 _roll_delay -= nframes;
2053 silence (nframes, offset);
2054 /* transport frame is not legal for caller to use */
2057 } else if (_roll_delay > 0) {
2059 nframes -= _roll_delay;
2061 silence (_roll_delay, offset);
2063 offset += _roll_delay;
2064 transport_frame += _roll_delay;
2073 Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
2074 bool can_record, bool rec_monitors_input)
2077 Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
2079 // automation snapshot can also be called from the non-rt context
2080 // and it uses the redirect list, so we take the lock out here
2081 automation_snapshot (_session.transport_frame());
2085 if ((n_outputs() == 0 && _redirects.empty()) || n_inputs() == 0 || !_active) {
2086 silence (nframes, offset);
2090 nframes_t unused = 0;
2092 if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
2098 apply_gain_automation = false;
2101 Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
2103 if (am.locked() && _session.transport_rolling()) {
2105 nframes_t start_frame = end_frame - nframes;
2107 if (gain_automation_playback()) {
2108 apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
2113 passthru (start_frame, end_frame, nframes, offset, declick, false);
2119 Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
2120 bool can_record, bool rec_monitors_input)
2122 silence (nframes, offset);
2127 Route::toggle_monitor_input ()
2129 for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
2130 (*i)->ensure_monitor_input(!(*i)->monitoring_input());
2135 Route::has_external_redirects () const
2137 boost::shared_ptr<const PortInsert> pi;
2139 for (RedirectList::const_iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2140 if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
2142 uint32_t no = pi->n_outputs();
2144 for (uint32_t n = 0; n < no; ++n) {
2146 string port_name = pi->output(n)->name();
2147 string client_name = port_name.substr (0, port_name.find(':'));
2149 /* only say "yes" if the redirect is actually in use */
2151 if (client_name != "ardour" && pi->active()) {
2162 Route::flush_redirects ()
2164 /* XXX shouldn't really try to take this lock, since
2165 this is called from the RT audio thread.
2168 Glib::RWLock::ReaderLock lm (redirect_lock);
2170 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2171 (*i)->deactivate ();
2177 Route::set_meter_point (MeterPoint p, void *src)
2179 if (_meter_point != p) {
2181 meter_change (src); /* EMIT SIGNAL */
2182 _session.set_dirty ();
2187 Route::update_total_latency ()
2191 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2192 if ((*i)->active ()) {
2193 _own_latency += (*i)->latency ();
2197 set_port_latency (_own_latency);
2199 /* this (virtual) function is used for pure Routes,
2200 not derived classes like AudioTrack. this means
2201 that the data processed here comes from an input
2202 port, not prerecorded material, and therefore we
2203 have to take into account any input latency.
2206 _own_latency += input_latency ();
2208 return _own_latency;
2212 Route::set_latency_delay (nframes_t longest_session_latency)
2214 _initial_delay = longest_session_latency - _own_latency;
2216 if (_session.transport_stopped()) {
2217 _roll_delay = _initial_delay;
2222 Route::automation_snapshot (nframes_t now)
2224 IO::automation_snapshot (now);
2226 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2227 (*i)->automation_snapshot (now);
2231 Route::ToggleControllable::ToggleControllable (std::string name, Route& s, ToggleType tp)
2232 : Controllable (name), route (s), type(tp)
2238 Route::ToggleControllable::set_value (float val)
2240 bool bval = ((val >= 0.5f) ? true: false);
2244 route.set_mute (bval, this);
2247 route.set_solo (bval, this);
2255 Route::ToggleControllable::get_value (void) const
2261 val = route.muted() ? 1.0f : 0.0f;
2264 val = route.soloed() ? 1.0f : 0.0f;
2274 Route::set_block_size (nframes_t nframes)
2276 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2277 (*i)->set_block_size (nframes);
2282 Route::redirect_active_proxy (Redirect* ignored, void* ignored_src)
2284 _session.update_latency_compensation (false, false);
2288 Route::protect_automation ()
2290 switch (gain_automation_state()) {
2293 set_gain_automation_state (Off);
2299 switch (panner().automation_state ()) {
2302 panner().set_automation_state (Off);
2308 for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
2309 boost::shared_ptr<PluginInsert> pi;
2310 if ((pi = boost::dynamic_pointer_cast<PluginInsert> (*i)) != 0) {
2311 pi->protect_automation ();
2317 Route::set_pending_declick (int declick)
2320 /* this call is not allowed to turn off a pending declick unless "force" is true */
2322 _pending_declick = declick;
2324 // cerr << _name << ": after setting to " << declick << " pending declick = " << _pending_declick << endl;
2326 _pending_declick = 0;