#include "lv2/lv2plug.in/ns/extensions/ui/ui.h"
#include "lv2/lv2plug.in/ns/extensions/units/units.h"
#include "lv2/lv2plug.in/ns/ext/patch/patch.h"
+#include "lv2/lv2plug.in/ns/ext/port-groups/port-groups.h"
#ifdef HAVE_LV2_1_2_0
#include "lv2/lv2plug.in/ns/ext/buf-size/buf-size.h"
#include "lv2/lv2plug.in/ns/ext/options/options.h"
LilvNode* ext_causesArtifacts;
LilvNode* ext_notAutomatic;
LilvNode* ext_rangeSteps;
+ LilvNode* groups_group;
+ LilvNode* groups_element;
LilvNode* lv2_AudioPort;
LilvNode* lv2_ControlPort;
LilvNode* lv2_InputPort;
LilvNode* lv2_OutputPort;
+ LilvNode* lv2_designation;
LilvNode* lv2_enumeration;
LilvNode* lv2_freewheeling;
LilvNode* lv2_inPlaceBroken;
LilvNode* lv2_isSideChain;
+ LilvNode* lv2_index;
LilvNode* lv2_integer;
LilvNode* lv2_default;
LilvNode* lv2_minimum;
_midname_interface = (const LV2_Midnam_Interface*)
extension_data (LV2_MIDNAM__interface);
if (_midname_interface) {
- if (read_midnam ()) {
- printf ("READ MIDNAM FROM PLUGIN\n");
- } else {
- printf ("**FAILED TO ** READ MIDNAM FROM PLUGIN\n");
- }
+ read_midnam ();
}
#endif
std::stringstream ss;
ss << (void*)this;
ss << unique_id();
- MIDI::Name::MidiPatchManager::instance().remove_custom_midnam (ss.str());
- rv = MIDI::Name::MidiPatchManager::instance().add_custom_midnam (ss.str(), midnam);
+ rv = MIDI::Name::MidiPatchManager::instance().update_custom_midnam (ss.str(), midnam);
}
- free (midnam);
+#ifndef NDEBUG
+ if (rv) {
+ info << string_compose(_("LV2: update midnam for plugin '%1'"), name ()) << endmsg;
+ } else {
+ warning << string_compose(_("LV2: Failed to parse midnam of plugin '%1'"), name ()) << endmsg;
+ }
+#endif
+ _midname_interface->free (midnam);
return rv;
}
if (model) {
rv = model;
}
- free (model);
+ _midname_interface->free (model);
return rv;
}
#endif
const std::string
LV2Plugin::state_dir(unsigned num) const
{
- return Glib::build_filename(plugin_dir(), string_compose("state%1", num));
+ return Glib::build_filename(plugin_dir(), string("state") + PBD::to_string (num));
}
/** Implementation of state:makePath for files created at instantiation time.
assert(_insert_id != PBD::ID("0"));
XMLNode* child;
- char buf[32];
LocaleGuard lg;
for (uint32_t i = 0; i < parameter_count(); ++i) {
if (parameter_is_input(i) && parameter_is_control(i)) {
child = new XMLNode("Port");
- child->add_property("symbol", port_symbol(i));
- snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
- child->add_property("value", string(buf));
+ child->set_property("symbol", port_symbol(i));
+ child->set_property("value", _shadow_data[i]);
root->add_child_nocopy(*child);
}
}
if (!_plugin_state_dir.empty()) {
- root->add_property("template-dir", _plugin_state_dir);
+ root->set_property("template-dir", _plugin_state_dir);
}
if (_has_state_interface) {
// Provisionally increment state version and create directory
const std::string new_dir = state_dir(++_state_version);
+ // and keep track of it (for templates & archive)
+ unsigned int saved_state = _state_version;;
g_mkdir_with_parents(new_dir.c_str(), 0744);
LilvState* state = lilv_state_new_from_instance(
lilv_state_free(state);
PBD::remove_directory(new_dir);
--_state_version;
+ saved_state = _state_version;
}
- root->add_property("state-dir", string_compose("state%1", _state_version));
+ root->set_property("state-dir", string("state") + PBD::to_string (saved_state));
}
}
const uint32_t port_index = self->port_index(port_symbol);
if (port_index != (uint32_t)-1) {
self->set_parameter(port_index, *(const float*)value);
+ self->PresetPortSetValue (port_index, *(const float*)value); /* EMIT SIGNAL */
}
}
if (_atom_ev_buffers && _atom_ev_buffers[0]) {
bufsiz = lv2_evbuf_get_capacity(_atom_ev_buffers[0]);
}
- rbs = max((size_t) bufsiz * 8, rbs);
+ int fact = ceilf(_session.frame_rate () / 3000.f);
+ rbs = max((size_t) bufsiz * std::max (8, fact), rbs);
_from_ui = new RingBuffer<uint8_t>(rbs);
}
// Serialize patch:Set message to set property
#ifdef HAVE_LV2_1_10_0
- lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Set);
+ lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Set);
lv2_atom_forge_key(forge, _uri_map.urids.patch_property);
lv2_atom_forge_urid(forge, key);
lv2_atom_forge_key(forge, _uri_map.urids.patch_value);
#else
- lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Set);
+ lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Set);
lv2_atom_forge_property_head(forge, _uri_map.urids.patch_property, 0);
lv2_atom_forge_urid(forge, key);
lv2_atom_forge_property_head(forge, _uri_map.urids.patch_value, 0);
if (label) {
desc.label = lilv_node_as_string(label);
}
- if (def && lilv_node_is_float(def)) {
- desc.normal = lilv_node_as_float(def);
+ if (def) {
+ if (lilv_node_is_float(def)) {
+ desc.normal = lilv_node_as_float(def);
+ } else if (lilv_node_is_int(def)) {
+ desc.normal = lilv_node_as_int(def);
+ }
}
- if (minimum && lilv_node_is_float(minimum)) {
- desc.lower = lilv_node_as_float(minimum);
+ if (minimum) {
+ if (lilv_node_is_float(minimum)) {
+ desc.lower = lilv_node_as_float(minimum);
+ } else if (lilv_node_is_int(minimum)) {
+ desc.lower = lilv_node_as_int(minimum);
+ }
}
- if (maximum && lilv_node_is_float(maximum)) {
- desc.upper = lilv_node_as_float(maximum);
+ if (maximum) {
+ if (lilv_node_is_float(maximum)) {
+ desc.upper = lilv_node_as_float(maximum);
+ } else if (lilv_node_is_int(maximum)) {
+ desc.upper = lilv_node_as_int(maximum);
+ }
}
load_parameter_descriptor_units(lworld, desc, units);
desc.datatype = datatype;
// Serialize patch:Get message with no subject (implicitly plugin instance)
#ifdef HAVE_LV2_1_10_0
- lv2_atom_forge_object(forge, &frame, 1, _uri_map.urids.patch_Get);
+ lv2_atom_forge_object(forge, &frame, 0, _uri_map.urids.patch_Get);
#else
- lv2_atom_forge_blank(forge, &frame, 1, _uri_map.urids.patch_Get);
+ lv2_atom_forge_blank(forge, &frame, 0, _uri_map.urids.patch_Get);
#endif
// Write message to UI=>Plugin ring
LV2Plugin::set_state(const XMLNode& node, int version)
{
XMLNodeList nodes;
- XMLProperty const * prop;
XMLNodeConstIterator iter;
XMLNode* child;
- const char* sym;
- const char* value;
- uint32_t port_id;
LocaleGuard lg;
if (node.name() != state_node_name()) {
child = *iter;
- if ((prop = child->property("symbol")) != 0) {
- sym = prop->value().c_str();
- } else {
+ std::string sym;
+ if (!child->get_property("symbol", sym)) {
warning << _("LV2: port has no symbol, ignored") << endmsg;
continue;
}
map<string, uint32_t>::iterator i = _port_indices.find(sym);
+ uint32_t port_id;
+
if (i != _port_indices.end()) {
port_id = i->second;
} else {
continue;
}
- if ((prop = child->property("value")) != 0) {
- value = prop->value().c_str();
- } else {
+ float val;
+ if (!child->get_property("value", val)) {
warning << _("LV2: port has no value, ignored") << endmsg;
continue;
}
- set_parameter(port_id, atof(value));
+ set_parameter(port_id, val);
}
- if ((prop = node.property("template-dir")) != 0) {
- set_state_dir (prop->value ());
+ std::string template_dir;
+ if (node.get_property("template-dir", template_dir)) {
+ set_state_dir (template_dir);
}
_state_version = 0;
- if ((prop = node.property("state-dir")) != 0) {
- if (sscanf(prop->value().c_str(), "state%u", &_state_version) != 1) {
+ std::string state_dir;
+ if (node.get_property("state-dir", state_dir) != 0) {
+ if (sscanf(state_dir.c_str(), "state%u", &_state_version) != 1) {
error << string_compose(
"LV2: failed to parse state version from \"%1\"",
- prop->value()) << endmsg;
+ state_dir) << endmsg;
}
std::string state_file = Glib::build_filename(
plugin_dir(),
- Glib::build_filename(prop->value(), "state.ttl"));
+ Glib::build_filename(state_dir, "state.ttl"));
LilvState* state = lilv_state_new_from_file(
_world.world, _uri_map.urid_map(), NULL, state_file.c_str());
return Plugin::IOPortDescription ("?");
}
- LilvNode* name = lilv_port_get_name(_impl->plugin,
- lilv_plugin_get_port_by_index(_impl->plugin, idx));
+ const LilvPort* pport = lilv_plugin_get_port_by_index (_impl->plugin, idx);
+
+ LilvNode* name = lilv_port_get_name(_impl->plugin, pport);
Plugin::IOPortDescription iod (lilv_node_as_string (name));
lilv_node_free(name);
- if (lilv_port_has_property(_impl->plugin,
- lilv_plugin_get_port_by_index(_impl->plugin, idx), _world.lv2_isSideChain)) {
+ /* get the port's pg:group */
+ LilvNodes* groups = lilv_port_get_value (_impl->plugin, pport, _world.groups_group);
+ if (lilv_nodes_size (groups) > 0) {
+ const LilvNode* group = lilv_nodes_get_first (groups);
+ LilvNodes* grouplabel = lilv_world_find_nodes (_world.world, group, _world.rdfs_label, NULL);
+
+ /* get the name of the port-group */
+ if (lilv_nodes_size (grouplabel) > 0) {
+ const LilvNode* grpname = lilv_nodes_get_first (grouplabel);
+ iod.group_name = lilv_node_as_string (grpname);
+ }
+ lilv_nodes_free (grouplabel);
+
+ /* get all port designations.
+ * we're interested in e.g. lv2:designation pg:right */
+ LilvNodes* designations = lilv_port_get_value (_impl->plugin, pport, _world.lv2_designation);
+ if (lilv_nodes_size (designations) > 0) {
+ /* get all pg:elements of the pg:group */
+ LilvNodes* group_childs = lilv_world_find_nodes (_world.world, group, _world.groups_element, NULL);
+ if (lilv_nodes_size (group_childs) > 0) {
+ /* iterate over all port designations .. */
+ LILV_FOREACH (nodes, i, designations) {
+ const LilvNode* designation = lilv_nodes_get (designations, i);
+ /* match the lv2:designation's element against the port-group's element */
+ LILV_FOREACH (nodes, j, group_childs) {
+ const LilvNode* group_element = lilv_nodes_get (group_childs, j);
+ LilvNodes* elem = lilv_world_find_nodes (_world.world, group_element, _world.lv2_designation, designation);
+ /* found it. Now look up the index (channel-number) of the pg:Element */
+ if (lilv_nodes_size (elem) > 0) {
+ LilvNodes* idx = lilv_world_find_nodes (_world.world, lilv_nodes_get_first (elem), _world.lv2_index, NULL);
+ if (lilv_node_is_int (lilv_nodes_get_first (idx))) {
+ iod.group_channel = lilv_node_as_int(lilv_nodes_get_first (idx));
+ }
+ }
+ }
+ }
+ }
+ }
+ lilv_nodes_free (groups);
+ lilv_nodes_free (designations);
+ }
+
+ if (lilv_port_has_property(_impl->plugin, pport, _world.lv2_isSideChain)) {
iod.is_sidechain = true;
}
return iod;
lv2_atom_forge_set_buffer(forge, pos_buf, sizeof(pos_buf));
LV2_Atom_Forge_Frame frame;
#ifdef HAVE_LV2_1_10_0
- lv2_atom_forge_object(forge, &frame, 1, urids.time_Position);
+ lv2_atom_forge_object(forge, &frame, 0, urids.time_Position);
lv2_atom_forge_key(forge, urids.time_frame);
lv2_atom_forge_long(forge, position);
lv2_atom_forge_key(forge, urids.time_speed);
}
if (_bpm_control_port) {
- *_bpm_control_port = tmap.tempo_at_frame (start).beats_per_minute();
+ *_bpm_control_port = tmap.tempo_at_frame (start).note_types_per_minute();
}
#ifdef LV2_EXTENDED
if (valid && (flags & PORT_INPUT)) {
if ((flags & PORT_POSITION)) {
Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
- double bpm = tmap.tempo_at_frame (start).beats_per_minute();
+ double bpm = tmap.tempo_at_frame (start).note_types_per_minute();
double beatpos = (bbt.bars - 1) * tmetric.meter().divisions_per_bar()
+ (bbt.beats - 1)
+ (bbt.ticks / Timecode::BBT_Time::ticks_per_beat);
MetricSection* metric = (metric_i != tmap.metrics_end())
? *metric_i : NULL;
if (m != m_end && (!metric || metric->frame() > (*m).time())) {
- const Evoral::MIDIEvent<framepos_t> ev(*m, false);
+ const Evoral::Event<framepos_t> ev(*m, false);
if (ev.time() < nframes) {
LV2_Evbuf_Iterator eend = lv2_evbuf_end(_ev_buffers[port_index]);
lv2_evbuf_write(&eend, ev.time(), 0, type, ev.size(), ev.buffer());
} else {
tmetric.set_metric(metric);
Timecode::BBT_Time bbt;
- bbt = tmap.bbt_at_pulse (metric->pulse());
- double bpm = tmap.tempo_at_frame (start/*XXX*/).beats_per_minute();
+ bbt = tmap.bbt_at_frame (metric->frame());
+ double bpm = tmap.tempo_at_frame (start/*XXX*/).note_types_per_minute();
write_position(&_impl->forge, _ev_buffers[port_index],
tmetric, bbt, speed, bpm,
metric->frame(),
if (atom->type == _uri_map.urids.atom_Blank ||
atom->type == _uri_map.urids.atom_Object) {
LV2_Atom_Object* obj = (LV2_Atom_Object*)atom;
- if (obj->body.otype == _uri_map.urids.state_Changed) {
+ if (obj->body.otype == _uri_map.urids.state_StateChanged) {
_session.set_dirty ();
}
}
* so it needs to be realative to that.
*/
TempoMetric t = tmap.metric_at(start);
- _current_bpm = tmap.tempo_at_frame (start).beats_per_minute();
+ _current_bpm = tmap.tempo_at_frame (start).note_types_per_minute();
Timecode::BBT_Time bbt (tmap.bbt_at_frame (start));
double beatpos = (bbt.bars - 1) * t.meter().divisions_per_bar()
+ (bbt.beats - 1)
ext_causesArtifacts= lilv_new_uri(world, LV2_PORT_PROPS__causesArtifacts);
ext_notAutomatic = lilv_new_uri(world, LV2_PORT_PROPS__notAutomatic);
ext_rangeSteps = lilv_new_uri(world, LV2_PORT_PROPS__rangeSteps);
+ groups_group = lilv_new_uri(world, LV2_PORT_GROUPS__group);
+ groups_element = lilv_new_uri(world, LV2_PORT_GROUPS__element);
lv2_AudioPort = lilv_new_uri(world, LILV_URI_AUDIO_PORT);
lv2_ControlPort = lilv_new_uri(world, LILV_URI_CONTROL_PORT);
lv2_InputPort = lilv_new_uri(world, LILV_URI_INPUT_PORT);
lv2_OutputPort = lilv_new_uri(world, LILV_URI_OUTPUT_PORT);
lv2_inPlaceBroken = lilv_new_uri(world, LV2_CORE__inPlaceBroken);
lv2_isSideChain = lilv_new_uri(world, LV2_CORE_PREFIX "isSideChain");
+ lv2_index = lilv_new_uri(world, LV2_CORE__index);
lv2_integer = lilv_new_uri(world, LV2_CORE__integer);
lv2_default = lilv_new_uri(world, LV2_CORE__default);
lv2_minimum = lilv_new_uri(world, LV2_CORE__minimum);
lv2_reportsLatency = lilv_new_uri(world, LV2_CORE__reportsLatency);
lv2_sampleRate = lilv_new_uri(world, LV2_CORE__sampleRate);
lv2_toggled = lilv_new_uri(world, LV2_CORE__toggled);
+ lv2_designation = lilv_new_uri(world, LV2_CORE__designation);
lv2_enumeration = lilv_new_uri(world, LV2_CORE__enumeration);
lv2_freewheeling = lilv_new_uri(world, LV2_CORE__freeWheeling);
midi_MidiEvent = lilv_new_uri(world, LILV_URI_MIDI_EVENT);
lilv_node_free(rdfs_label);
lilv_node_free(rdfs_range);
lilv_node_free(midi_MidiEvent);
+ lilv_node_free(lv2_designation);
lilv_node_free(lv2_enumeration);
lilv_node_free(lv2_freewheeling);
lilv_node_free(lv2_toggled);
lilv_node_free(lv2_sampleRate);
lilv_node_free(lv2_reportsLatency);
+ lilv_node_free(lv2_index);
lilv_node_free(lv2_integer);
lilv_node_free(lv2_isSideChain);
lilv_node_free(lv2_inPlaceBroken);
lilv_node_free(lv2_InputPort);
lilv_node_free(lv2_ControlPort);
lilv_node_free(lv2_AudioPort);
+ lilv_node_free(groups_group);
+ lilv_node_free(groups_element);
lilv_node_free(ext_rangeSteps);
lilv_node_free(ext_notAutomatic);
lilv_node_free(ext_causesArtifacts);
{
// TODO use untranslated lilv_plugin_get_class()
// match gtk2_ardour/plugin_selector.cc
- if (category == c) {
- return true;
- }
- return false;
+ return category == c;
}
bool
projects / ardour.git / blobdiff