#include <pbd/enumwriter.h>
#include <ardour/session.h>
#include <ardour/automatable.h>
+#include <ardour/midi_track.h>
#include "i18n.h"
using namespace ARDOUR;
using namespace PBD;
+nframes_t Automatable::_automation_interval = 0;
Automatable::Automatable(Session& _session, const string& name)
: SessionObject(_session, name)
uint32_t what;
stringstream sstr;
- _visible_parameter_automation.clear ();
+ _visible_controls.clear ();
sstr << prop->value();
while (1) {
if (sstr.fail()) {
break;
}
- mark_automation_visible (ParamID(PluginAutomation, what), true);
+ mark_automation_visible (Parameter(PluginAutomation, what), true);
}
}
+
+ _last_automation_snapshot = 0;
return 0;
}
}
Glib::Mutex::Lock lm (_automation_lock);
- set<ParamID> tosave;
- _parameter_automation.clear ();
+ set<Parameter> tosave;
+ _controls.clear ();
+
+ _last_automation_snapshot = 0;
while (in) {
double when;
in >> value; if (!in) goto bad;
/* FIXME: this is legacy and only used for plugin inserts? I think? */
- AutomationList* al = automation_list (ParamID(PluginAutomation, port), true);
- al->add (when, value);
- tosave.insert (ParamID(PluginAutomation, port));
+ boost::shared_ptr<AutomationControl> c = control (Parameter(PluginAutomation, port), true);
+ c->list()->add (when, value);
+ tosave.insert (Parameter(PluginAutomation, port));
}
return 0;
bad:
error << string_compose(_("%1: cannot load automation data from %2"), _name, fullpath) << endmsg;
- _parameter_automation.clear ();
+ _controls.clear ();
return -1;
}
void
-Automatable::add_automation_parameter(AutomationList* al)
+Automatable::add_control(boost::shared_ptr<AutomationControl> ac)
{
- _parameter_automation[al->param_id()] = al;
-
- /* let derived classes do whatever they need with this */
- automation_list_creation_callback (al->param_id(), *al);
+ Parameter param = ac->parameter();
- cerr << _name << ": added parameter " << al->param_id().to_string() << endl;
+ _controls[param] = ac;
+
+ _can_automate_list.insert(param);
- // FIXME: sane default behaviour?
- _visible_parameter_automation.insert(al->param_id());
- _can_automate_list.insert(al->param_id());
+ // Sync everything (derived classes) up to initial values
+ auto_state_changed(param);
}
void
-Automatable::what_has_automation (set<ParamID>& s) const
+Automatable::what_has_automation (set<Parameter>& s) const
{
Glib::Mutex::Lock lm (_automation_lock);
- map<ParamID,AutomationList*>::const_iterator li;
+ Controls::const_iterator li;
- for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) {
+ // FIXME: correct semantics?
+ for (li = _controls.begin(); li != _controls.end(); ++li) {
s.insert ((*li).first);
}
}
void
-Automatable::what_has_visible_automation (set<ParamID>& s) const
+Automatable::what_has_visible_automation (set<Parameter>& s) const
{
Glib::Mutex::Lock lm (_automation_lock);
- set<ParamID>::const_iterator li;
+ set<Parameter>::const_iterator li;
- for (li = _visible_parameter_automation.begin(); li != _visible_parameter_automation.end(); ++li) {
+ for (li = _visible_controls.begin(); li != _visible_controls.end(); ++li) {
s.insert (*li);
}
}
/** Returns NULL if we don't have an AutomationList for \a parameter.
*/
-AutomationList*
-Automatable::automation_list (ParamID parameter, bool create_if_missing)
+boost::shared_ptr<AutomationControl>
+Automatable::control (Parameter parameter, bool create_if_missing)
{
- std::map<ParamID,AutomationList*>::iterator i = _parameter_automation.find(parameter);
+ Controls::iterator i = _controls.find(parameter);
- if (i != _parameter_automation.end()) {
+ if (i != _controls.end()) {
return i->second;
} else if (create_if_missing) {
- AutomationList* al = new AutomationList (parameter, FLT_MIN, FLT_MAX, default_parameter_value (parameter));
- add_automation_parameter(al);
- return al;
+ boost::shared_ptr<AutomationList> al (new AutomationList (
+ parameter, FLT_MIN, FLT_MAX, default_parameter_value (parameter)));
+ boost::shared_ptr<AutomationControl> ac(control_factory(al));
+ add_control(ac);
+ return ac;
} else {
//warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg;
- return NULL;
+ return boost::shared_ptr<AutomationControl>();
}
}
-const AutomationList*
-Automatable::automation_list (ParamID parameter) const
+boost::shared_ptr<const AutomationControl>
+Automatable::control (Parameter parameter) const
{
- std::map<ParamID,AutomationList*>::const_iterator i = _parameter_automation.find(parameter);
+ Controls::const_iterator i = _controls.find(parameter);
- if (i != _parameter_automation.end()) {
+ if (i != _controls.end()) {
return i->second;
} else {
//warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg;
- return NULL;
+ return boost::shared_ptr<AutomationControl>();
}
}
string
-Automatable::describe_parameter (ParamID param)
+Automatable::describe_parameter (Parameter param)
{
/* derived classes like PluginInsert should override this */
- if (param == ParamID(GainAutomation))
+ if (param == Parameter(GainAutomation))
return _("Fader");
- else if (param == ParamID(PanAutomation))
- return _("Pan");
+ else if (param.type() == PanAutomation)
+ return (string_compose(_("Pan %1"), param.id()));
else if (param.type() == MidiCCAutomation)
- return string_compose("MIDI CC %1", param.id());
+ return string_compose("CC %1", param.id());
else
return param.to_string();
}
void
-Automatable::can_automate (ParamID what)
+Automatable::can_automate (Parameter what)
{
_can_automate_list.insert (what);
}
void
-Automatable::mark_automation_visible (ParamID what, bool yn)
+Automatable::mark_automation_visible (Parameter what, bool yn)
{
if (yn) {
- _visible_parameter_automation.insert (what);
+ _visible_controls.insert (what);
} else {
- set<ParamID>::iterator i;
+ set<Parameter>::iterator i;
- if ((i = _visible_parameter_automation.find (what)) != _visible_parameter_automation.end()) {
- _visible_parameter_automation.erase (i);
+ if ((i = _visible_controls.find (what)) != _visible_controls.end()) {
+ _visible_controls.erase (i);
}
}
}
bool
Automatable::find_next_event (nframes_t now, nframes_t end, ControlEvent& next_event) const
{
- map<ParamID,AutomationList*>::const_iterator li;
- AutomationList::TimeComparator cmp;
+ Controls::const_iterator li;
next_event.when = max_frames;
- for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) {
+ for (li = _controls.begin(); li != _controls.end(); ++li) {
AutomationList::const_iterator i;
- const AutomationList& alist (*((*li).second));
+ boost::shared_ptr<const AutomationList> alist (li->second->list());
ControlEvent cp (now, 0.0f);
- for (i = lower_bound (alist.const_begin(), alist.const_end(), &cp, cmp); i != alist.const_end() && (*i)->when < end; ++i) {
+ for (i = lower_bound (alist->const_begin(), alist->const_end(), &cp, AutomationList::time_comparator);
+ i != alist->const_end() && (*i)->when < end; ++i) {
if ((*i)->when > now) {
break;
}
}
- if (i != alist.const_end() && (*i)->when < end) {
+ if (i != alist->const_end() && (*i)->when < end) {
if ((*i)->when < next_event.when) {
next_event.when = (*i)->when;
* pass that type and it will be used for the untyped AutomationList found.
*/
int
-Automatable::set_automation_state (const XMLNode& node, ParamID legacy_param)
+Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param)
{
Glib::Mutex::Lock lm (_automation_lock);
- _parameter_automation.clear ();
- _visible_parameter_automation.clear ();
+ /* Don't clear controls, since some may be special derived Controllable classes */
+
+ _visible_controls.clear ();
XMLNodeList nlist = node.children();
XMLNodeIterator niter;
const XMLProperty* id_prop = (*niter)->property("automation-id");
- ParamID param = (id_prop ? ParamID(id_prop->value()) : legacy_param);
+ Parameter param = (id_prop ? Parameter(id_prop->value()) : legacy_param);
- AutomationList* al = new AutomationList(**niter, param);
+ boost::shared_ptr<AutomationList> al (new AutomationList(**niter, param));
if (!id_prop) {
warning << "AutomationList node without automation-id property, "
<< "using default: " << legacy_param.to_string() << endmsg;
- al->set_param_id(legacy_param);
+ al->set_parameter(legacy_param);
}
- add_automation_parameter(al);
+ boost::shared_ptr<AutomationControl> existing = control(param);
+ if (existing)
+ existing->set_list(al);
+ else
+ add_control(control_factory(al));
} else {
error << "Expected AutomationList node, got '" << (*niter)->name() << endmsg;
}
}
+ _last_automation_snapshot = 0;
+
return 0;
}
Glib::Mutex::Lock lm (_automation_lock);
XMLNode* node = new XMLNode (X_("Automation"));
- cerr << "'" << _name << "'->get_automation_state, # params = " << _parameter_automation.size() << endl;
-
- if (_parameter_automation.empty()) {
+ if (_controls.empty()) {
return *node;
}
- map<ParamID,AutomationList*>::iterator li;
-
- for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li) {
- node->add_child_nocopy (li->second->get_state ());
+ for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) {
+ node->add_child_nocopy (li->second->list()->get_state ());
}
return *node;
{
Glib::Mutex::Lock lm (_automation_lock);
- map<ParamID,AutomationList*>::iterator li;
-
- for (li = _parameter_automation.begin(); li != _parameter_automation.end(); ++li)
- li->second->clear();
+ for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li)
+ li->second->list()->clear();
}
void
-Automatable::set_parameter_automation_state (ParamID param, AutoState s)
+Automatable::set_parameter_automation_state (Parameter param, AutoState s)
{
Glib::Mutex::Lock lm (_automation_lock);
- AutomationList* al = automation_list (param, true);
+ boost::shared_ptr<AutomationControl> c = control (param, true);
- if (s != al->automation_state()) {
- al->set_automation_state (s);
+ if (s != c->list()->automation_state()) {
+ c->list()->set_automation_state (s);
_session.set_dirty ();
}
}
AutoState
-Automatable::get_parameter_automation_state (ParamID param)
+Automatable::get_parameter_automation_state (Parameter param, bool lock)
{
- Glib::Mutex::Lock lm (_automation_lock);
+ AutoState result = Off;
- AutomationList* al = automation_list(param);
+ if (lock)
+ _automation_lock.lock();
- if (al) {
- return al->automation_state();
- } else {
- return Off;
- }
+ boost::shared_ptr<AutomationControl> c = control(param);
+
+ if (c)
+ result = c->list()->automation_state();
+
+ if (lock)
+ _automation_lock.unlock();
+
+ return result;
}
void
-Automatable::set_parameter_automation_style (ParamID param, AutoStyle s)
+Automatable::set_parameter_automation_style (Parameter param, AutoStyle s)
{
Glib::Mutex::Lock lm (_automation_lock);
- AutomationList* al = automation_list (param, true);
+ boost::shared_ptr<AutomationControl> c = control(param, true);
- if (s != al->automation_style()) {
- al->set_automation_style (s);
+ if (s != c->list()->automation_style()) {
+ c->list()->set_automation_style (s);
_session.set_dirty ();
}
}
AutoStyle
-Automatable::get_parameter_automation_style (ParamID param)
+Automatable::get_parameter_automation_style (Parameter param)
{
Glib::Mutex::Lock lm (_automation_lock);
- AutomationList* al = automation_list(param);
+ boost::shared_ptr<AutomationControl> c = control(param);
- if (al) {
- return al->automation_style();
+ if (c) {
+ return c->list()->automation_style();
} else {
return Absolute; // whatever
}
void
Automatable::protect_automation ()
{
- set<ParamID> automated_params;
+ set<Parameter> automated_params;
what_has_automation (automated_params);
- for (set<ParamID>::iterator i = automated_params.begin(); i != automated_params.end(); ++i) {
+ for (set<Parameter>::iterator i = automated_params.begin(); i != automated_params.end(); ++i) {
- AutomationList* al = automation_list (*i);
+ boost::shared_ptr<AutomationControl> c = control(*i);
- switch (al->automation_state()) {
+ switch (c->list()->automation_state()) {
case Write:
- al->set_automation_state (Off);
+ c->list()->set_automation_state (Off);
break;
case Touch:
- al->set_automation_state (Play);
+ c->list()->set_automation_state (Play);
break;
default:
break;
}
}
+void
+Automatable::automation_snapshot (nframes_t now)
+{
+ if (_last_automation_snapshot > now || (now - _last_automation_snapshot) > _automation_interval) {
+
+ for (Controls::iterator i = _controls.begin(); i != _controls.end(); ++i) {
+ if (i->second->list()->automation_write()) {
+ i->second->list()->rt_add (now, i->second->user_value());
+ }
+ }
+
+ _last_automation_snapshot = now;
+ }
+}
+
+void
+Automatable::transport_stopped (nframes_t now)
+{
+ for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) {
+
+ boost::shared_ptr<AutomationControl> c = li->second;
+
+ c->list()->reposition_for_rt_add (now);
+
+ if (c->list()->automation_state() != Off) {
+ c->set_value(c->list()->eval(now));
+ }
+ }
+}
+
+/* FIXME: this probably doesn't belong here */
+boost::shared_ptr<AutomationControl>
+Automatable::control_factory(boost::shared_ptr<AutomationList> list)
+{
+ if (list->parameter().type() == MidiCCAutomation) {
+ // FIXME: this will die horribly if this is not a MidiTrack
+ return boost::shared_ptr<AutomationControl>(new MidiTrack::MidiControl((MidiTrack*)this, list));
+ } else {
+ return boost::shared_ptr<AutomationControl>(new AutomationControl(_session, list));
+ }
+}
+
projects / ardour.git / blobdiff