, _maps_from_state (false)
, _latency_changed (false)
, _bypass_port (UINT32_MAX)
+ , _stat_reset (0)
{
/* the first is the master */
return false;
}
std::ostringstream n;
- if (n_audio > 0 || n_midi > 0) {
- n << "Sidechain " << Session::next_name_id ();
- } else {
+ if (n_audio == 0 && n_midi == 0) {
n << "TO BE RESET FROM XML";
+ } else if (owner()) {
+ n << "SC " << owner()->name() << "/" << name() << " " << Session::next_name_id ();
+ } else {
+ n << "tobeRenamed";
}
SideChain *sc = new SideChain (_session, n.str ());
_sidechain = boost::shared_ptr<SideChain> (sc);
}
void
-PluginInsert::set_sidechain_latency (uint32_t capture, uint32_t playback)
+PluginInsert::update_sidechain_name ()
{
- if (_sidechain &&
- (_sc_playback_latency != playback || _sc_capture_latency != capture)) {
- _sc_capture_latency = capture;
- _sc_playback_latency = playback;
- LatencyRange pl; pl.min = pl.max = playback;
- LatencyRange cl; cl.min = cl.max = capture;
- DEBUG_TRACE (DEBUG::Latency, string_compose ("%1: capture %2 playback; %3\n", _sidechain->name (), capture, playback));
- PortSet& ps (_sidechain->input ()->ports ());
- for (PortSet::iterator p = ps.begin(); p != ps.end(); ++p) {
- p->set_private_latency_range (pl, true);
- p->set_private_latency_range (cl, false);
- }
+ if (!_sidechain) {
+ return;
}
+
+ std::ostringstream n;
+
+ n << "SC ";
+ if (owner()) {
+ n << owner()->name() << "/";
+ }
+
+ n << name() << " " << Session::next_name_id ();
+
+ _sidechain->set_name (n.str());
}
void
= boost::dynamic_pointer_cast<AutomationControl>(control (which));
if (c && s != Off) {
- _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_frame()));
+ _plugins[0]->set_parameter (which.id(), c->list()->eval (_session.transport_sample()));
}
}
return _plugins[0]->get_info()->n_inputs.n_audio() == 0;
}
-framecnt_t
+samplecnt_t
PluginInsert::plugin_latency () const {
return _plugins.front()->signal_latency ();
}
PluginInsert::is_instrument() const
{
PluginInfoPtr pip = _plugins[0]->get_info();
- if (pip->is_instrument ()) {
- return true;
- }
- return pip->n_inputs.n_midi () != 0 && pip->n_outputs.n_audio () > 0 && pip->n_inputs.n_audio () == 0;
+ return (pip->is_instrument ());
}
bool
boost::shared_ptr<Plugin> plugin = _plugins.front();
set<Evoral::Parameter> a = _plugins.front()->automatable ();
+ const uint32_t limit_automatables = Config->get_limit_n_automatables ();
+
for (uint32_t i = 0; i < plugin->parameter_count(); ++i) {
if (!plugin->parameter_is_control (i)) {
continue;
const bool automatable = a.find(param) != a.end();
- if (automatable) {
- can_automate (param);
- }
boost::shared_ptr<AutomationList> list(new AutomationList(param, desc));
boost::shared_ptr<AutomationControl> c (new PluginControl(this, param, desc, list));
- if (!automatable) {
+ if (!automatable || (limit_automatables > 0 && i > limit_automatables)) {
c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
}
add_control (c);
if (Variant::type_is_numeric(desc.datatype)) {
list = boost::shared_ptr<AutomationList>(new AutomationList(param, desc));
}
- add_control (boost::shared_ptr<AutomationControl> (new PluginPropertyControl(this, param, desc, list)));
+ boost::shared_ptr<AutomationControl> c (new PluginPropertyControl(this, param, desc, list));
+ if (!Variant::type_is_numeric(desc.datatype)) {
+ c->set_flags (Controllable::Flag ((int)c->flags() | Controllable::NotAutomatable));
+ }
+ add_control (c);
}
}
return ret;
}
+void
+PluginInsert::automation_run (samplepos_t start, pframes_t nframes, bool only_active)
+{
+ // XXX does not work when rolling backwards
+ if (_loop_location && nframes > 0) {
+ const samplepos_t loop_start = _loop_location->start ();
+ const samplepos_t loop_end = _loop_location->end ();
+ const samplecnt_t looplen = loop_end - loop_start;
+
+ samplecnt_t remain = nframes;
+ samplepos_t start_pos = start;
+
+ while (remain > 0) {
+ if (start_pos >= loop_end) {
+ sampleoffset_t start_off = (start_pos - loop_start) % looplen;
+ start_pos = loop_start + start_off;
+ }
+ samplecnt_t move = std::min ((samplecnt_t)nframes, loop_end - start_pos);
+
+ Automatable::automation_run (start_pos, move, only_active);
+ remain -= move;
+ start_pos += move;
+ }
+ return;
+ }
+ Automatable::automation_run (start, nframes, only_active);
+}
+
+bool
+PluginInsert::find_next_event (double now, double end, Evoral::ControlEvent& next_event, bool only_active) const
+{
+ bool rv = Automatable::find_next_event (now, end, next_event, only_active);
+
+ if (_loop_location && now < end) {
+ if (rv) {
+ end = ceil (next_event.when);
+ }
+ const samplepos_t loop_end = _loop_location->end ();
+ assert (now < loop_end); // due to map_loop_range ()
+ if (end > loop_end) {
+ next_event.when = loop_end;
+ rv = true;
+ }
+ }
+ return rv;
+}
+
void
PluginInsert::activate ()
{
+ _timing_stats.reset ();
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
(*i)->activate ();
}
void
PluginInsert::deactivate ()
{
+#ifdef MIXBUS
+ if (is_nonbypassable ()) {
+ return;
+ }
+#endif
+ _timing_stats.reset ();
Processor::deactivate ();
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
BypassableChanged ();
}
+bool
+PluginInsert::write_immediate_event (size_t size, const uint8_t* buf)
+{
+ bool rv = true;
+ for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
+ if (!(*i)->write_immediate_event (size, buf)) {
+ rv = false;
+ }
+ }
+ return rv;
+}
+
void
PluginInsert::preset_load_set_value (uint32_t p, float v)
{
}
void
-PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, framecnt_t nframes, framecnt_t offset) const
+PluginInsert::inplace_silence_unconnected (BufferSet& bufs, const PinMappings& out_map, samplecnt_t nframes, samplecnt_t offset) const
{
// TODO optimize: store "unconnected" in a fixed set.
// it only changes on reconfiguration.
}
void
-PluginInsert::connect_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes, framecnt_t offset, bool with_auto)
+PluginInsert::connect_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes, samplecnt_t offset, bool with_auto)
{
- // TODO: atomically copy maps & _no_inplace
- PinMappings in_map (_in_map);
- PinMappings out_map (_out_map);
- ChanMapping thru_map (_thru_map);
- if (_mapping_changed) { // ToDo use a counters, increment until match.
+ if (_mapping_changed) { // ToDo use a counter, increment until match
_no_inplace = check_inplace ();
_mapping_changed = false;
}
+ // TODO: atomically copy maps & _no_inplace
+ PinMappings in_map (_in_map); // TODO Split case below overrides, use const& in_map
+ PinMappings const& out_map (_out_map);
+ ChanMapping const& thru_map (_thru_map);
if (_latency_changed) {
/* delaylines are configured with the max possible latency (as reported by the plugin)
continue;
}
bool valid;
- uint32_t first_idx = in_map[0].get (*t, 0, &valid);
+ uint32_t first_idx = in_map.p(0).get (*t, 0, &valid);
assert (valid && first_idx == 0); // check_inplace ensures this
/* copy the first stream's buffer contents to the others */
for (uint32_t i = 1; i < natural_input_streams ().get (*t); ++i) {
- uint32_t idx = in_map[0].get (*t, i, &valid);
+ uint32_t idx = in_map.p(0).get (*t, i, &valid);
if (valid) {
assert (idx == 0);
bufs.get (*t, i).read_from (bufs.get (*t, first_idx), nframes, offset, offset);
if (with_auto) {
+#if 0
uint32_t n = 0;
- for (Controls::iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
-
- boost::shared_ptr<AutomationControl> c
- = boost::dynamic_pointer_cast<AutomationControl>(li->second);
+ for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
- if (c->list() && c->automation_playback()) {
+ /* boost::dynamic_pointer_cast<> has significant overhead, since we know that
+ * all controls are AutomationControl and their lists - if any - are AutomationList,
+ * we can use static_cast<>. This yields a speedup of 2.8/4.6 over to the
+ * previous code (measuerd with VeeSeeVSTRack 10k parameters, optimized build) */
+ AutomationControl& c = static_cast<AutomationControl&> (*(li->second));
+ boost::shared_ptr<const Evoral::ControlList> clist (c.list());
+ if (clist && (static_cast<AutomationList const&> (*clist)).automation_playback ()) {
bool valid;
-
- const float val = c->list()->rt_safe_eval (start, valid);
-
+ const float val = c.list()->rt_safe_eval (start, valid);
if (valid) {
- /* This is the ONLY place where we are
- * allowed to call
- * AutomationControl::set_value_unchecked(). We
- * know that the control is in
- * automation playback mode, so no
- * check on writable() is required
- * (which must be done in AutomationControl::set_value()
- *
- */
- c->set_value_unchecked(val);
+ c.set_value_unchecked(val);
}
-
}
}
+#else
+ boost::shared_ptr<ControlList> cl = _automated_controls.reader ();
+ for (ControlList::const_iterator ci = cl->begin(); ci != cl->end(); ++ci) {
+ AutomationControl& c = *(ci->get());
+ boost::shared_ptr<const Evoral::ControlList> clist (c.list());
+ /* we still need to check for Touch and Latch */
+ if (clist && (static_cast<AutomationList const&> (*clist)).automation_playback ()) {
+ bool valid;
+ const float val = c.list()->rt_safe_eval (start, valid);
+ if (valid) {
+ c.set_value_unchecked(val);
+ }
+ }
+ }
+#endif
}
- /* Calculate if, and how many frames we need to collect for analysis */
- framecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
+ /* Calculate if, and how many samples we need to collect for analysis */
+ samplecnt_t collect_signal_nframes = (_signal_analysis_collect_nframes_max -
_signal_analysis_collected_nframes);
- if (nframes < collect_signal_nframes) { // we might not get all frames now
+ if (nframes < collect_signal_nframes) { // we might not get all samples now
collect_signal_nframes = nframes;
}
// collect input
//std::cerr << "collect input, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
//std::cerr << " streams " << internal_input_streams().n_audio() << std::endl;
- //std::cerr << "filling buffer with " << collect_signal_nframes << " frames at " << _signal_analysis_collected_nframes << std::endl;
+ //std::cerr << "filling buffer with " << collect_signal_nframes << " samples at " << _signal_analysis_collected_nframes << std::endl;
- _signal_analysis_inputs.set_count(input_streams());
+ _signal_analysis_inputs.set_count (ChanCount (DataType::AUDIO, input_streams().n_audio()));
for (uint32_t i = 0; i < input_streams().n_audio(); ++i) {
_signal_analysis_inputs.get_audio(i).read_from (
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
for (uint32_t out = 0; out < natural_output_streams().get (*t); ++out) {
bool valid;
- uint32_t out_idx = out_map[pc].get (*t, out, &valid);
+ uint32_t out_idx = out_map.p(pc).get (*t, out, &valid);
if (valid) {
used_outputs.set (*t, out_idx, 1); // mark as used
}
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
ARDOUR::ChanMapping i_in_map (natural_input_streams());
- ARDOUR::ChanMapping i_out_map (out_map[pc]);
+ ARDOUR::ChanMapping i_out_map (out_map.p(pc));
ARDOUR::ChanCount mapped;
/* map inputs sequentially */
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
for (uint32_t in = 0; in < natural_input_streams().get (*t); ++in) {
bool valid;
- uint32_t in_idx = in_map[pc].get (*t, in, &valid);
+ uint32_t in_idx = in_map.p(pc).get (*t, in, &valid);
uint32_t m = mapped.get (*t);
if (valid) {
inplace_bufs.get (*t, m).read_from (bufs.get (*t, in_idx), nframes, offset, offset);
/* in-place processing */
uint32_t pc = 0;
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i, ++pc) {
- if ((*i)->connect_and_run(bufs, start, end, speed, in_map[pc], out_map[pc], nframes, offset)) {
+ if ((*i)->connect_and_run(bufs, start, end, speed, in_map.p(pc), out_map.p(pc), nframes, offset)) {
deactivate ();
}
}
//std::cerr << " output, bufs " << bufs.count().n_audio() << " count, " << bufs.available().n_audio() << " available" << std::endl;
//std::cerr << " streams " << internal_output_streams().n_audio() << std::endl;
- _signal_analysis_outputs.set_count(output_streams());
+ _signal_analysis_outputs.set_count (ChanCount (DataType::AUDIO, output_streams().n_audio()));
for (uint32_t i = 0; i < output_streams().n_audio(); ++i) {
_signal_analysis_outputs.get_audio(i).read_from(
/* bypass the plugin(s) not the whole processor.
* -> use mappings just like connect_and_run
*/
-
- // TODO: atomically copy maps & _no_inplace
- const ChanMapping in_map (no_sc_input_map ());
- const ChanMapping out_map (output_map ());
if (_mapping_changed) {
_no_inplace = check_inplace ();
_mapping_changed = false;
}
+ // TODO: atomically copy maps & _no_inplace
+ ChanMapping const& in_map (no_sc_input_map ());
+ ChanMapping const& out_map (output_map ());
bufs.set_count(ChanCount::max(bufs.count(), _configured_internal));
bufs.set_count(ChanCount::max(bufs.count(), _configured_out));
}
void
-PluginInsert::silence (framecnt_t nframes, framepos_t start_frame)
+PluginInsert::silence (samplecnt_t nframes, samplepos_t start_sample)
{
- automation_run (start_frame, nframes); // evaluate automation only
+ automation_run (start_sample, nframes, true); // evaluate automation only
if (!active ()) {
// XXX delaybuffers need to be offset by nframes
_delaybuffers.flush ();
- ChanMapping in_map (natural_input_streams ());
- ChanMapping out_map (natural_output_streams ());
+ const ChanMapping in_map (natural_input_streams ());
+ const ChanMapping out_map (natural_output_streams ());
ChanCount maxbuf = ChanCount::max (natural_input_streams (), natural_output_streams());
#ifdef MIXBUS
if (is_channelstrip ()) {
if (_configured_in.n_audio() > 0) {
- _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
+ _plugins.front()->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0);
}
} else
#endif
for (Plugins::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
- (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_frame, start_frame + nframes, 1.0, in_map, out_map, nframes, 0);
+ (*i)->connect_and_run (_session.get_scratch_buffers (maxbuf, true), start_sample, start_sample + nframes, 1.0, in_map, out_map, nframes, 0);
}
}
void
-PluginInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, double speed, pframes_t nframes, bool)
+PluginInsert::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool)
{
if (_sidechain) {
// collect sidechain input for complete cycle (!)
// TODO we need delaylines here for latency compensation
- _sidechain->run (bufs, start_frame, end_frame, speed, nframes, true);
+ _sidechain->run (bufs, start_sample, end_sample, speed, nframes, true);
+ }
+
+ if (g_atomic_int_compare_and_exchange (&_stat_reset, 1, 0)) {
+ _timing_stats.reset ();
}
if (_pending_active) {
+#if defined MIXBUS && defined NDEBUG
+ if (!is_channelstrip ()) {
+ _timing_stats.start ();
+ }
+#else
+ _timing_stats.start ();
+#endif
/* run as normal if we are active or moving from inactive to active */
if (_session.transport_rolling() || _session.bounce_processing()) {
- automate_and_run (bufs, start_frame, end_frame, speed, nframes);
+ automate_and_run (bufs, start_sample, end_sample, speed, nframes);
} else {
Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
- connect_and_run (bufs, start_frame, end_frame, speed, nframes, 0, lm.locked());
+ connect_and_run (bufs, start_sample, end_sample, speed, nframes, 0, lm.locked());
+ }
+#if defined MIXBUS && defined NDEBUG
+ if (!is_channelstrip ()) {
+ _timing_stats.update ();
}
+#else
+ _timing_stats.update ();
+#endif
} else {
+ _timing_stats.reset ();
// XXX should call ::silence() to run plugin(s) for consistent load.
// We'll need to change this anyway when bypass can be automated
bypass (bufs, nframes);
- automation_run (start_frame, nframes); // evaluate automation only
+ automation_run (start_sample, nframes, true); // evaluate automation only
_delaybuffers.flush ();
}
}
void
-PluginInsert::automate_and_run (BufferSet& bufs, framepos_t start, framepos_t end, double speed, pframes_t nframes)
+PluginInsert::automate_and_run (BufferSet& bufs, samplepos_t start, samplepos_t end, double speed, pframes_t nframes)
{
Evoral::ControlEvent next_event (0, 0.0f);
- framecnt_t offset = 0;
+ samplecnt_t offset = 0;
Glib::Threads::Mutex::Lock lm (control_lock(), Glib::Threads::TRY_LOCK);
return;
}
+ /* map start back into loop-range, adjust end */
+ map_loop_range (start, end);
+
if (!find_next_event (start, end, next_event) || _plugins.front()->requires_fixed_sized_buffers()) {
/* no events have a time within the relevant range */
while (nframes) {
- framecnt_t cnt = min (((framecnt_t) ceil (next_event.when) - start), (framecnt_t) nframes);
+ samplecnt_t cnt = min (((samplecnt_t) ceil (next_event.when) - start), (samplecnt_t) nframes);
connect_and_run (bufs, start, start + cnt, speed, cnt, offset, true); // XXX (start + cnt) * speed
offset += cnt;
start += cnt;
+ map_loop_range (start, end);
+
if (!find_next_event (start, end, next_event)) {
break;
}
PluginInsert::is_channelstrip () const {
return _plugins.front()->is_channelstrip();
}
+bool
+PluginInsert::is_nonbypassable () const {
+ return _plugins.front()->is_nonbypassable ();
+}
#endif
bool
*
* but allows in-port 1 -> sink-pin 2 || source-pin 2 -> out port 1
*/
- ChanMapping in_map (input_map ());
+ ChanMapping const& in_map (input_map ());
const ChanMapping::Mappings out_m (output_map ().mappings ());
for (ChanMapping::Mappings::const_iterator t = out_m.begin (); t != out_m.end () && inplace_ok; ++t) {
for (ChanMapping::TypeMapping::const_iterator c = (*t).second.begin (); c != (*t).second.end () ; ++c) {
_delaybuffers.configure (_configured_out, _plugins.front ()->max_latency ());
_latency_changed = true;
- // we don't know the analysis window size, so we must work with the
- // current buffer size here. each request for data fills in these
- // buffers and the analyser makes sure it gets enough data for the
- // analysis window
- session().ensure_buffer_set (_signal_analysis_inputs, in);
- _signal_analysis_inputs.set_count (in);
+ /* we don't know the analysis window size, so we must work with the
+ * current buffer size here. each request for data fills in these
+ * buffers and the analyser makes sure it gets enough data for the
+ * analysis window. We also only analyze audio, so we can ignore
+ * MIDI buffers.
+ */
+ ChanCount cc_analysis_in (DataType::AUDIO, in.n_audio());
+ ChanCount cc_analysis_out (DataType::AUDIO, out.n_audio());
+
+ session().ensure_buffer_set (_signal_analysis_inputs, cc_analysis_in);
+ _signal_analysis_inputs.set_count (cc_analysis_in);
- session().ensure_buffer_set (_signal_analysis_outputs, out);
- _signal_analysis_outputs.set_count (out);
+ session().ensure_buffer_set (_signal_analysis_outputs, cc_analysis_out);
+ _signal_analysis_outputs.set_count (cc_analysis_out);
// std::cerr << "set counts to i" << in.n_audio() << "/o" << out.n_audio() << std::endl;
XMLNode&
-PluginInsert::get_state ()
+PluginInsert::state ()
{
- return state (true);
-}
-
-XMLNode&
-PluginInsert::state (bool full)
-{
- XMLNode& node = Processor::state (full);
+ XMLNode& node = Processor::state ();
node.set_property("type", _plugins[0]->state_node_name());
node.set_property("unique-id", _plugins[0]->unique_id());
node.add_child_nocopy (* _thru_map.state ("ThruMap"));
if (_sidechain) {
- node.add_child_nocopy (_sidechain->state (full));
+ node.add_child_nocopy (_sidechain->get_state ());
}
_plugins[0]->set_insert_id(this->id());
// sidechain is a Processor (IO)
if ((*i)->name () == Processor::state_node_name) {
if (!_sidechain) {
- add_sidechain (0);
+ if (regenerate_xml_or_string_ids ()) {
+ add_sidechain_from_xml (**i, version);
+ } else {
+ add_sidechain (0);
+ }
}
if (!regenerate_xml_or_string_ids ()) {
_sidechain->set_state (**i, version);
+ } else {
+ update_sidechain_name ();
}
}
}
return Automatable::describe_parameter(param);
}
-ARDOUR::framecnt_t
+ARDOUR::samplecnt_t
PluginInsert::signal_latency() const
{
if (!_pending_active) {
}
void
-PluginInsert::collect_signal_for_analysis (framecnt_t nframes)
+PluginInsert::collect_signal_for_analysis (samplecnt_t nframes)
{
// called from outside the audio thread, so this should be safe
// only do audio as analysis is (currently) only for audio plugins
_plugins.push_back (plugin);
}
+void
+PluginInsert::add_sidechain_from_xml (const XMLNode& node, int version)
+{
+ if (version < 3000) {
+ return;
+ }
+
+ XMLNodeList nlist = node.children();
+
+ if (nlist.size() == 0) {
+ return;
+ }
+
+ uint32_t audio = 0;
+ uint32_t midi = 0;
+
+ XMLNodeConstIterator it = nlist.front()->children().begin();
+ for ( ; it != nlist.front()->children().end(); ++ it) {
+ if ((*it)->name() == "Port") {
+ DataType type(DataType::NIL);
+ (*it)->get_property ("type", type);
+ if (type == DataType::AUDIO) {
+ ++audio;
+ } else if (type == DataType::MIDI) {
+ ++midi;
+ }
+ }
+ }
+
+ ChanCount in_cc = ChanCount();
+ in_cc.set (DataType::AUDIO, audio);
+ in_cc.set (DataType::MIDI, midi);
+
+ add_sidechain (audio, midi);
+}
+
bool
PluginInsert::load_preset (ARDOUR::Plugin::PresetRecord pr)
{
{
boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
if (ac) {
- // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0
- ac->start_touch (session().audible_frame());
+ // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0
+ ac->start_touch (session().audible_sample());
}
}
{
boost::shared_ptr<AutomationControl> ac = automation_control (Evoral::Parameter (PluginAutomation, 0, param_id));
if (ac) {
- // ToDo subtract _plugin_signal_latency from audible_frame() when rolling, assert > 0
- ac->stop_touch (session().audible_frame());
+ // ToDo subtract _plugin_signal_latency from audible_sample() when rolling, assert > 0
+ ac->stop_touch (session().audible_sample());
}
}
+bool
+PluginInsert::provides_stats () const
+{
+#if defined MIXBUS && defined NDEBUG
+ if (is_channelstrip () || !display_to_user ()) {
+ return false;
+ }
+#endif
+ return true;
+}
+
+bool
+PluginInsert::get_stats (uint64_t& min, uint64_t& max, double& avg, double& dev) const
+{
+ /* TODO: consider taking a try/lock: Don't run concurrently with
+ * TimingStats::update, TimingStats::reset.
+ */
+ return _timing_stats.get_stats (min, max, avg, dev);
+}
+
+void
+PluginInsert::clear_stats ()
+{
+ g_atomic_int_set (&_stat_reset, 1);
+}
+
std::ostream& operator<<(std::ostream& o, const ARDOUR::PluginInsert::Match& m)
{
switch (m.method) {
projects / ardour.git / blobdiff