Keep a dedicated list of automated parameters to evaluate in realtime.
This fixes a performance issue with plugins that have many controls
with only few of them being automated.
#include <boost/shared_ptr.hpp>
+#include "pbd/rcu.h"
#include "pbd/signals.h"
#include "evoral/ControlSet.hpp"
virtual void non_realtime_locate (samplepos_t now);
virtual void non_realtime_transport_stop (samplepos_t now, bool flush);
- virtual void automation_run (samplepos_t, pframes_t);
+ virtual void automation_run (samplepos_t, pframes_t, bool only_active = false);
virtual std::string describe_parameter(Evoral::Parameter param);
void can_automate(Evoral::Parameter);
- virtual void automation_list_automation_state_changed (Evoral::Parameter, AutoState) {}
+ virtual void automation_list_automation_state_changed (Evoral::Parameter, AutoState);
+ SerializedRCUManager<ControlList> _automated_controls;
int load_automation (const std::string& path);
int old_set_automation_state(const XMLNode&);
bool write_immediate_event (size_t size, const uint8_t* buf);
- void automation_run (samplepos_t, pframes_t);
+ void automation_run (samplepos_t, pframes_t, bool only_active = false);
bool find_next_event (double, double, Evoral::ControlEvent&, bool only_active = true) const;
int set_block_size (pframes_t nframes);
Automatable::Automatable(Session& session)
: _a_session(session)
+ , _automated_controls (new ControlList)
{
}
Automatable::Automatable (const Automatable& other)
- : ControlSet (other)
- , Slavable ()
- , _a_session (other._a_session)
+ : ControlSet (other)
+ , Slavable ()
+ , _a_session (other._a_session)
+ , _automated_controls (new ControlList)
{
Glib::Threads::Mutex::Lock lm (other._control_lock);
Automatable::~Automatable ()
{
+ {
+ RCUWriter<ControlList> writer (_automated_controls);
+ boost::shared_ptr<ControlList> cl = writer.get_copy ();
+ cl->clear ();
+ }
+ _automated_controls.flush ();
+
Glib::Threads::Mutex::Lock lm (_control_lock);
for (Controls::const_iterator li = _controls.begin(); li != _controls.end(); ++li) {
boost::dynamic_pointer_cast<AutomationControl>(li->second)->drop_references ();
}
void
-Automatable::automation_run (samplepos_t start, pframes_t nframes)
+Automatable::automation_run (samplepos_t start, pframes_t nframes, bool only_active)
{
+ if (only_active) {
+ boost::shared_ptr<ControlList> cl = _automated_controls.reader ();
+ for (ControlList::const_iterator ci = cl->begin(); ci != cl->end(); ++ci) {
+ (*ci)->automation_run (start, nframes);
+ }
+ return;
+ }
+
for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) {
boost::shared_ptr<AutomationControl> c =
boost::dynamic_pointer_cast<AutomationControl>(li->second);
}
}
+void
+Automatable::automation_list_automation_state_changed (Evoral::Parameter param, AutoState as)
+{
+ {
+ boost::shared_ptr<AutomationControl> c (automation_control(param));
+ assert (c && c->list());
+
+ RCUWriter<ControlList> writer (_automated_controls);
+ boost::shared_ptr<ControlList> cl = writer.get_copy ();
+
+ ControlList::const_iterator fi = std::find (cl->begin(), cl->end(), c);
+ if (fi != cl->end()) {
+ cl->erase (fi);
+ }
+ switch (as) {
+ /* all potential automation_playback() states */
+ case Play:
+ case Touch:
+ case Latch:
+ cl->push_back (c);
+ break;
+ case Off:
+ case Write:
+ break;
+ }
+ }
+ _automated_controls.flush();
+}
+
boost::shared_ptr<Evoral::Control>
Automatable::control_factory(const Evoral::Parameter& param)
{
}
void
-PluginInsert::automation_run (samplepos_t start, pframes_t nframes)
+PluginInsert::automation_run (samplepos_t start, pframes_t nframes, bool only_active)
{
// XXX does not work when rolling backwards
if (_loop_location && nframes > 0) {
}
samplecnt_t move = std::min ((samplecnt_t)nframes, loop_end - start_pos);
- Automatable::automation_run (start_pos, move);
+ Automatable::automation_run (start_pos, move, only_active);
remain -= move;
start_pos += move;
}
return;
}
- Automatable::automation_run (start, nframes);
+ Automatable::automation_run (start, nframes, only_active);
}
bool
if (with_auto) {
+#if 0
uint32_t n = 0;
for (Controls::const_iterator li = controls().begin(); li != controls().end(); ++li, ++n) {
}
}
}
+#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 samples we need to collect for analysis */
void
PluginInsert::silence (samplecnt_t nframes, samplepos_t start_sample)
{
- automation_run (start_sample, nframes); // evaluate automation only
+ automation_run (start_sample, nframes, true); // evaluate automation only
if (!active ()) {
// XXX delaybuffers need to be offset by nframes
// 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_sample, nframes); // evaluate automation only
+ automation_run (start_sample, nframes, true); // evaluate automation only
_delaybuffers.flush ();
}