ardour/ardour
ardour/ardour
13
1
Fork 0
Code Pull Requests Releases Activity

Clean up LV2 code in preparation for atom support.

Browse Source 
Merge all parameter_is_* boolvectors into a single vector of flags (smaller/faster).


git-svn-id: svn://localhost/ardour2/branches/3.0@11515 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
David Robillard 2012-02-24 22:09:30 +00:00
parent 78b1139d35
commit 4f96a1006b
2 changed files with 75 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
libs/ardour/ardour/lv2_plugin.h
View File

@ -1,4 +1,3 @@
/*
Copyright (C) 2008-2011 Paul Davis
Author: David Robillard
@ -16,7 +15,6 @@
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef __ardour_lv2_plugin_h__
@ -26,12 +24,6 @@
#include <string>
#include <vector>
#include <dlfcn.h>
#include "pbd/stateful.h"
#include <jack/types.h>
#include "ardour/plugin.h"
#include "ardour/uri_map.h"
@ -98,7 +90,7 @@ class LV2Plugin : public ARDOUR::Plugin
bool parameter_is_audio (uint32_t) const;
bool parameter_is_control (uint32_t) const;
bool parameter_is_midi (uint32_t) const;
bool parameter_is_event (uint32_t) const;
bool parameter_is_input (uint32_t) const;
bool parameter_is_output (uint32_t) const;
bool parameter_is_toggled (uint32_t) const;
@ -130,12 +122,17 @@ class LV2Plugin : public ARDOUR::Plugin
float* _latency_control_port;
PBD::ID _insert_id;
std::vector<bool> _port_is_input;
std::vector<bool> _port_is_output;
std::vector<bool> _port_is_midi;
std::vector<bool> _port_is_audio;
std::vector<bool> _port_is_control;
typedef enum {
PORT_INPUT = 1,
PORT_OUTPUT = 1 << 1,
PORT_EVENT = 1 << 2,
PORT_AUDIO = 1 << 3,
PORT_CONTROL = 1 << 4
} PortFlag;
typedef unsigned PortFlags;
std::vector<PortFlags> _port_flags;
std::map<std::string,uint32_t> _port_indices;
typedef struct {

118
libs/ardour/lv2_plugin.cc
View File

@ -152,7 +152,7 @@ LV2Plugin::init(void* c_plugin, framecnt_t rate)
_state_version = 0;
_was_activated = false;
_has_state_interface = false;
_instance_access_feature.URI = "http://lv2plug.in/ns/ext/instance-access";
_data_access_feature.URI = "http://lv2plug.in/ns/ext/data-access";
_make_path_feature.URI = LV2_STATE_MAKE_PATH_URI;
@ -210,17 +210,35 @@ LV2Plugin::init(void* c_plugin, framecnt_t rate)
_sample_rate = rate;
const uint32_t num_ports = this->num_ports();
const uint32_t num_ports = this->num_ports();
for (uint32_t i = 0; i < num_ports; ++i) {
const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
_port_is_control.push_back(lilv_port_is_a(_impl->plugin, port, _world.control_class));
_port_is_audio.push_back(lilv_port_is_a(_impl->plugin, port, _world.audio_class));
_port_is_midi.push_back(lilv_port_is_a(_impl->plugin, port, _world.event_class));
_port_is_output.push_back(lilv_port_is_a(_impl->plugin, port, _world.output_class));
_port_is_input.push_back(lilv_port_is_a(_impl->plugin, port, _world.input_class));
const LilvPort* port = lilv_plugin_get_port_by_index(_impl->plugin, i);
PortFlags flags = 0;
if (lilv_port_is_a(_impl->plugin, port, _world.control_class)) {
flags |= PORT_CONTROL;
} else if (lilv_port_is_a(_impl->plugin, port, _world.audio_class)) {
flags |= PORT_AUDIO;
} else if (lilv_port_is_a(_impl->plugin, port, _world.event_class)) {
flags |= PORT_EVENT;
} else {
error << string_compose(
"LV2: \"%1\" port %2 has no known data type",
lilv_node_as_string(_impl->name), i) << endmsg;
throw failed_constructor();
}
if (lilv_port_is_a(_impl->plugin, port, _world.output_class)) {
flags |= PORT_OUTPUT;
} else if (lilv_port_is_a(_impl->plugin, port, _world.input_class)) {
flags |= PORT_INPUT;
} else {
error << string_compose(
"LV2: \"%1\" port %2 is neither input nor output",
lilv_node_as_string(_impl->name), i) << endmsg;
throw failed_constructor();
}
_port_flags.push_back(flags);
}
const bool latent = lilv_plugin_has_latency(plugin);
const uint32_t latency_port = (latent)
? lilv_plugin_get_latency_port_index(plugin)
@ -935,55 +953,47 @@ LV2Plugin::connect_and_run(BufferSet& bufs,
uint32_t midi_out_index = 0;
bool valid;
for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
void* buf = NULL;
uint32_t index = 0;
if (parameter_is_audio(port_index)) {
if (parameter_is_input(port_index)) {
const uint32_t buf_index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
lilv_instance_connect_port(_impl->instance, port_index,
valid ? bufs.get_audio(buf_index).data(offset)
: silent_bufs.get_audio(0).data(offset));
index = in_map.get(DataType::AUDIO, audio_in_index++, &valid);
buf = (valid)
? bufs.get_audio(index).data(offset)
: silent_bufs.get_audio(0).data(offset);
} else if (parameter_is_output(port_index)) {
const uint32_t buf_index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
//cerr << port_index << " : " << " AUDIO OUT " << buf_index << endl;
lilv_instance_connect_port(_impl->instance, port_index,
valid ? bufs.get_audio(buf_index).data(offset)
: scratch_bufs.get_audio(0).data(offset));
index = out_map.get(DataType::AUDIO, audio_out_index++, &valid);
buf = (valid)
? bufs.get_audio(index).data(offset)
: scratch_bufs.get_audio(0).data(offset);
}
} else if (parameter_is_midi(port_index)) {
/* FIXME: The checks here for bufs.count().n_midi() > buf_index shouldn't
} else if (parameter_is_event(port_index)) {
/* FIXME: The checks here for bufs.count().n_midi() > index shouldn't
be necessary, but the mapping is illegal in some cases. Ideally
that should be fixed, but this is easier...
*/
if (parameter_is_input(port_index)) {
const uint32_t buf_index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
if (valid && bufs.count().n_midi() > buf_index) {
lilv_instance_connect_port(_impl->instance, port_index,
bufs.get_lv2_midi(true, buf_index).data());
} else {
lilv_instance_connect_port(_impl->instance, port_index,
silent_bufs.get_lv2_midi(true, 0).data());
}
index = in_map.get(DataType::MIDI, midi_in_index++, &valid);
buf = (valid && bufs.count().n_midi() > index)
? bufs.get_lv2_midi(true, index).data()
: silent_bufs.get_lv2_midi(true, 0).data();
} else if (parameter_is_output(port_index)) {
const uint32_t buf_index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
if (valid && bufs.count().n_midi() > buf_index) {
lilv_instance_connect_port(_impl->instance, port_index,
bufs.get_lv2_midi(false, buf_index).data());
} else {
lilv_instance_connect_port(_impl->instance, port_index,
scratch_bufs.get_lv2_midi(true, 0).data());
}
index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
buf = (valid && bufs.count().n_midi() > index)
? bufs.get_lv2_midi(false, index).data()
: scratch_bufs.get_lv2_midi(true, 0).data();
}
} else if (!parameter_is_control(port_index)) {
// Optional port (it'd better be if we've made it this far...)
lilv_instance_connect_port(_impl->instance, port_index, NULL);
}
} // else port is optional (or we shouldn't have made it this far)
lilv_instance_connect_port(_impl->instance, port_index, buf);
}
run(nframes);
midi_out_index = 0;
for (uint32_t port_index = 0; port_index < num_ports; ++port_index) {
if (parameter_is_midi(port_index) && parameter_is_output(port_index)) {
const uint32_t buf_index = out_map.get(DataType::MIDI, midi_out_index++, &valid);
if (parameter_is_event(port_index) && parameter_is_output(port_index)) {
const uint32_t buf_index = out_map.get(
DataType::MIDI, midi_out_index++, &valid);
if (valid) {
bufs.flush_lv2_midi(true, buf_index);
}
@ -999,36 +1009,36 @@ LV2Plugin::connect_and_run(BufferSet& bufs,
bool
LV2Plugin::parameter_is_control(uint32_t param) const
{
assert(param < _port_is_control.size());
return _port_is_control[param];
assert(param < _port_flags.size());
return _port_flags[param] & PORT_CONTROL;
}
bool
LV2Plugin::parameter_is_audio(uint32_t param) const
{
assert(param < _port_is_audio.size());
return _port_is_audio[param];
assert(param < _port_flags.size());
return _port_flags[param] & PORT_AUDIO;
}
bool
LV2Plugin::parameter_is_midi(uint32_t param) const
LV2Plugin::parameter_is_event(uint32_t param) const
{
assert(param < _port_is_midi.size());
return _port_is_midi[param];
assert(param < _port_flags.size());
return _port_flags[param] & PORT_EVENT;
}
bool
LV2Plugin::parameter_is_output(uint32_t param) const
{
assert(param < _port_is_output.size());
return _port_is_output[param];
assert(param < _port_flags.size());
return _port_flags[param] & PORT_OUTPUT;
}
bool
LV2Plugin::parameter_is_input(uint32_t param) const
{
assert(param < _port_is_input.size());
return _port_is_input[param];
assert(param < _port_flags.size());
return _port_flags[param] & PORT_INPUT;
}
void