LV2 support for Anklang

.gitmodules

@@ -22,3 +22,22 @@
 [submodule "websocketpp"]
 	path = external/websocketpp
 	url = https://github.com/zaphoyd/websocketpp.git
+# lilv and its dependencies
+[submodule "lilv"]
+	path = external/lilv
+	url = https://github.com/swesterfeld/lilv
+[submodule "lv2"]
+	path = external/lv2
+	url = https://github.com/drobilla/lv2.git
+[submodule "serd"]
+	path = external/serd
+	url = https://github.com/drobilla/serd.git
+[submodule "sord"]
+	path = external/sord
+	url = https://github.com/drobilla/sord.git
+[submodule "sratom"]
+	path = external/sratom
+	url = https://github.com/drobilla/sratom.git
+[submodule "zix"]
+	path = external/zix
+	url = https://github.com/drobilla/zix.git

ase/Makefile.mk

@@ -133,21 +133,35 @@ CLEANDIRS += $>/sndfile/
 CLEANFILES += $>/lib/libsndfile.*
 ase/sndfile.cc: $>/lib/libsndfile.so # includes $>/sndfile/src/config.h
 
+# == lilv ==
+$>/lib/liblilv-0.a: .submodule-stamp external/lilv/include/lilv/lilv.h | $>/lib/
+	$(QGEN)
+	$Q misc/build-lilv.sh $>
+
 # == AnklangSynthEngine ==
 ASE_EXTERNAL_INCLUDES := $(strip	\
 	-Iexternal/clap/include		\
 	-Iexternal/libsndfile/include	\
+	-Iexternal/lilv/include		\
 	-Iexternal/rapidjson/include	\
 	-Iexternal/websocketpp		\
 )
+LILV_LIBS := $(strip 					\
+	$>/lib/liblilv-0.a	\
+	$>/lib/libserd-0.a	\
+	$>/lib/libsord-0.a	\
+	$>/lib/libsratom-0.a	\
+	$>/lib/libzix-0.a	\
+)
+
 $(ase/AnklangSynthEngine.objects): $(ase/include.deps) $(ase/libase.deps)
 $(ase/AnklangSynthEngine.objects): EXTRA_INCLUDES ::= $(ASE_EXTERNAL_INCLUDES) -I$> -I$>/external/ $(ASEDEPS_CFLAGS)
-$(lib/AnklangSynthEngine): $>/lib/libsndfile.so					| $>/lib/
+$(lib/AnklangSynthEngine): $>/lib/libsndfile.so $>/lib/liblilv-0.a		| $>/lib/
 $(call BUILD_PROGRAM, \
 	$(lib/AnklangSynthEngine), \
 	$(ase/AnklangSynthEngine.objects), \
 	$(lib/libase.so), \
-	$(BOOST_SYSTEM_LIBS) $(ASEDEPS_LIBS) $(ALSA_LIBS) -lzstd -ldl $>/lib/libsndfile.so, \
+	$(BOOST_SYSTEM_LIBS) $(ASEDEPS_LIBS) $(ALSA_LIBS) -lzstd -ldl $(LILV_LIBS) $>/lib/libsndfile.so, \
 	../lib)
 # Work around legacy code in external/websocketpp/*.hpp
 ase/websocket.cc.FLAGS = -Wno-deprecated-dynamic-exception-spec -Wno-sign-promo

ase/clapplugin.cc

@@ -1971,12 +1971,21 @@ try_load_x11wrapper()
   return_unless (x11wrapper == nullptr);
   static Gtk2DlWrapEntry *gtk2wrapentry = [] () {
     String gtk2wrapso = anklang_runpath (RPath::LIBDIR, "gtk2wrap.so");
-    void *gtkdlhandle_ = dlopen (gtk2wrapso.c_str(), RTLD_LOCAL | RTLD_NOW);
+    void *gtkdlhandle_ = dlopen (gtk2wrapso.c_str(), RTLD_GLOBAL | RTLD_NOW);
     const char *symname = "Ase__Gtk2__wrapentry";
     void *ptr = gtkdlhandle_ ? dlsym (gtkdlhandle_, symname) : nullptr;
     return (Gtk2DlWrapEntry*) ptr;
   } ();
   x11wrapper = gtk2wrapentry;
