X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fautomatable.cc;h=10d2565c90c4be3ce7f96e965e42856cf59ac8f7;hb=cf52d6e4b40111eb04b244ec054055a4ec15dbe0;hp=661b1532446a8d1f775de504b62e4d6aec3f7c5e;hpb=a473d630eb165272992e90f8d854b1d66ec0be63;p=ardour.git diff --git a/libs/ardour/automatable.cc b/libs/ardour/automatable.cc index 661b153244..10d2565c90 100644 --- a/libs/ardour/automatable.cc +++ b/libs/ardour/automatable.cc @@ -17,61 +17,69 @@ */ -#include "ardour/ardour.h" -#include -#include #include #include +#include "pbd/gstdio_compat.h" #include #include "pbd/error.h" -#include "pbd/enumwriter.h" -#include "pbd/stacktrace.h" -#include "midi++/names.h" - -#include "ardour/automatable.h" #include "ardour/amp.h" +#include "ardour/automatable.h" #include "ardour/event_type_map.h" +#include "ardour/gain_control.h" +#include "ardour/monitor_control.h" #include "ardour/midi_track.h" -#include "ardour/pannable.h" -#include "ardour/panner.h" #include "ardour/pan_controllable.h" +#include "ardour/pannable.h" +#include "ardour/plugin.h" #include "ardour/plugin_insert.h" +#include "ardour/record_enable_control.h" #include "ardour/session.h" +#include "ardour/uri_map.h" +#include "ardour/value_as_string.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; using namespace PBD; -framecnt_t Automatable::_automation_interval = 0; const string Automatable::xml_node_name = X_("Automation"); 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); + Glib::Threads::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)); add_control (ac); } } + +Automatable::~Automatable () +{ + { + Glib::Threads::Mutex::Lock lm (_control_lock); + + for (Controls::const_iterator li = _controls.begin(); li != _controls.end(); ++li) { + boost::dynamic_pointer_cast(li->second)->drop_references (); + } + } +} + int Automatable::old_set_automation_state (const XMLNode& node) { - const XMLProperty *prop; + XMLProperty const * prop; if ((prop = node.property ("path")) != 0) { load_automation (prop->value()); @@ -79,24 +87,6 @@ Automatable::old_set_automation_state (const XMLNode& node) 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 (Evoral::Parameter(PluginAutomation, 0, what), true); - } - } - - _last_automation_snapshot = 0; - return 0; } @@ -111,7 +101,8 @@ Automatable::load_automation (const string& path) fullpath = _a_session.automation_dir(); fullpath += path; } - ifstream in (fullpath.c_str()); + + FILE * in = g_fopen (fullpath.c_str (), "rb"); if (!in) { warning << string_compose(_("cannot open %2 to load automation data (%3)") @@ -119,20 +110,21 @@ Automatable::load_automation (const string& path) return 1; } - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); set tosave; controls().clear (); - _last_automation_snapshot = 0; - - while (in) { + while (!feof(in)) { double when; double value; uint32_t port; - in >> port; if (!in) break; - in >> when; if (!in) goto bad; - in >> value; if (!in) goto bad; + if (3 != fscanf (in, "%d %lf %lf", &port, &when, &value)) { + if (feof(in)) { + break; + } + goto bad; + } Evoral::Parameter param(PluginAutomation, 0, port); /* FIXME: this is legacy and only used for plugin inserts? I think? */ @@ -140,12 +132,14 @@ Automatable::load_automation (const string& path) c->list()->add (when, value); tosave.insert (param); } + ::fclose (in); return 0; bad: error << string_compose(_("cannot load automation data from %2"), fullpath) << endmsg; controls().clear (); + ::fclose (in); return -1; } @@ -155,26 +149,21 @@ Automatable::add_control(boost::shared_ptr ac) Evoral::Parameter param = ac->parameter(); boost::shared_ptr al = boost::dynamic_pointer_cast (ac->list ()); - assert (al); - al->automation_state_changed.connect_same_thread ( - _list_connections, boost::bind (&Automatable::automation_list_automation_state_changed, this, ac->parameter(), _1) - ); + boost::shared_ptr actl (boost::dynamic_pointer_cast (ac)); - ControlSet::add_control (ac); - _can_automate_list.insert (param); - - automation_list_automation_state_changed (param, al->automation_state ()); // sync everything up -} + if ((!actl || !(actl->flags() & Controllable::NotAutomatable)) && al) { + al->automation_state_changed.connect_same_thread ( + _list_connections, + boost::bind (&Automatable::automation_list_automation_state_changed, + this, ac->parameter(), _1)); + } -void -Automatable::what_has_visible_data(set& s) const -{ - Glib::Mutex::Lock lm (control_lock()); - set::const_iterator li; + ControlSet::add_control (ac); - for (li = _visible_controls.begin(); li != _visible_controls.end(); ++li) { - s.insert (*li); + if ((!actl || !(actl->flags() & Controllable::NotAutomatable)) && al) { + _can_automate_list.insert (param); + automation_list_automation_state_changed (param, al->automation_state ()); // sync everything up } } @@ -185,15 +174,22 @@ Automatable::describe_parameter (Evoral::Parameter param) if (param == Evoral::Parameter(GainAutomation)) { return _("Fader"); + } else if (param.type() == TrimAutomation) { + return _("Trim"); + } else if (param.type() == MuteAutomation) { + return _("Mute"); } else if (param.type() == MidiCCAutomation) { - return string_compose("%1: %2 [%3]", - param.id(), midi_name(param.id()), int(param.channel()) + 1); + return string_compose("Controller %1 [%2]", 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() == MidiChannelPressureAutomation) { return string_compose("Pressure [%1]", int(param.channel()) + 1); +#ifdef LV2_SUPPORT + } else if (param.type() == PluginPropertyAutomation) { + return string_compose("Property %1", URIMap::instance().id_to_uri(param.id())); +#endif } else { return EventTypeMap::instance().to_symbol(param); } @@ -205,20 +201,6 @@ Automatable::can_automate (Evoral::Parameter what) _can_automate_list.insert (what); } -void -Automatable::mark_automation_visible (Evoral::Parameter what, bool yn) -{ - if (yn) { - _visible_controls.insert (what); - } else { - set::iterator i; - - if ((i = _visible_controls.find (what)) != _visible_controls.end()) { - _visible_controls.erase (i); - } - } -} - /** \a legacy_param is used for loading legacy sessions where an object (IO, Panner) * had a single automation parameter, with it's type implicit. Derived objects should * pass that type and it will be used for the untyped AutomationList found. @@ -226,12 +208,10 @@ Automatable::mark_automation_visible (Evoral::Parameter what, bool yn) int Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter legacy_param) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); /* Don't clear controls, since some may be special derived Controllable classes */ - _visible_controls.clear (); - XMLNodeList nlist = node.children(); XMLNodeIterator niter; @@ -244,18 +224,21 @@ Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter le if ((*niter)->name() == "AutomationList") { - const XMLProperty* id_prop = (*niter)->property("automation-id"); + XMLProperty const * id_prop = (*niter)->property("automation-id"); Evoral::Parameter param = (id_prop - ? EventTypeMap::instance().new_parameter(id_prop->value()) + ? EventTypeMap::instance().from_symbol(id_prop->value()) : legacy_param); if (param.type() == NullAutomation) { warning << "Automation has null type" << endl; continue; - } - + } + if (_can_automate_list.find (param) == _can_automate_list.end ()) { + warning << "Ignored automation data for non-automatable parameter" << endl; + continue; + } if (!id_prop) { warning << "AutomationList node without automation-id property, " @@ -278,15 +261,13 @@ Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter le } } - _last_automation_snapshot = 0; - return 0; } XMLNode& Automatable::get_automation_xml_state () { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); XMLNode* node = new XMLNode (Automatable::xml_node_name); if (controls().empty()) { @@ -294,9 +275,8 @@ Automatable::get_automation_xml_state () } for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { - boost::shared_ptr l - = boost::dynamic_pointer_cast(li->second->list()); - if (!l->empty()) { + boost::shared_ptr l = boost::dynamic_pointer_cast(li->second->list()); + if (l && !l->empty()) { node->add_child_nocopy (l->get_state ()); } } @@ -307,14 +287,14 @@ Automatable::get_automation_xml_state () void Automatable::set_parameter_automation_state (Evoral::Parameter param, AutoState s) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); - boost::shared_ptr c = control (param, true); - boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); + boost::shared_ptr c = automation_control (param, true); - if (s != l->automation_state()) { - l->set_automation_state (s); + if (c && (s != c->automation_state())) { + c->set_automation_state (s); _a_session.set_dirty (); + AutomationStateChanged(); /* Emit signal */ } } @@ -323,11 +303,10 @@ Automatable::get_parameter_automation_state (Evoral::Parameter param) { AutoState result = Off; - boost::shared_ptr c = control(param); - boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); + boost::shared_ptr c = automation_control(param); if (c) { - result = l->automation_state(); + result = c->automation_state(); } return result; @@ -336,13 +315,12 @@ Automatable::get_parameter_automation_state (Evoral::Parameter param) void Automatable::set_parameter_automation_style (Evoral::Parameter param, AutoStyle s) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); - boost::shared_ptr c = control(param, true); - boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); + boost::shared_ptr c = automation_control(param, true); - if (s != l->automation_style()) { - l->set_automation_style (s); + if (c && (s != c->automation_style())) { + c->set_automation_style (s); _a_session.set_dirty (); } } @@ -350,7 +328,7 @@ Automatable::set_parameter_automation_style (Evoral::Parameter param, AutoStyle AutoStyle Automatable::get_parameter_automation_style (Evoral::Parameter param) { - Glib::Mutex::Lock lm (control_lock()); + Glib::Threads::Mutex::Lock lm (control_lock()); boost::shared_ptr c = control(param); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); @@ -366,11 +344,9 @@ void Automatable::protect_automation () { typedef set ParameterSet; - ParameterSet automated_params; + const ParameterSet& automated_params = what_can_be_automated (); - what_has_data(automated_params); - - for (ParameterSet::iterator i = automated_params.begin(); i != automated_params.end(); ++i) { + for (ParameterSet::const_iterator i = automated_params.begin(); i != automated_params.end(); ++i) { boost::shared_ptr c = control(*i); boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); @@ -389,19 +365,20 @@ Automatable::protect_automation () } void -Automatable::automation_snapshot (framepos_t now, bool force) +Automatable::transport_located (framepos_t now) { - if (force || _last_automation_snapshot > now || (now - _last_automation_snapshot) > _automation_interval) { + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + + boost::shared_ptr c + = boost::dynamic_pointer_cast(li->second); + if (c) { + boost::shared_ptr l + = boost::dynamic_pointer_cast(c->list()); - for (Controls::iterator i = controls().begin(); i != controls().end(); ++i) { - boost::shared_ptr c - = boost::dynamic_pointer_cast(i->second); - if (_a_session.transport_rolling() && c->automation_write()) { - c->list()->rt_add (now, i->second->user_double()); + if (l) { + l->start_write_pass (now); } } - - _last_automation_snapshot = now; } } @@ -409,61 +386,83 @@ void Automatable::transport_stopped (framepos_t now) { for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr c = + boost::dynamic_pointer_cast(li->second); + if (!c) { + continue; + } - boost::shared_ptr c - = boost::dynamic_pointer_cast(li->second); - if (c) { - boost::shared_ptr l - = boost::dynamic_pointer_cast(c->list()); + boost::shared_ptr l = + boost::dynamic_pointer_cast(c->list()); + if (!l) { + continue; + } + + /* Stop any active touch gesture just before we mark the write pass + as finished. If we don't do this, the transport can end up stopped with + an AutomationList thinking that a touch is still in progress and, + when the transport is re-started, a touch will magically + be happening without it ever have being started in the usual way. + */ + const bool list_did_write = !l->in_new_write_pass (); + + l->stop_touch (true, now); + + c->commit_transaction (list_did_write); + + l->write_pass_finished (now, Config->get_automation_thinning_factor ()); + + if (l->automation_state () == Write) { + l->set_automation_state (Touch); + } - if (l) { - /* Stop any active touch gesture just before we mark the write pass - as finished. If we don't do this, the transport can end up stopped with - an AutomationList thinking that a touch is still in progress and, - when the transport is re-started, a touch will magically - be happening without it ever have being started in the usual way. - */ - l->stop_touch (true, now); - l->write_pass_finished (now); - - if (l->automation_playback()) { - c->set_value(c->list()->eval(now)); - } - - if (l->automation_state() == Write) { - l->set_automation_state (Touch); - } - } - } + if (l->automation_playback ()) { + c->set_value_unchecked (c->list ()->eval (now)); + } } } boost::shared_ptr Automatable::control_factory(const Evoral::Parameter& param) { - boost::shared_ptr list(new AutomationList(param)); - Evoral::Control* control = NULL; + Evoral::Control* control = NULL; + bool make_list = true; + ParameterDescriptor desc(param); + boost::shared_ptr list; + 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; + make_list = false; // No list, this is region "automation" } } else if (param.type() == PluginAutomation) { PluginInsert* pi = dynamic_cast(this); if (pi) { - control = new PluginInsert::PluginControl(pi, param); + pi->plugin(0)->get_parameter_descriptor(param.id(), desc); + control = new PluginInsert::PluginControl(pi, param, desc); } 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 if (param.type() == PluginPropertyAutomation) { + PluginInsert* pi = dynamic_cast(this); + if (pi) { + desc = pi->plugin(0)->get_property_descriptor(param.id()); + if (desc.datatype != Variant::NOTHING) { + if (!Variant::type_is_numeric(desc.datatype)) { + make_list = false; // Can't automate non-numeric data yet + } else { + list = boost::shared_ptr(new AutomationList(param, desc)); + } + control = new PluginInsert::PluginPropertyControl(pi, param, desc, list); + } } else { - warning << "GainAutomation for non-Amp" << endl; + warning << "PluginPropertyAutomation for non-Plugin" << endl; } + } else if (param.type() == GainAutomation) { + control = new GainControl(_a_session, param); + } else if (param.type() == TrimAutomation) { + control = new GainControl(_a_session, param); } else if (param.type() == PanAzimuthAutomation || param.type() == PanWidthAutomation || param.type() == PanElevationAutomation) { Pannable* pannable = dynamic_cast(this); if (pannable) { @@ -471,13 +470,37 @@ Automatable::control_factory(const Evoral::Parameter& param) } else { warning << "PanAutomation for non-Pannable" << endl; } + } else if (param.type() == RecEnableAutomation) { + Recordable* re = dynamic_cast (this); + if (re) { + control = new RecordEnableControl (_a_session, X_("recenable"), *re); + } + } else if (param.type() == MonitoringAutomation) { + Monitorable* m = dynamic_cast(this); + if (m) { + control = new MonitorControl (_a_session, X_("monitor"), *m); + } + } else if (param.type() == SoloAutomation) { + Soloable* s = dynamic_cast(this); + Muteable* m = dynamic_cast(this); + if (s && m) { + control = new SoloControl (_a_session, X_("solo"), *s, *m); + } + } else if (param.type() == MuteAutomation) { + Muteable* m = dynamic_cast(this); + if (m) { + control = new MuteControl (_a_session, X_("mute"), *m); + } + } + + if (make_list && !list) { + list = boost::shared_ptr(new AutomationList(param, desc)); } if (!control) { - control = new AutomationControl(_a_session, param); + control = new AutomationControl(_a_session, param, desc, list); } - control->set_list(list); return boost::shared_ptr(control); } @@ -501,21 +524,46 @@ Automatable::clear_controls () } string -Automatable::value_as_string (boost::shared_ptr ac) const +Automatable::value_as_string (boost::shared_ptr ac) const +{ + return ARDOUR::value_as_string(ac->desc(), ac->get_value()); +} + +bool +Automatable::find_next_event (double now, double end, Evoral::ControlEvent& next_event, bool only_active) const { - std::stringstream s; + Controls::const_iterator li; - /* this is a the default fallback for this virtual method. Derived Automatables - are free to override this to display the values of their parameters/controls - in different ways. - */ + next_event.when = std::numeric_limits::max(); - // Hack to display CC as integer value, rather than double - if (ac->parameter().type() == MidiCCAutomation) { - s << lrint (ac->get_value()); - } else { - s << std::fixed << std::setprecision(3) << ac->get_value(); + for (li = _controls.begin(); li != _controls.end(); ++li) { + boost::shared_ptr c + = boost::dynamic_pointer_cast(li->second); + + if (only_active && (!c || !c->automation_playback())) { + continue; + } + + Evoral::ControlList::const_iterator i; + boost::shared_ptr alist (li->second->list()); + Evoral::ControlEvent cp (now, 0.0f); + if (!alist) { + continue; + } + + for (i = lower_bound (alist->begin(), alist->end(), &cp, Evoral::ControlList::time_comparator); + i != alist->end() && (*i)->when < end; ++i) { + if ((*i)->when > now) { + break; + } + } + + if (i != alist->end() && (*i)->when < end) { + if ((*i)->when < next_event.when) { + next_event.when = (*i)->when; + } + } } - return s.str (); + return next_event.when != std::numeric_limits::max(); }