smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-16 19:56:31 +01:00
Code Issues Projects Releases Wiki Activity

Use new Suil and SLV2 APIs for LV2 plugin UIs.

Browse source 
Add lv2_ui.h (required by lv2_external_ui.h).


git-svn-id: svn://localhost/ardour2/branches/3.0@9406 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
David Robillard 2011-04-22 08:08:37 +00:00
parent 12bb5b6207
commit c37722f7dc
8 changed files with 328 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gtk2_ardour/lv2_external_ui.h
View file

@ -77,7 +77,7 @@ struct lv2_external_ui_host
* @param controller Host context associated with plugin UI, as
* supplied to LV2UI_Descriptor::instantiate()
*/
void (* ui_closed)(LV2UI_Controller controller);
void (* ui_closed)(void* controller);
/**
* Optional (may be NULL) "user friendly" identifier which the UI

57
gtk2_ardour/lv2_plugin_ui.cc
View file

@ -26,21 +26,23 @@
#include "gui_thread.h"
#include "lv2_plugin_ui.h"
#include "lv2_ui.h"
using namespace Gtk;
using namespace ARDOUR;
using namespace PBD;
#ifdef HAVE_NEW_SLV2
SLV2UIHost LV2PluginUI::ui_host = NULL;
SLV2Value LV2PluginUI::ui_GtkUI = NULL;
#if defined(HAVE_NEW_SLV2) && defined(HAVE_SUIL)
SuilHost LV2PluginUI::ui_host = NULL;
SLV2Value LV2PluginUI::ui_GtkUI = NULL;
#endif
void
LV2PluginUI::lv2_ui_write(LV2UI_Controller controller,
uint32_t port_index,
uint32_t /*buffer_size*/,
uint32_t /*format*/,
const void* buffer)
LV2PluginUI::lv2_ui_write(void* controller,
uint32_t port_index,
uint32_t /*buffer_size*/,
uint32_t /*format*/,
const void* buffer)
{
LV2PluginUI* me = (LV2PluginUI*)controller;
boost::shared_ptr<AutomationControl> ac = me->_controllables[port_index];
@ -51,7 +53,7 @@ LV2PluginUI::lv2_ui_write(LV2UI_Controller controller,
}
void
LV2PluginUI::on_external_ui_closed(LV2UI_Controller controller)
LV2PluginUI::on_external_ui_closed(void* controller)
{
LV2PluginUI* me = (LV2PluginUI*)controller;
me->_screen_update_connection.disconnect();
@ -75,8 +77,8 @@ LV2PluginUI::parameter_update(uint32_t port_index, float val)
return;
}
#ifdef HAVE_NEW_SLV2
slv2_ui_instance_port_event(_inst, port_index, 4, 0, &val);
#ifdef HAVE_SUIL
suil_instance_port_event(_inst, port_index, 4, 0, &val);
#else
const LV2UI_Descriptor* ui_desc = slv2_ui_instance_get_descriptor(_inst);
LV2UI_Handle ui_handle = slv2_ui_instance_get_handle(_inst);
@ -131,9 +133,9 @@ LV2PluginUI::LV2PluginUI(boost::shared_ptr<PluginInsert> pi,
boost::shared_ptr<LV2Plugin> lv2p)
: PlugUIBase(pi)
, _lv2(lv2p)
, _inst(NULL)
, _values(NULL)
, _external_ui_ptr(NULL)
, _inst(NULL)
{
if (!_lv2->is_external_ui()) {
lv2ui_instantiate("gtk2gui");
@ -174,16 +176,25 @@ LV2PluginUI::lv2ui_instantiate(const std::string& title)
features_dst = (LV2_Feature**)_lv2->features();
}
#ifdef HAVE_NEW_SLV2
#if defined(HAVE_NEW_SLV2) && defined(HAVE_SUIL)
if (!LV2PluginUI::ui_host) {
LV2PluginUI::ui_GtkUI = slv2_value_new_uri(
ARDOUR::PluginManager::the_manager()->lv2_world()->world,
"http://lv2plug.in/ns/extensions/ui#GtkUI");
LV2PluginUI::ui_host = slv2_ui_host_new(
LV2PluginUI::ui_host = suil_host_new(
LV2PluginUI::lv2_ui_write, NULL, NULL, NULL);
}
_inst = slv2_ui_instance_new(
_lv2->slv2_plugin(), _lv2->slv2_ui(), ui_GtkUI, ui_host, this, features_dst);
SLV2UI ui = _lv2->slv2_ui();
_inst = suil_instance_new(
LV2PluginUI::ui_host,
this,
slv2_value_as_uri(ui_GtkUI),
slv2_value_as_uri(slv2_plugin_get_uri(_lv2->slv2_plugin())),
slv2_value_as_uri(slv2_ui_get_uri(ui)),
slv2_value_as_uri(_lv2->ui_type()),
slv2_uri_to_path(slv2_value_as_uri(slv2_ui_get_bundle_uri(ui))),
slv2_uri_to_path(slv2_value_as_uri(slv2_ui_get_binary_uri(ui))),
features_dst);
#else
_inst = slv2_ui_instantiate(
_lv2->slv2_plugin(), _lv2->slv2_ui(), LV2PluginUI::lv2_ui_write, this,
@ -194,6 +205,12 @@ LV2PluginUI::lv2ui_instantiate(const std::string& title)
free(features_dst);
}
#if defined(HAVE_NEW_SLV2) && defined(HAVE_SUIL)
#define GET_WIDGET(inst) suil_instance_get_widget(inst);
#else
#define GET_WIDGET(inst) slv2_ui_instance_get_widget(inst);
#endif
uint32_t num_ports = slv2_plugin_get_num_ports(_lv2->slv2_plugin());
for (uint32_t i = 0; i < num_ports; ++i) {
if (_lv2->parameter_is_output(i)
@ -206,12 +223,12 @@ LV2PluginUI::lv2ui_instantiate(const std::string& title)
_external_ui_ptr = NULL;
if (_inst) {
if (!is_external_ui) {
GtkWidget* c_widget = (GtkWidget*)slv2_ui_instance_get_widget(_inst);
GtkWidget* c_widget = (GtkWidget*)GET_WIDGET(_inst);
_gui_widget = Glib::wrap(c_widget);
_gui_widget->show_all();
pack_start(*_gui_widget, true, true);
} else {
_external_ui_ptr = (struct lv2_external_ui*)slv2_ui_instance_get_widget(_inst);
_external_ui_ptr = (struct lv2_external_ui*)GET_WIDGET(_inst);
}
}
@ -241,8 +258,8 @@ LV2PluginUI::~LV2PluginUI ()
}
/* Close and delete GUI. */
#ifdef HAVE_NEW_SLV2
slv2_ui_instance_free(_inst);
#if defined(HAVE_NEW_SLV2) && defined(HAVE_SUIL)
suil_instance_free(_inst);
#else
const LV2UI_Descriptor* ui_desc = slv2_ui_instance_get_descriptor(_inst);
LV2UI_Handle ui_handle = slv2_ui_instance_get_handle(_inst);

29
gtk2_ardour/lv2_plugin_ui.h
View file

@ -40,6 +40,10 @@
#include "lv2_external_ui.h"
#if defined(HAVE_NEW_SLV2) && defined(HAVE_SUIL)
#include <suil/suil.h>
#endif
namespace ARDOUR {
class PluginInsert;
class LV2Plugin;
@ -66,9 +70,8 @@ class LV2PluginUI : public PlugUIBase, public Gtk::VBox
std::vector<int> _output_ports;
sigc::connection _screen_update_connection;
Gtk::Widget* _gui_widget;
SLV2UIInstance _inst;
float* _values;
Gtk::Widget* _gui_widget;
float* _values;
std::vector<boost::shared_ptr<ARDOUR::AutomationControl> > _controllables;
struct lv2_external_ui_host _external_ui_host;
@ -76,19 +79,23 @@ class LV2PluginUI : public PlugUIBase, public Gtk::VBox
struct lv2_external_ui* _external_ui_ptr;
Gtk::Window* _win_ptr;
static void on_external_ui_closed(LV2UI_Controller controller);
static void on_external_ui_closed(void* controller);
#ifdef HAVE_NEW_SLV2
static SLV2UIHost ui_host;
#if defined(HAVE_NEW_SLV2) && defined(HAVE_SUIL)
static SuilHost ui_host;
static SLV2Value ui_GtkUI;
SuilInstance _inst;
#else
SLV2UIInstance _inst;
#endif
static void lv2_ui_write(
LV2UI_Controller controller,
uint32_t port_index,
uint32_t buffer_size,
uint32_t format,
const void* buffer);
void* controller,
uint32_t port_index,
uint32_t buffer_size,
uint32_t format,
const void* buffer);
void lv2ui_instantiate(const std::string& title);

241
gtk2_ardour/lv2_ui.h Normal file
View file

@ -0,0 +1,241 @@
/* LV2 UI Extension
* Copyright (C) 2006-2008 Lars Luthman <lars.luthman@gmail.com>
* Copyright (C) 2009-2010 David Robillard <d@drobilla.net>
*
* Based on lv2.h, which was
* Copyright (C) 2000-2002 Richard W.E. Furse, Paul Barton-Davis,
* Stefan Westerfeld
* Copyright (C) 2006 Steve Harris, David Robillard.
*
* This header is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation; either version 2.1 of the License,
* or (at your option) any later version.
*
* This header is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
* USA.
*
*/
/** @file
* C header for the LV2 UI extension <http://lv2plug.in/ns/extensions/ui>.
*/
#ifndef LV2_UI_H
#define LV2_UI_H
#include "lv2.h"
#define LV2_UI_URI "http://lv2plug.in/ns/extensions/ui"
#ifdef __cplusplus
extern "C" {
#endif
/** A pointer to some widget or other type of UI handle.
The actual type is defined by the type URI of the UI.
All the functionality provided by this extension is toolkit
independent, the host only needs to pass the necessary callbacks and
display the widget, if possible. Plugins may have several UIs, in various
toolkits. */
typedef void* LV2UI_Widget;
/** A pointer to a particular instance of a UI.
It is valid to compare this to NULL (0 for C++) but otherwise the
host MUST not attempt to interpret it. The UI plugin may use it to
reference internal instance data. */
typedef void* LV2UI_Handle;
/** A pointer to a particular plugin controller, provided by the host.
It is valid to compare this to NULL (0 for C++) but otherwise the
UI plugin MUST not attempt to interpret it. The host may use it to
reference internal instance data. */
typedef void* LV2UI_Controller;
/** The type of the host-provided function that the UI can use to
send data to a plugin's input ports. The @c buffer parameter must point
to a block of data, @c buffer_size bytes large. The contents of this buffer
and what the host should do with it depends on the value of the @c format
parameter.
The @c format parameter should either be 0 or a numeric ID for a "Transfer
mechanism". Transfer mechanisms are Features and may be defined in
meta-extensions. They specify how to translate the data buffers passed
to this function to input data for the plugin ports. If a UI wishes to
write data to an input port, it must list a transfer mechanism Feature
for that port's class as an optional or required feature (depending on
whether the UI will work without being able to write to that port or not).
The only exception is when the UI wants to write single float values to
input ports of the class lv2:ControlPort, in which case @c buffer_size
should always be 4, the buffer should always contain a single IEEE-754
float, and @c format should be 0.
The numeric IDs for the transfer mechanisms are provided by a
URI-to-integer mapping function provided by the host, using the URI Map
feature <http://lv2plug.in/ns/ext/uri-map> with the map URI
"http://lv2plug.in/ns/extensions/ui". Thus a UI that requires transfer
mechanism features also requires the URI Map feature, but this is
implicit - the UI does not have to list the URI map feature as a required
or optional feature in it's RDF data.
An UI MUST NOT pass a @c format parameter value (except 0) that has not
been returned by the host-provided URI mapping function for a
host-supported transfer mechanism feature URI.
The UI MUST NOT try to write to a port for which there is no specified
transfer mechanism, or to an output port. The UI is responsible for
allocating the buffer and deallocating it after the call.
*/
typedef void (*LV2UI_Write_Function)(LV2UI_Controller controller,
uint32_t port_index,
uint32_t buffer_size,
uint32_t format,
const void* buffer);
/** This struct contains the implementation of a UI. A pointer to an
object of this type is returned by the lv2ui_descriptor() function.
*/
typedef struct _LV2UI_Descriptor {
/** The URI for this UI (not for the plugin it controls). */
const char* URI;
/** Create a new UI object and return a handle to it. This function works
similarly to the instantiate() member in LV2_Descriptor.
@param descriptor The descriptor for the UI that you want to instantiate.
@param plugin_uri The URI of the plugin that this UI will control.
@param bundle_path The path to the bundle containing the RDF data file
that references this shared object file, including the
trailing '/'.
@param write_function A function provided by the host that the UI can
use to send data to the plugin's input ports.
@param controller A handle for the plugin instance that should be passed
as the first parameter of @c write_function.
@param widget A pointer to an LV2UI_Widget. The UI will write a
widget pointer to this location (what type of widget
depends on the RDF class of the UI) that will be the
main UI widget.
@param features An array of LV2_Feature pointers. The host must pass
all feature URIs that it and the UI supports and any
additional data, just like in the LV2 plugin
instantiate() function. Note that UI features and plugin
features are NOT necessarily the same, they just share
the same data structure - this will probably not be the
same array as the one the plugin host passes to a
plugin.
*/
LV2UI_Handle (*instantiate)(const struct _LV2UI_Descriptor* descriptor,
const char* plugin_uri,
const char* bundle_path,
LV2UI_Write_Function write_function,
LV2UI_Controller controller,
LV2UI_Widget* widget,
const LV2_Feature* const* features);
/** Destroy the UI object and the associated widget. The host must not try
to access the widget after calling this function.
*/
void (*cleanup)(LV2UI_Handle ui);
/** Tell the UI that something interesting has happened at a plugin port.
What is interesting and how it is written to the buffer passed to this
function is defined by the @c format parameter, which has the same
meaning as in LV2UI_Write_Function. The only exception is ports of the
class lv2:ControlPort, for which this function should be called
when the port value changes (it does not have to be called for every
single change if the host's UI thread has problems keeping up with the
thread the plugin is running in), @c buffer_size should be 4, the buffer
should contain a single IEEE-754 float, and @c format should be 0.
By default, the host should only call this function for input ports of
the lv2:ControlPort class. However, the default setting can be modified
by using the following URIs in the UI's RDF data:
<pre>
uiext:portNotification
uiext:noPortNotification
uiext:plugin
uiext:portIndex
</pre>
For example, if you want the UI with uri
<code><http://my.pluginui></code> for the plugin with URI
<code><http://my.plugin></code> to get notified when the value of the
output control port with index 4 changes, you would use the following
in the RDF for your UI:
<pre>
<http://my.pluginui> uiext:portNotification [ uiext:plugin <http://my.plugin> ;
uiext:portIndex 4 ] .
</pre>
and similarly with <code>uiext:noPortNotification</code> if you wanted
to prevent notifications for a port for which it would be on by default
otherwise. The UI is not allowed to request notifications for ports of
types for which no transfer mechanism is specified, if it does it should
be considered broken and the host should not load it.
The @c buffer is only valid during the time of this function call, so if
the UI wants to keep it for later use it has to copy the contents to an
internal buffer.
This member may be set to NULL if the UI is not interested in any
port events.
*/
void (*port_event)(LV2UI_Handle ui,
uint32_t port_index,
uint32_t buffer_size,
uint32_t format,
const void* buffer);
/** Returns a data structure associated with an extension URI, for example
a struct containing additional function pointers. Avoid returning
function pointers directly since standard C/C++ has no valid way of
casting a void* to a function pointer. This member may be set to NULL
if the UI is not interested in supporting any extensions. This is similar
to the extension_data() member in LV2_Descriptor.
*/
const void* (*extension_data)(const char* uri);
} LV2UI_Descriptor;
/** A plugin UI programmer must include a function called "lv2ui_descriptor"
with the following function prototype within the shared object
file. This function will have C-style linkage (if you are using
C++ this is taken care of by the 'extern "C"' clause at the top of
the file). This function will be accessed by the UI host using the
@c dlsym() function and called to get a LV2UI_UIDescriptor for the
wanted plugin.
Just like lv2_descriptor(), this function takes an index parameter. The
index should only be used for enumeration and not as any sort of ID number -
the host should just iterate from 0 and upwards until the function returns
NULL or a descriptor with an URI matching the one the host is looking for.
*/
const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index);
/** This is the type of the lv2ui_descriptor() function. */
typedef const LV2UI_Descriptor* (*LV2UI_DescriptorFunction)(uint32_t index);
#ifdef __cplusplus
}
#endif
#endif

2
libs/ardour/ardour/lv2_plugin.h
View file

@ -74,6 +74,7 @@ class LV2Plugin : public ARDOUR::Plugin
SLV2Plugin slv2_plugin () { return _plugin; }
SLV2UI slv2_ui () { return _ui; }
SLV2Value ui_type() { return _ui_type; }
SLV2Port slv2_port (uint32_t i) { return slv2_plugin_get_port_by_index (_plugin, i); }
bool is_external_ui () const;
@ -125,6 +126,7 @@ class LV2Plugin : public ARDOUR::Plugin
LV2_Feature** _features;
SLV2Plugin _plugin;
SLV2UI _ui;
SLV2Value _ui_type;
SLV2Value _name;
SLV2Value _author;
SLV2Instance _instance;

26
libs/ardour/lv2_plugin.cc
View file

@ -30,8 +30,11 @@
#include "pbd/compose.h"
#include "pbd/error.h"
#include "pbd/pathscanner.h"
#include "pbd/stl_delete.h"
#include "pbd/xml++.h"
#include "libardour-config.h"
#include "ardour/ardour.h"
#include "ardour/audio_buffer.h"
#include "ardour/audioengine.h"
@ -40,14 +43,15 @@
#include "ardour/lv2_plugin.h"
#include "ardour/session.h"
#include "pbd/stl_delete.h"
#include "i18n.h"
#include <locale.h>
#include "lv2ext/lv2_files.h"
#include "lv2ext/lv2_persist.h"
#include "rdff.h"
#ifdef HAVE_SUIL
#include <suil/suil.h>
#endif
#define NS_DC "http://dublincore.org/documents/dcmi-namespace/"
#define NS_LV2 "http://lv2plug.in/ns/lv2core#"
@ -98,6 +102,7 @@ LV2Plugin::init(LV2World& world, SLV2Plugin plugin, framecnt_t rate)
_world = world;
_plugin = plugin;
_ui = NULL;
_ui_type = NULL;
_control_data = 0;
_shadow_data = 0;
_latency_control_port = 0;
@ -202,6 +207,21 @@ LV2Plugin::init(LV2World& world, SLV2Plugin plugin, framecnt_t rate)
SLV2UIs uis = slv2_plugin_get_uis(_plugin);
if (slv2_uis_size(uis) > 0) {
#if defined(HAVE_NEW_SLV2) and defined(HAVE_SUIL)
// Look for embeddable UI
SLV2Value ui_type = NULL;
SLV2_FOREACH(u, uis) {
SLV2UI this_ui = slv2_uis_get(uis, u);
if (slv2_ui_is_supported(this_ui,
suil_ui_supported,
_world.gtk_gui,
&_ui_type)) {
// TODO: Multiple UI support
_ui = this_ui;
break;
}
}
#else
// Look for Gtk native UI
for (unsigned i = 0; i < slv2_uis_size(uis); ++i) {
SLV2UI ui = slv2_uis_get_at(uis, i);
@ -210,6 +230,7 @@ LV2Plugin::init(LV2World& world, SLV2Plugin plugin, framecnt_t rate)
break;
}
}
#endif
// If Gtk UI is not available, try to find external UI
if (!_ui) {
@ -236,6 +257,7 @@ LV2Plugin::~LV2Plugin ()
slv2_instance_free(_instance);
slv2_value_free(_name);
slv2_value_free(_author);
slv2_value_free(_ui_type);
delete [] _control_data;
delete [] _shadow_data;

3
libs/ardour/wscript
View file

@ -244,6 +244,7 @@ def configure(conf):
autowaf.check_pkg(conf, 'sigc++-2.0', uselib_store='SIGCPP', atleast_version='2.0')
autowaf.check_pkg(conf, 'slv2', uselib_store='SLV2', atleast_version='0.6.4', mandatory=False)
autowaf.check_pkg(conf, 'slv2', uselib_store='NEW_SLV2', atleast_version='0.7.0', mandatory=False)
autowaf.check_pkg(conf, 'suil', uselib_store='SUIL', atleast_version='0.1.0', mandatory=False)
autowaf.check_pkg(conf, 'rasqal', uselib_store='RASQAL', atleast_version='0.9.14', mandatory=False)
autowaf.check_pkg(conf, 'soundtouch-1.0', uselib_store='SOUNDTOUCH', mandatory=False)
autowaf.check_pkg(conf, 'cppunit', uselib_store='CPPUNIT', atleast_version='1.12.0', mandatory=False)
@ -330,6 +331,8 @@ def build(bld):
if bld.env['HAVE_SLV2']:
obj.source += [ 'lv2_plugin.cc', 'lv2_event_buffer.cc', 'uri_map.cc', 'rdff.c' ]
obj.uselib += ' SLV2 ' + ' RASQAL '
if bld.env['HAVE_SUIL']:
obj.uselib += ' SUIL '
if bld.env['VST_SUPPORT']:
obj.source += [ 'vst_plugin.cc', 'session_vst.cc' ]

2
wscript
View file

@ -534,6 +534,7 @@ def configure(conf):
if opts.freesound:
conf.define('FREESOUND',1)
autowaf.display_msg(conf, 'LV2 Support', bool(conf.env['HAVE_SLV2']))
autowaf.display_msg(conf, 'LV2 UI Embedding', bool(conf.env['HAVE_SUIL']))
autowaf.display_msg(conf, 'OGG', bool(conf.env['HAVE_OGG']))
autowaf.display_msg(conf, 'Rubberband', bool(conf.env['HAVE_RUBBERBAND']))
autowaf.display_msg(conf, 'Samplerate', bool(conf.env['HAVE_SAMPLERATE']))
@ -586,6 +587,7 @@ def configure(conf):
config_text.write ('Freedesktop files: '); config_text.write (str (opts.freedesktop)); config_text.write ("\\n\\\n")
config_text.write ('Freesound: '); config_text.write (str (opts.freesound)); config_text.write ("\\n\\\n")
config_text.write ('LV2 support: '); config_text.write (str (bool(conf.env['HAVE_SLV2']))); config_text.write ("\\n\\\n")
config_text.write ('LV2 UI embedding: '); config_text.write (str (bool(conf.env['HAVE_SUIL']))); config_text.write ("\\n\\\n")
config_text.write ('Rubberband: '); config_text.write (str (bool(conf.env['HAVE_RUBBERBAND']))); config_text.write ("\\n\\\n")
config_text.write ('Samplerate: '); config_text.write (str (bool(conf.env['HAVE_SAMPLERATE']))); config_text.write ("\\n\\\n")
config_text.write ('Soundtouch: '); config_text.write (str (bool(conf.env['HAVE_SOUNDTOUCH']))); config_text.write ("\\n\\\n")