+  if (x11wrapper)
+    TaskRegistry::set_gtk_thread_id (x11wrapper->gtk_thread_id());
+}
+
+Gtk2DlWrapEntry *
+get_x11wrapper()
+{
+  try_load_x11wrapper();
+  return x11wrapper;
 }
 
 // == ClapPluginHandle ==

ase/clapplugin.hh

@@ -4,6 +4,7 @@
 
 #include <ase/device.hh>
 #include <clap/clap.h>
+#include <ase/gtk2wrap.hh>
 
 namespace Ase {
 
@@ -96,6 +97,8 @@ const char* clap_event_type_string (int etype);
 String      clap_event_to_string   (const clap_event_note_t *enote);
 DeviceInfo  clap_device_info       (const ClapPluginDescriptor &descriptor);
 
+Gtk2DlWrapEntry *get_x11wrapper();
+
 } // Ase
 
 #endif // __ASE_CLAP_PLUGIN_HH__

ase/defs.hh

@@ -52,6 +52,7 @@ ASE_CLASS_DECLS (Emittable);
 ASE_CLASS_DECLS (FileCrawler);
 ASE_CLASS_DECLS (Gadget);
 ASE_CLASS_DECLS (GadgetImpl);
+ASE_CLASS_DECLS (LV2DeviceImpl);
 ASE_CLASS_DECLS (Monitor);
 ASE_CLASS_DECLS (NativeDevice);
 ASE_CLASS_DECLS (NativeDeviceImpl);

ase/gtk2wrap.cc

@@ -1,13 +1,19 @@
 // This Source Code Form is licensed MPL-2.0: http://mozilla.org/MPL/2.0
 #include "gtk2wrap.hh"
 #include <gtk/gtk.h>
+#include <suil/suil.h>
 #include <semaphore.h>
 #include <thread>
