X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fautomatable.cc;h=1e5b497bf7458901beb362a5e4c27f644e246505;hb=ecb0cd5d119d28092a8f48e4521ac5eba197bb54;hp=5595ebc2cfc5a22966e99e36cfa9930e7dec7d9d;hpb=7aea02083a207402405cc4869b892dd63da191b6;p=ardour.git diff --git a/libs/ardour/automatable.cc b/libs/ardour/automatable.cc index 5595ebc2cf..1e5b497bf7 100644 --- a/libs/ardour/automatable.cc +++ b/libs/ardour/automatable.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2001,2007 Paul Davis + Copyright (C) 2001,2007 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,17 +17,23 @@ */ -#include +#include "ardour/ardour.h" #include #include #include #include -#include -#include -#include -#include -#include -#include +#include "pbd/error.h" +#include "pbd/enumwriter.h" + +#include "midi++/names.h" + +#include "ardour/automatable.h" +#include "ardour/amp.h" +#include "ardour/event_type_map.h" +#include "ardour/midi_track.h" +#include "ardour/panner.h" +#include "ardour/plugin_insert.h" +#include "ardour/session.h" #include "i18n.h" @@ -37,38 +43,51 @@ using namespace PBD; nframes_t Automatable::_automation_interval = 0; -Automatable::Automatable(Session& _session, const string& name) - : SessionObject(_session, name) +Automatable::Automatable(Session& session) + : _a_session(session) , _last_automation_snapshot(0) -{} +{ +} +Automatable::Automatable (const Automatable& other) + : ControlSet (other) + , _a_session (other._a_session) + , _last_automation_snapshot (0) +{ + Glib::Mutex::Lock lm (other._control_lock); + + for (Controls::const_iterator i = other._controls.begin(); i != other._controls.end(); ++i) { + boost::shared_ptr ac (control_factory (i->first)); + _controls[ac->parameter()] = ac; + } +} int Automatable::old_set_automation_state (const XMLNode& node) { const XMLProperty *prop; - + if ((prop = node.property ("path")) != 0) { load_automation (prop->value()); } else { - warning << string_compose(_("%1: Automation node has no path property"), _name) << endmsg; + warning << _("Automation node has no path property") << endmsg; } - + if ((prop = node.property ("visible")) != 0) { uint32_t what; stringstream sstr; - + _visible_controls.clear (); - + sstr << prop->value(); while (1) { sstr >> what; if (sstr.fail()) { break; } - mark_automation_visible (Parameter(PluginAutomation, what), true); + mark_automation_visible (Evoral::Parameter(PluginAutomation, 0, what), true); } } - + _last_automation_snapshot = 0; return 0; @@ -82,20 +101,21 @@ Automatable::load_automation (const string& path) if (path[0] == '/') { // legacy fullpath = path; } else { - fullpath = _session.automation_dir(); + fullpath = _a_session.automation_dir(); fullpath += path; } ifstream in (fullpath.c_str()); if (!in) { - warning << string_compose(_("%1: cannot open %2 to load automation data (%3)"), _name, fullpath, strerror (errno)) << endmsg; + warning << string_compose(_("cannot open %2 to load automation data (%3)") + , fullpath, strerror (errno)) << endmsg; return 1; } - Glib::Mutex::Lock lm (_control_lock); - set tosave; - _controls.clear (); - + Glib::Mutex::Lock lm (control_lock()); + set tosave; + controls().clear (); + _last_automation_snapshot = 0; while (in) { @@ -106,80 +126,90 @@ Automatable::load_automation (const string& path) in >> port; if (!in) break; in >> when; if (!in) goto bad; in >> value; if (!in) goto bad; - + + Evoral::Parameter param(PluginAutomation, 0, port); /* FIXME: this is legacy and only used for plugin inserts? I think? */ - boost::shared_ptr c = control (Parameter(PluginAutomation, port), true); + boost::shared_ptr c = control (param, true); c->list()->add (when, value); - tosave.insert (Parameter(PluginAutomation, port)); + tosave.insert (param); } - + return 0; bad: - error << string_compose(_("%1: cannot load automation data from %2"), _name, fullpath) << endmsg; - _controls.clear (); + error << string_compose(_("cannot load automation data from %2"), fullpath) << endmsg; + controls().clear (); return -1; } void Automatable::add_control(boost::shared_ptr ac) { - Parameter param = ac->parameter(); + Evoral::Parameter param = ac->parameter(); + ControlSet::add_control(ac); _can_automate_list.insert(param); + auto_state_changed(param); // sync everything up - // Sync everything (derived classes) up to initial values - auto_state_changed(param); + /* connect to automation_state_changed so that we can emit a signal when one of our controls' + automation state changes + */ + boost::shared_ptr c = boost::dynamic_pointer_cast (ac); + if (c) { + c->alist()->automation_state_changed.connect_same_thread ( + _control_connections, boost::bind (&Automatable::automation_state_changed, this, c->parameter()) + ); + } } void -Automatable::what_has_visible_data (set& s) const +Automatable::what_has_visible_data(set& s) const { - Glib::Mutex::Lock lm (_control_lock); - set::const_iterator li; - + Glib::Mutex::Lock lm (control_lock()); + set::const_iterator li; + for (li = _visible_controls.begin(); li != _visible_controls.end(); ++li) { s.insert (*li); } } string -Automatable::describe_parameter (Parameter param) +Automatable::describe_parameter (Evoral::Parameter param) { /* derived classes like PluginInsert should override this */ - if (param == Parameter(GainAutomation)) { + if (param == Evoral::Parameter(GainAutomation)) { return _("Fader"); } else if (param.type() == PanAutomation) { /* ID's are zero-based, present them as 1-based */ return (string_compose(_("Pan %1"), param.id() + 1)); } else if (param.type() == MidiCCAutomation) { - return string_compose("CC %1 (%2) [%3]", - param.id() + 1, midi_name(param.id()), int(param.channel()) + 1); + return string_compose("%2 [%3]", + param.id() + 1, midi_name(param.id()), int(param.channel()) + 1); } else if (param.type() == MidiPgmChangeAutomation) { return string_compose("Program [%1]", int(param.channel()) + 1); } else if (param.type() == MidiPitchBenderAutomation) { return string_compose("Bender [%1]", int(param.channel()) + 1); - } else if (param.type() == MidiChannelAftertouchAutomation) { - return string_compose("Aftertouch [%1]", int(param.channel()) + 1); + } else if (param.type() == MidiChannelPressureAutomation) { + return string_compose("Pressure [%1]", int(param.channel()) + 1); } else { - return param.symbol(); + return EventTypeMap::instance().to_symbol(param); } } void -Automatable::can_automate (Parameter what) +Automatable::can_automate (Evoral::Parameter what) { _can_automate_list.insert (what); } void -Automatable::mark_automation_visible (Parameter what, bool yn) +Automatable::mark_automation_visible (Evoral::Parameter what, bool yn) { if (yn) { _visible_controls.insert (what); } else { - set::iterator i; + set::iterator i; if ((i = _visible_controls.find (what)) != _visible_controls.end()) { _visible_controls.erase (i); @@ -192,9 +222,9 @@ Automatable::mark_automation_visible (Parameter what, bool yn) * pass that type and it will be used for the untyped AutomationList found. */ int -Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param) -{ - Glib::Mutex::Lock lm (_control_lock); +Automatable::set_automation_state (const XMLNode& node, Evoral::Parameter legacy_param) +{ + Glib::Mutex::Lock lm (control_lock()); /* Don't clear controls, since some may be special derived Controllable classes */ @@ -202,7 +232,7 @@ Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param) XMLNodeList nlist = node.children(); XMLNodeIterator niter; - + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { /*if (sscanf ((*niter)->name().c_str(), "parameter-%" PRIu32, ¶m) != 1) { @@ -214,21 +244,30 @@ Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param) const XMLProperty* id_prop = (*niter)->property("automation-id"); - Parameter param = (id_prop ? Parameter(id_prop->value()) : legacy_param); - + Evoral::Parameter param = (id_prop + ? EventTypeMap::instance().new_parameter(id_prop->value()) + : legacy_param); + + if (param.type() == NullAutomation) { + warning << "Automation has null type" << endl; + continue; + } + boost::shared_ptr al (new AutomationList(**niter, param)); - + if (!id_prop) { warning << "AutomationList node without automation-id property, " - << "using default: " << legacy_param.symbol() << endmsg; - al->set_parameter(legacy_param); + << "using default: " << EventTypeMap::instance().to_symbol(legacy_param) << endmsg; } boost::shared_ptr existing = control(param); - if (existing) + if (existing) { existing->set_list(al); - else - add_control(control_factory(al)); + } else { + boost::shared_ptr newcontrol = control_factory(param); + add_control(newcontrol); + newcontrol->set_list(al); + } } else { error << "Expected AutomationList node, got '" << (*niter)->name() << endmsg; @@ -243,74 +282,76 @@ Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param) XMLNode& Automatable::get_automation_state () { - Glib::Mutex::Lock lm (_control_lock); + Glib::Mutex::Lock lm (control_lock()); XMLNode* node = new XMLNode (X_("Automation")); - - if (_controls.empty()) { + + if (controls().empty()) { return *node; } - for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) { + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { boost::shared_ptr l = boost::dynamic_pointer_cast(li->second->list()); - node->add_child_nocopy (l->get_state ()); + if (!l->empty()) { + node->add_child_nocopy (l->get_state ()); + } } return *node; } void -Automatable::set_parameter_automation_state (Parameter param, AutoState s) +Automatable::set_parameter_automation_state (Evoral::Parameter param, AutoState s) { - Glib::Mutex::Lock lm (_control_lock); - + Glib::Mutex::Lock lm (control_lock()); + boost::shared_ptr c = control (param, true); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); if (s != l->automation_state()) { l->set_automation_state (s); - _session.set_dirty (); + _a_session.set_dirty (); } } AutoState -Automatable::get_parameter_automation_state (Parameter param, bool lock) +Automatable::get_parameter_automation_state (Evoral::Parameter param, bool lock) { AutoState result = Off; if (lock) - _control_lock.lock(); + control_lock().lock(); boost::shared_ptr c = control(param); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); if (c) result = l->automation_state(); - + if (lock) - _control_lock.unlock(); + control_lock().unlock(); return result; } void -Automatable::set_parameter_automation_style (Parameter param, AutoStyle s) +Automatable::set_parameter_automation_style (Evoral::Parameter param, AutoStyle s) { - Glib::Mutex::Lock lm (_control_lock); - + Glib::Mutex::Lock lm (control_lock()); + boost::shared_ptr c = control(param, true); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); if (s != l->automation_style()) { l->set_automation_style (s); - _session.set_dirty (); + _a_session.set_dirty (); } } AutoStyle -Automatable::get_parameter_automation_style (Parameter param) +Automatable::get_parameter_automation_style (Evoral::Parameter param) { - Glib::Mutex::Lock lm (_control_lock); + Glib::Mutex::Lock lm (control_lock()); boost::shared_ptr c = control(param); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); @@ -328,7 +369,7 @@ Automatable::protect_automation () typedef set ParameterSet; ParameterSet automated_params; - what_has_data (automated_params); + what_has_data(automated_params); for (ParameterSet::iterator i = automated_params.begin(); i != automated_params.end(); ++i) { @@ -353,28 +394,28 @@ Automatable::automation_snapshot (nframes_t now, bool force) { if (force || _last_automation_snapshot > now || (now - _last_automation_snapshot) > _automation_interval) { - for (Controls::iterator i = _controls.begin(); i != _controls.end(); ++i) { + for (Controls::iterator i = controls().begin(); i != controls().end(); ++i) { boost::shared_ptr c = boost::dynamic_pointer_cast(i->second); if (c->automation_write()) { - c->list()->rt_add (now, i->second->user_value()); + c->list()->rt_add (now, i->second->user_float()); } } - + _last_automation_snapshot = now; } } void -Automatable::transport_stopped (nframes_t now) +Automatable::transport_stopped (sframes_t now) { - for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) { - + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr c = boost::dynamic_pointer_cast(li->second); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); - + c->list()->reposition_for_rt_add (now); if (c->automation_state() != Off) { @@ -384,20 +425,62 @@ Automatable::transport_stopped (nframes_t now) } boost::shared_ptr -Automatable::control_factory(boost::shared_ptr list) const +Automatable::control_factory(const Evoral::Parameter& param) { - boost::shared_ptr l = boost::dynamic_pointer_cast(list); - assert(l); - if (l->parameter().type() >= MidiCCAutomation - && l->parameter().type() <= MidiChannelAftertouchAutomation) { - return boost::shared_ptr(new MidiTrack::MidiControl((MidiTrack*)this, l)); - } else { - return boost::shared_ptr(new AutomationControl(_session, l)); + boost::shared_ptr list(new AutomationList(param)); + Evoral::Control* control = NULL; + if (param.type() >= MidiCCAutomation && param.type() <= MidiChannelPressureAutomation) { + MidiTrack* mt = dynamic_cast(this); + if (mt) { + control = new MidiTrack::MidiControl(mt, param); + } else { + warning << "MidiCCAutomation for non-MidiTrack" << endl; + } + } else if (param.type() == PluginAutomation) { + PluginInsert* pi = dynamic_cast(this); + if (pi) { + control = new PluginInsert::PluginControl(pi, param); + } else { + warning << "PluginAutomation for non-Plugin" << endl; + } + } else if (param.type() == GainAutomation) { + Amp* amp = dynamic_cast(this); + if (amp) { + control = new Amp::GainControl(X_("gaincontrol"), _a_session, amp, param); + } else { + warning << "GainAutomation for non-Amp" << endl; + } + } else if (param.type() == PanAutomation) { + Panner* me = dynamic_cast(this); + if (me) { + control = new Panner::PanControllable(me->session(), X_("panner"), *me, param); + } else { + warning << "PanAutomation for non-Panner" << endl; + } } + + if (!control) { + control = new AutomationControl(_a_session, param); + } + + control->set_list(list); + return boost::shared_ptr(control); } -boost::shared_ptr -Automatable::control_list_factory(const Evoral::Parameter& param) const +boost::shared_ptr +Automatable::automation_control (const Evoral::Parameter& id, bool create) +{ + return boost::dynamic_pointer_cast(Evoral::ControlSet::control(id, create)); +} + +boost::shared_ptr +Automatable::automation_control (const Evoral::Parameter& id) const +{ + return boost::dynamic_pointer_cast(Evoral::ControlSet::control(id)); +} + +void +Automatable::automation_state_changed (Evoral::Parameter const & p) { - return boost::shared_ptr(new AutomationList(param)); + AutomationStateChanged (p); /* EMIT SIGNAL */ }