X-Git-Url: https://main.carlh.net/gitweb/?p=ardour.git;a=blobdiff_plain;f=libs%2Fardour%2Fautomatable.cc;h=51a58ce94293f10b4e00e60827c8556d35f7c061;hp=067e64a870f5b4c1e974125416084639c9845b4b;hb=e4d3ebfb666e2c4e9cf134d8f3ed42152da343bf;hpb=23c6936f433bfd07437b157eda4f36210819f2cf diff --git a/libs/ardour/automatable.cc b/libs/ardour/automatable.cc index 067e64a870..51a58ce942 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,58 +17,87 @@ */ -#include -#include -#include #include #include -#include -#include -#include -#include -#include -#include "i18n.h" +#include "pbd/gstdio_compat.h" +#include + +#include "pbd/error.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/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" +#ifdef LV2_SUPPORT +#include "ardour/uri_map.h" +#endif +#include "ardour/value_as_string.h" + +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; using namespace PBD; -nframes_t Automatable::_automation_interval = 0; +/* used for templates (previously: !full_state) */ +bool Automatable::skip_saving_automation = false; -Automatable::Automatable(Session& _session, const string& name) - : SessionObject(_session, name) - , _last_automation_snapshot(0) -{} +const string Automatable::xml_node_name = X_("Automation"); + +Automatable::Automatable(Session& session) + : _a_session(session) + , _automated_controls (new ControlList) +{ +} + +Automatable::Automatable (const Automatable& other) + : ControlSet (other) + , Slavable () + , _a_session (other._a_session) + , _automated_controls (new ControlList) +{ + 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 () +{ + { + RCUWriter writer (_automated_controls); + boost::shared_ptr 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(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()); } 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); - } - } - - _last_automation_snapshot = 0; return 0; } @@ -78,394 +107,128 @@ Automatable::load_automation (const string& path) { string fullpath; - if (path[0] == '/') { // legacy + if (Glib::path_is_absolute (path)) { // legacy fullpath = path; } else { - fullpath = _session.automation_dir(); + 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(_("%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 (_automation_lock); - set tosave; - _controls.clear (); - - _last_automation_snapshot = 0; + Glib::Threads::Mutex::Lock lm (control_lock()); + set tosave; + controls().clear (); - 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? */ - 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); } - + ::fclose (in); + 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 (); + ::fclose (in); return -1; } void -Automatable::add_control(boost::shared_ptr ac) -{ - Parameter param = ac->parameter(); - - _controls[param] = ac; - - _can_automate_list.insert(param); - - // Sync everything (derived classes) up to initial values - auto_state_changed(param); -} - -void -Automatable::what_has_automation (set& s) const +Automatable::add_control(boost::shared_ptr ac) { - Glib::Mutex::Lock lm (_automation_lock); - Controls::const_iterator li; - - // FIXME: correct semantics? - for (li = _controls.begin(); li != _controls.end(); ++li) { - s.insert ((*li).first); - } -} + Evoral::Parameter param = ac->parameter(); -void -Automatable::what_has_visible_automation (set& s) const -{ - Glib::Mutex::Lock lm (_automation_lock); - set::const_iterator li; - - for (li = _visible_controls.begin(); li != _visible_controls.end(); ++li) { - s.insert (*li); - } -} + boost::shared_ptr al = boost::dynamic_pointer_cast (ac->list ()); -/** Returns NULL if we don't have an AutomationList for \a parameter. - */ -boost::shared_ptr -Automatable::control (Parameter parameter, bool create_if_missing) -{ - Controls::iterator i = _controls.find(parameter); + boost::shared_ptr actl (boost::dynamic_pointer_cast (ac)); - if (i != _controls.end()) { - return i->second; - - } else if (create_if_missing) { - boost::shared_ptr al (new AutomationList ( - parameter, FLT_MIN, FLT_MAX, default_parameter_value (parameter))); - boost::shared_ptr ac(control_factory(al)); - add_control(ac); - return ac; - - } else { - //warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg; - return boost::shared_ptr(); + 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)); } -} -boost::shared_ptr -Automatable::control (Parameter parameter) const -{ - Controls::const_iterator i = _controls.find(parameter); + ControlSet::add_control (ac); - if (i != _controls.end()) { - return i->second; - } else { - //warning << "AutomationList " << parameter.to_string() << " not found for " << _name << endmsg; - return boost::shared_ptr(); + if ((!actl || !(actl->flags() & Controllable::NotAutomatable)) && al) { + _can_automate_list.insert (param); + automation_list_automation_state_changed (param, al->automation_state ()); // sync everything up } } - 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) { - return (string_compose(_("Pan %1"), param.id())); + } else if (param.type() == TrimAutomation) { + return _("Trim"); + } else if (param.type() == MuteAutomation) { + return _("Mute"); } else if (param.type() == MidiCCAutomation) { - string name = get_name_for_cc_number(param.id()); - if(name.length() != 0) { - return string_compose("%1 [%2]", name, int(param.channel()) + 1); - } else { - return string_compose("CC %1 [%2]", 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() == 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 if (param.type() == MidiNotePressureAutomation) { + return string_compose("PolyPressure [%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 param.to_string(); + return EventTypeMap::instance().to_symbol(param); } } -string -Automatable::get_name_for_cc_number (uint32_t cc_number) -{ - string name; - - switch (cc_number) { - case 0: - name = "Upper Bank"; - break; - - case 32: - name = "Lower Bank"; - break; - - case 1: - name = "Modulation MSB"; - break; - - case 2: - name = "Breath Controller"; - break; - - case 4: - name = "Foot Controller"; - break; - - case 5: - name = "Portamento Time"; - break; - - case 6: - name = "RPN Controller"; - break; - - case 7: - name = "Main Volume"; - break; - - case 8: - name = "Balance"; - break; - - case 10: - name = "Panorama"; - break; - - case 11: - name = "Expression"; - break; - - case 12: - name = "Effect 1"; - break; - - case 13: - name = "Effect 2"; - break; - - case 16: - case 17: - case 18: - case 19: - name = string_compose("General Purpose %1", cc_number - 15); - break; - - case 64: - name = "Sustain Pedal"; - break; - - case 65: - name = "Portamento"; - break; - - case 66: - name = "Sostenuto"; - break; - - case 67: - name = "Soft Pedal"; - break; - - case 68: - name = "Legato Footswitch"; - break; - - case 69: - name = "Hold 2"; - break; - - case 70: - case 71: - case 72: - case 73: - case 74: - name = string_compose("Sound Controller %1", cc_number - 69); - break; - - case 80: - case 81: - case 82: - case 83: - name = string_compose("General Purpose %1", cc_number - 75); - break; - - case 84: - name = "Portamento Control"; - break; - - case 91: - case 92: - case 93: - case 94: - case 95: - name = string_compose("Effects %1 Depth", cc_number - 90); - break; - - case 96: - name = "Data Increment RPN/NRPN"; - break; - - case 97: - name = "Data Decrement RPN/NRPN"; - break; - - case 98: - name = "NRPN LSB"; - break; - - case 99: - name = "NRPN MSB"; - break; - - case 100: - name = "RPN LSB"; - break; - - case 101: - name = "RPN MSB"; - break; - - case 120: - name = "all sounds off"; - break; - - case 121: - name = "Controller Reset"; - break; - - case 122: - name = "Local Control on/off"; - break; - - case 123: - name = "all notes off"; - break; - - case 124: - name = "omni off"; - break; - - case 125: - name = "omni on"; - break; - - case 126: - name = "mono on / poly off"; - break; - - case 127: - name = "poly on / mono off"; - break; - - default: - break; - } - - return name; -} - 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) -{ - if (yn) { - _visible_controls.insert (what); - } else { - set::iterator 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 -{ - Controls::const_iterator li; - - next_event.when = max_frames; - - for (li = _controls.begin(); li != _controls.end(); ++li) { - - AutomationList::const_iterator i; - boost::shared_ptr alist (li->second->list()); - ControlEvent cp (now, 0.0f); - - 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)->when < next_event.when) { - next_event.when = (*i)->when; - } - } - } - - return next_event.when != max_frames; -} - /** \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. */ int -Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param) -{ - Glib::Mutex::Lock lm (_automation_lock); +Automatable::set_automation_xml_state (const XMLNode& node, Evoral::Parameter legacy_param) +{ + 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; - + for (niter = nlist.begin(); niter != nlist.end(); ++niter) { /*if (sscanf ((*niter)->name().c_str(), "parameter-%" PRIu32, ¶m) != 1) { @@ -475,186 +238,423 @@ Automatable::set_automation_state (const XMLNode& node, Parameter legacy_param) 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().from_symbol(id_prop->value()) + : legacy_param); + + if (param.type() == NullAutomation) { + warning << "Automation has null type" << endl; + continue; + } - Parameter param = (id_prop ? Parameter(id_prop->value()) : legacy_param); - - boost::shared_ptr al (new AutomationList(**niter, param)); - if (!id_prop) { warning << "AutomationList node without automation-id property, " - << "using default: " << legacy_param.to_string() << endmsg; - al->set_parameter(legacy_param); + << "using default: " << EventTypeMap::instance().to_symbol(legacy_param) << endmsg; } - boost::shared_ptr existing = control(param); - if (existing) - existing->set_list(al); - else - add_control(control_factory(al)); + if (_can_automate_list.find (param) == _can_automate_list.end ()) { + boost::shared_ptr actl = automation_control (param); + if (actl && (*niter)->children().size() > 0 && Config->get_limit_n_automatables () > 0) { + actl->set_flags (Controllable::Flag ((int)actl->flags() & ~Controllable::NotAutomatable)); + can_automate (param); + info << "Marked parmater as automatable" << endl; + } else { + warning << "Ignored automation data for non-automatable parameter" << endl; + continue; + } + } + + + boost::shared_ptr existing = automation_control (param); + + if (existing) { + existing->alist()->set_state (**niter, 3000); + } else { + boost::shared_ptr newcontrol = control_factory(param); + add_control (newcontrol); + boost::shared_ptr al (new AutomationList(**niter, param)); + newcontrol->set_list(al); + } } else { - error << "Expected AutomationList node, got '" << (*niter)->name() << endmsg; + error << "Expected AutomationList node, got '" << (*niter)->name() << "'" << endmsg; } } - _last_automation_snapshot = 0; - return 0; } XMLNode& -Automatable::get_automation_state () +Automatable::get_automation_xml_state () { - Glib::Mutex::Lock lm (_automation_lock); - XMLNode* node = new XMLNode (X_("Automation")); - - if (_controls.empty()) { + Glib::Threads::Mutex::Lock lm (control_lock()); + XMLNode* node = new XMLNode (Automatable::xml_node_name); + + if (controls().empty()) { return *node; } - for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) { - node->add_child_nocopy (li->second->list()->get_state ()); + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr l = boost::dynamic_pointer_cast(li->second->list()); + if (l) { + node->add_child_nocopy (l->get_state ()); + } } return *node; } void -Automatable::clear_automation () +Automatable::set_parameter_automation_state (Evoral::Parameter param, AutoState s) { - Glib::Mutex::Lock lm (_automation_lock); + Glib::Threads::Mutex::Lock lm (control_lock()); - for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) - li->second->list()->clear(); -} - -void -Automatable::set_parameter_automation_state (Parameter param, AutoState s) -{ - Glib::Mutex::Lock lm (_automation_lock); - - boost::shared_ptr c = control (param, true); + boost::shared_ptr c = automation_control (param, true); - if (s != c->list()->automation_state()) { - c->list()->set_automation_state (s); - _session.set_dirty (); + if (c && (s != c->automation_state())) { + c->set_automation_state (s); + _a_session.set_dirty (); + AutomationStateChanged(); /* Emit signal */ } } AutoState -Automatable::get_parameter_automation_state (Parameter param, bool lock) +Automatable::get_parameter_automation_state (Evoral::Parameter param) { AutoState result = Off; - if (lock) - _automation_lock.lock(); - - boost::shared_ptr c = control(param); + boost::shared_ptr c = automation_control(param); - if (c) - result = c->list()->automation_state(); - - if (lock) - _automation_lock.unlock(); + if (c) { + result = c->automation_state(); + } return result; } void -Automatable::set_parameter_automation_style (Parameter param, AutoStyle s) +Automatable::protect_automation () { - Glib::Mutex::Lock lm (_automation_lock); - - boost::shared_ptr c = control(param, true); + typedef set ParameterSet; + const ParameterSet& automated_params = what_can_be_automated (); + + for (ParameterSet::const_iterator i = automated_params.begin(); i != automated_params.end(); ++i) { - if (s != c->list()->automation_style()) { - c->list()->set_automation_style (s); - _session.set_dirty (); + boost::shared_ptr c = control(*i); + boost::shared_ptr l = boost::dynamic_pointer_cast(c->list()); + + switch (l->automation_state()) { + case Write: + l->set_automation_state (Off); + break; + case Latch: + /* fall through */ + case Touch: + l->set_automation_state (Play); + break; + default: + break; + } } } -AutoStyle -Automatable::get_parameter_automation_style (Parameter param) +void +Automatable::non_realtime_locate (samplepos_t now) { - Glib::Mutex::Lock lm (_automation_lock); + bool rolling = _a_session.transport_rolling (); - boost::shared_ptr c = control(param); + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { - if (c) { - return c->list()->automation_style(); - } else { - return Absolute; // whatever + boost::shared_ptr c + = boost::dynamic_pointer_cast(li->second); + if (c) { + boost::shared_ptr l + = boost::dynamic_pointer_cast(c->list()); + + if (!l) { + continue; + } + + bool am_touching = c->touching (); + if (rolling && am_touching) { + /* when locating while rolling, and writing automation, + * start a new write pass. + * compare to compare to non_realtime_transport_stop() + */ + const bool list_did_write = !l->in_new_write_pass (); + c->stop_touch (-1); // time is irrelevant + l->stop_touch (-1); + 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->automation_playback ()) { + c->set_value_unchecked (c->list ()->eval (now)); + } + } + + l->start_write_pass (now); + + if (rolling && am_touching) { + c->start_touch (now); + } + } } } void -Automatable::protect_automation () +Automatable::non_realtime_transport_stop (samplepos_t now, bool /*flush_processors*/) { - set automated_params; + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr c = + boost::dynamic_pointer_cast(li->second); + if (!c) { + continue; + } - what_has_automation (automated_params); + boost::shared_ptr l = + boost::dynamic_pointer_cast(c->list()); + if (!l) { + continue; + } - for (set::iterator i = automated_params.begin(); i != automated_params.end(); ++i) { + /* 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 (); - boost::shared_ptr c = control(*i); + c->stop_touch (now); + l->stop_touch (now); - switch (c->list()->automation_state()) { - case Write: - c->list()->set_automation_state (Off); - break; - case Touch: - c->list()->set_automation_state (Play); - break; - default: - break; + 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->automation_playback ()) { + c->set_value_unchecked (c->list ()->eval (now)); } } } void -Automatable::automation_snapshot (nframes_t now, bool force) +Automatable::automation_run (samplepos_t start, pframes_t nframes, bool only_active) { - if (force || _last_automation_snapshot > now || (now - _last_automation_snapshot) > _automation_interval) { + if (only_active) { + boost::shared_ptr cl = _automated_controls.reader (); + for (ControlList::const_iterator ci = cl->begin(); ci != cl->end(); ++ci) { + (*ci)->automation_run (start, nframes); + } + return; + } - 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()); - } + for (Controls::iterator li = controls().begin(); li != controls().end(); ++li) { + boost::shared_ptr c = + boost::dynamic_pointer_cast(li->second); + if (!c) { + continue; } - - _last_automation_snapshot = now; + c->automation_run (start, nframes); } } void -Automatable::transport_stopped (nframes_t now) +Automatable::automation_list_automation_state_changed (Evoral::Parameter param, AutoState as) +{ + { + boost::shared_ptr c (automation_control(param)); + assert (c && c->list()); + + RCUWriter writer (_automated_controls); + boost::shared_ptr 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 +Automatable::control_factory(const Evoral::Parameter& param) { - for (Controls::iterator li = _controls.begin(); li != _controls.end(); ++li) { - - boost::shared_ptr c = li->second; - - c->list()->reposition_for_rt_add (now); - - if (c->list()->automation_state() != Off) { - c->set_value(c->list()->eval(now)); + 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); + make_list = false; // No list, this is region "automation" } + } else if (param.type() == PluginAutomation) { + PluginInsert* pi = dynamic_cast(this); + if (pi) { + 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() == 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 << "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) { + control = new PanControllable (_a_session, pannable->describe_parameter (param), pannable, 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, desc, list); } + + return boost::shared_ptr(control); } -/* FIXME: this probably doesn't belong here */ boost::shared_ptr -Automatable::control_factory(boost::shared_ptr list) +Automatable::automation_control (PBD::ID const & id) const { - if ( - list->parameter().type() == MidiCCAutomation || - list->parameter().type() == MidiPgmChangeAutomation || - list->parameter().type() == MidiChannelAftertouchAutomation - ) { - // FIXME: this will die horribly if this is not a MidiTrack - return boost::shared_ptr(new MidiTrack::MidiControl((MidiTrack*)this, list)); - } else { - return boost::shared_ptr(new AutomationControl(_session, list)); + Controls::const_iterator li; + + for (li = _controls.begin(); li != _controls.end(); ++li) { + boost::shared_ptr ac = boost::dynamic_pointer_cast (li->second); + if (ac && (ac->id() == id)) { + return ac; + } } + + return boost::shared_ptr(); } +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::clear_controls () +{ + _control_connections.drop_connections (); + ControlSet::clear_controls (); +} + +bool +Automatable::find_next_event (double now, double end, Evoral::ControlEvent& next_event, bool only_active) const +{ + Controls::const_iterator li; + + next_event.when = std::numeric_limits::max(); + + 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; + } + + boost::shared_ptr sc + = boost::dynamic_pointer_cast(li->second); + + if (sc) { + sc->find_next_event (now, end, next_event); + } + + 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 next_event.when != std::numeric_limits::max(); +}