+#include <map>
+#include <cassert>
 
 namespace { // Anon
 using namespace Ase;
 
-static std::thread *gtkthred = nullptr;
+using std::string;
+
+static std::thread *gtk_thread = nullptr;
+static std::thread::id gtk_thread_id {};
 
 // == Semaphore ==
 class Semaphore {
@@ -96,6 +102,17 @@ create_window (const Gtk2WindowSetup &wsetup)
   return windowid;
 }
 
+static void *
+create_suil_window (const string &window_title, bool resizable, const std::function<void()>& deleterequest_mt)
+{
+  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_resizable (GTK_WINDOW (window), resizable);
+  BWrap *bw = vwrap (deleterequest_mt);
+  g_signal_connect_data (window, "delete-event", (GCallback) bw->truefunc, bw, (GClosureNotify) bw->deleter, G_CONNECT_SWAPPED);
+  gtk_window_set_title (GTK_WINDOW (window), window_title.c_str());
+  return window;
+}
+
 static bool
 destroy_window (ulong windowid)
 {
@@ -137,11 +154,71 @@ hide_window (ulong windowid)
   return true;
 }
 
+static std::thread::id
+get_gtk_thread_id()
+{
+  return std::this_thread::get_id();
+}
+
+struct TimerHelper
+{
+  std::function<bool()> callback;
+  guint id = 0;
+};
+
+std::map<guint, std::unique_ptr<TimerHelper>> timer_helper_map;
+
+static guint
+register_timer (const std::function<bool()>& callback, guint interval_ms)
+{
+  auto timer_helper_ptr = std::make_unique<TimerHelper> (callback, 0);
+
+  guint id = g_timeout_add (interval_ms,
+    [] (gpointer data) -> int
+      {
+        TimerHelper *helper = (TimerHelper *) data;
+        auto again = helper->callback();
+        if (!again)
+          timer_helper_map.erase (helper->id);
+        return again;
+      },
+    timer_helper_ptr.get());
+
+  timer_helper_ptr->id = id;
+  timer_helper_map[id] = std::move (timer_helper_ptr);
+  return id;
+}
+
+static bool
+remove_timer (uint timer_id)
+{
+  if (timer_helper_map.erase (timer_id) != 1)
+    fprintf (stderr, "Gtk2Wrap: removing timer callback id=%u from map failed\n", timer_id);
+
+  if (g_source_remove (timer_id))
+    return true;
+
+  fprintf (stderr, "Gtk2Wrap: removing timer with id=%u failed", timer_id);
+  return false;
+}
+
+static bool
+exec_in_gtk_thread (const std::function<void()>& func)
+{
+  func();
+  return true;
+}
+
 template<typename Ret, typename ...Args, typename ...Params> static Ret
 gtkidle_call (Ret (*func) (Params...), Args &&...args)
 {
-  if (!gtkthred)        // FIXME: need thread cleanup
-    gtkthred = new std::thread (gtkmain);
+  if (!gtk_thread)        // FIXME: need thread cleanup
+    {
+      gtk_thread = new std::thread (gtkmain);
+      gtk_thread_id = gtk_thread->get_id();
+    }
+  // using this function from gtk thread would block execution (and never return)
+  assert (std::this_thread::get_id() != gtk_thread_id);
   Semaphore sem;
   Ret ret = {};
   BWrap *bw = bwrap ([&sem, &ret, func, &args...] () -> bool {
@@ -157,6 +234,12 @@ gtkidle_call (Ret (*func) (Params...), Args &&...args)
   return ret;
 }
 
+void
+check_gtk_thread()
+{
+  assert (std::this_thread::get_id() == gtk_thread_id);
+}
+
 } // Anon
 
 extern "C" {
@@ -178,5 +261,63 @@ Ase::Gtk2DlWrapEntry Ase__Gtk2__wrapentry {
   },
   .threads_enter = gdk_threads_enter,
   .threads_leave = gdk_threads_leave,
+  .gtk_thread_id = [] () -> std::thread::id {
+    return gtkidle_call (get_gtk_thread_id);
+  },
+  .register_timer = [] (const std::function<bool()>& callback, uint interval_ms) -> uint {
+    check_gtk_thread();
+    return register_timer (callback, interval_ms);
+  },
+  .remove_timer = [] (uint timer_id) -> bool {
+    check_gtk_thread();
+    return remove_timer (timer_id);
+  },
+  .exec_in_gtk_thread = [] (const std::function<void()>& func) {
+    gtkidle_call (exec_in_gtk_thread, func);
+  },
+  .create_suil_host = [] (SPortWriteFunc write_func, SPortIndexFunc index_func) -> void * {
+    return gtkidle_call (suil_host_new, write_func, index_func, nullptr, nullptr);
+  },
+  .create_suil_instance = [] (void *host, void *controller,
+                              const string &container_type_uri, const string &plugin_uri,
+                              const string &ui_uri, const string &ui_type_uri,
+                              const string &ui_bundle_path, const string &ui_binary_path,
+                              const LV2_Feature *const *features) -> void * {
+    check_gtk_thread();
+    return suil_instance_new ((SuilHost *) host, (SuilController *) controller,
+                              container_type_uri.c_str(), plugin_uri.c_str(),
+                              ui_uri.c_str(), ui_type_uri.c_str(),
+                              ui_bundle_path.c_str(), ui_binary_path.c_str(),
+                              features);
+  },
+  .destroy_suil_instance = [] (void *instance) {
+    check_gtk_thread();
+    suil_instance_free ((SuilInstance *) instance);
+  },
+  .create_suil_window = [] (const string &window_title, bool resizable, const std::function<void()>& deleterequest_mt) -> void * {
+    check_gtk_thread();
+    return create_suil_window (window_title, resizable, deleterequest_mt);
+  },
+  .add_suil_widget_to_window = [] (void *window, void *instance) {
+    check_gtk_thread();
+    gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (suil_instance_get_widget ((SuilInstance *) instance)));
+    gtk_widget_show_all (GTK_WIDGET (window));
+  },
+  .destroy_suil_window = [] (void *window) -> void {
+    check_gtk_thread();
+    gtk_widget_destroy (GTK_WIDGET (window));
+  },
+  .suil_ui_supported = [] (const string& host_type_uri, const string& ui_type_uri) -> unsigned {
+    check_gtk_thread();
+    return suil_ui_supported (host_type_uri.c_str(), ui_type_uri.c_str());
+  },
+  .suil_instance_port_event = [] (void *instance, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void *buffer) {
+    check_gtk_thread();
+    return suil_instance_port_event ((SuilInstance *) instance, port_index, buffer_size, format, buffer);
+  },
+  .get_suil_widget = [] (void *instance) {
+    check_gtk_thread();
+    return suil_instance_get_widget ((SuilInstance *) instance);
+  }
 };
 } // "C"

ase/gtk2wrap.hh

@@ -4,6 +4,9 @@
 
 #include <string>
 #include <functional>
+#include <thread>
+
+#include <lv2/core/lv2.h>
 
 namespace Ase {
 
@@ -13,14 +16,34 @@ struct Gtk2WindowSetup {
   std::function<void()> deleterequest_mt;
 };
 
+typedef void (*SPortWriteFunc) (void *controller, uint32_t port_index, uint32_t buffer_size, uint32_t protocol, void const* buffer);
+typedef uint32_t (*SPortIndexFunc) (void *controller, const char* port_symbol);
+
 struct Gtk2DlWrapEntry {
-  ulong (*create_window)  (const Gtk2WindowSetup &windowsetup);
-  bool  (*resize_window)  (ulong windowid, int width, int height);
-  void  (*show_window)    (ulong windowid);
-  void  (*hide_window)    (ulong windowid);
-  void  (*destroy_window) (ulong windowid);
-  void  (*threads_enter) ();
-  void  (*threads_leave) ();
+  ulong (*create_window)              (const Gtk2WindowSetup &windowsetup);
+  bool  (*resize_window)              (ulong windowid, int width, int height);
+  void  (*show_window)                (ulong windowid);
+  void  (*hide_window)                (ulong windowid);
+  void  (*destroy_window)             (ulong windowid);
+  void  (*threads_enter)              ();
+  void  (*threads_leave)              ();
+  std::thread::id (*gtk_thread_id)    ();
+  uint  (*register_timer)             (const std::function<bool()>& callback, uint interval_ms);
+  bool  (*remove_timer)               (uint timer_id);
+  void  (*exec_in_gtk_thread)         (const std::function<void()>& func);
+  void *(*create_suil_host)           (SPortWriteFunc write_func, SPortIndexFunc index_func);
+  void *(*create_suil_instance)       (void *host, void *controller,
+                                       const std::string &container_type_uri, const std::string &plugin_uri,
+                                       const std::string &ui_uri, const std::string &ui_type_uri,
+                                       const std::string &ui_bundle_path, const std::string &ui_binary_path,
+                                       const LV2_Feature *const *features);
+  void  (*destroy_suil_instance)      (void *instance);
+  void *(*create_suil_window)         (const std::string &window_title, bool resizable, const std::function<void()>& deleterequest_mt);
+  void  (*add_suil_widget_to_window)  (void *window, void *instance);
+  void  (*destroy_suil_window)        (void *window);
+  uint  (*suil_ui_supported)          (const std::string& host_type_uri, const std::string& ui_type_uri);
+  void  (*suil_instance_port_event)   (void *instance, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void *buffer);
+  void *(*get_suil_widget)            (void *instance);
 };
 
 } // Ase