commit a4f511c6189fe37e6c22e2d3e16f1c84e490a413
parent 50c448bc361b9ea2aa9ca86ba70546125e86c789
Author: falkTX <falktx@falktx.com>
Date: Sat, 12 Jun 2021 15:15:36 +0100
Switch to use jackbridge instead of direct link to libjack
Diffstat:
7 files changed, 2930 insertions(+), 54 deletions(-)
diff --git a/distrho/DistrhoPluginMain.cpp b/distrho/DistrhoPluginMain.cpp
@@ -19,7 +19,7 @@
#if defined(DISTRHO_PLUGIN_TARGET_CARLA)
# include "src/DistrhoPluginCarla.cpp"
#elif defined(DISTRHO_PLUGIN_TARGET_JACK)
-# include "src/DistrhoPluginJack.cpp"
+# include "src/DistrhoPluginJACK.cpp"
#elif (defined(DISTRHO_PLUGIN_TARGET_LADSPA) || defined(DISTRHO_PLUGIN_TARGET_DSSI))
# include "src/DistrhoPluginLADSPA+DSSI.cpp"
#elif defined(DISTRHO_PLUGIN_TARGET_LV2)
diff --git a/distrho/extra/LibraryUtils.hpp b/distrho/extra/LibraryUtils.hpp
@@ -0,0 +1,120 @@
+/*
+ * DISTRHO Plugin Framework (DPF)
+ * Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with
+ * or without fee is hereby granted, provided that the above copyright notice and this
+ * permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+ * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
+ * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef DISTRHO_LIBRARY_UTILS_HPP_INCLUDED
+#define DISTRHO_LIBRARY_UTILS_HPP_INCLUDED
+
+#include "../DistrhoUtils.hpp"
+
+#ifdef DISTRHO_OS_WINDOWS
+typedef HMODULE lib_t;
+#else
+# include <dlfcn.h>
+typedef void* lib_t;
+#endif
+
+// -----------------------------------------------------------------------
+// library related calls
+
+/*
+ * Open 'filename' library (must not be null).
+ * May return null, in which case "lib_error" has the error.
+ */
+static inline
+lib_t lib_open(const char* const filename) noexcept
+{
+ DISTRHO_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', nullptr);
+
+ try {
+#ifdef DISTRHO_OS_WINDOWS
+ return ::LoadLibraryA(filename);
+#else
+ return ::dlopen(filename, RTLD_NOW|RTLD_LOCAL);
+#endif
+ } DISTRHO_SAFE_EXCEPTION_RETURN("lib_open", nullptr);
+}
+
+/*
+ * Close a previously opened library (must not be null).
+ * If false is returned, "lib_error" has the error.
+ */
+static inline
+bool lib_close(const lib_t lib) noexcept
+{
+ DISTRHO_SAFE_ASSERT_RETURN(lib != nullptr, false);
+
+ try {
+#ifdef DISTRHO_OS_WINDOWS
+ return ::FreeLibrary(lib);
+#else
+ return (::dlclose(lib) == 0);
+#endif
+ } DISTRHO_SAFE_EXCEPTION_RETURN("lib_close", false);
+}
+
+/*
+ * Get a library symbol (must not be null).
+ * Returns null if the symbol is not found.
+ */
+template<typename Func>
+static inline
+Func lib_symbol(const lib_t lib, const char* const symbol) noexcept
+{
+ DISTRHO_SAFE_ASSERT_RETURN(lib != nullptr, nullptr);
+ DISTRHO_SAFE_ASSERT_RETURN(symbol != nullptr && symbol[0] != '\0', nullptr);
+
+ try {
+#ifdef DISTRHO_OS_WINDOWS
+ return (Func)::GetProcAddress(lib, symbol);
+#else
+ return (Func)(uintptr_t)::dlsym(lib, symbol);
+#endif
+ } DISTRHO_SAFE_EXCEPTION_RETURN("lib_symbol", nullptr);
+}
+
+/*
+ * Return the last operation error ('filename' must not be null).
+ * May return null.
+ */
+static inline
+const char* lib_error(const char* const filename) noexcept
+{
+ DISTRHO_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', nullptr);
+
+#ifdef DISTRHO_OS_WINDOWS
+ static char libError[2048+1];
+ std::memset(libError, 0, sizeof(libError));
+
+ try {
+ const DWORD winErrorCode = ::GetLastError();
+ const int winErrorFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS;
+ LPVOID winErrorString;
+
+ ::FormatMessage(winErrorFlags, nullptr, winErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&winErrorString, 0, nullptr);
+
+ std::snprintf(libError, 2048, "%s: error code %li: %s", filename, winErrorCode, (const char*)winErrorString);
+ ::LocalFree(winErrorString);
+ } DISTRHO_SAFE_EXCEPTION("lib_error");
+
+ return (libError[0] != '\0') ? libError : nullptr;
+#else
+ return ::dlerror();
+#endif
+}
+
+// -----------------------------------------------------------------------
+
+#endif // DISTRHO_LIBRARY_UTILS_HPP_INCLUDED
diff --git a/distrho/src/DistrhoPluginJACK.cpp b/distrho/src/DistrhoPluginJACK.cpp
@@ -23,11 +23,7 @@
# include "../extra/Sleep.hpp"
#endif
-#include "jack/jack.h"
-#include "jack/metadata.h"
-#include "jack/midiport.h"
-#include "jack/transport.h"
-#include "jack/uuid.h"
+#include "jackbridge/JackBridge1.cpp"
#include "lv2/lv2.h"
#ifndef DISTRHO_OS_WINDOWS
@@ -38,6 +34,10 @@
# define JACK_METADATA_ORDER "http://jackaudio.org/metadata/order"
#endif
+#ifndef JACK_METADATA_PRETTY_NAME
+# define JACK_METADATA_PRETTY_NAME "http://jackaudio.org/metadata/pretty-name"
+#endif
+
#ifndef JACK_METADATA_SIGNAL_TYPE
# define JACK_METADATA_SIGNAL_TYPE "http://jackaudio.org/metadata/signal-type"
#endif
@@ -132,7 +132,7 @@ public:
for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i)
{
const AudioPort& port(fPlugin.getAudioPort(true, i));
- fPortAudioIns[i] = jack_port_register(fClient, port.symbol, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
+ fPortAudioIns[i] = jackbridge_port_register(fClient, port.symbol, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
setAudioPortMetadata(port, fPortAudioIns[i], i);
}
# endif
@@ -141,16 +141,16 @@ public:
{
std::snprintf(strBuf, 0xff, "out%i", i+1);
const AudioPort& port(fPlugin.getAudioPort(false, i));
- fPortAudioOuts[i] = jack_port_register(fClient, port.symbol, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
+ fPortAudioOuts[i] = jackbridge_port_register(fClient, port.symbol, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
setAudioPortMetadata(port, fPortAudioOuts[i], DISTRHO_PLUGIN_NUM_INPUTS+i);
}
# endif
#endif
- fPortEventsIn = jack_port_register(fClient, "events-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
+ fPortEventsIn = jackbridge_port_register(fClient, "events-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
#if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT
- fPortMidiOut = jack_port_register(fClient, "midi-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
+ fPortMidiOut = jackbridge_port_register(fClient, "midi-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
fPortMidiOutBuffer = nullptr;
#endif
@@ -193,17 +193,17 @@ public:
#endif
}
- jack_set_buffer_size_callback(fClient, jackBufferSizeCallback, this);
- jack_set_sample_rate_callback(fClient, jackSampleRateCallback, this);
- jack_set_process_callback(fClient, jackProcessCallback, this);
- jack_on_shutdown(fClient, jackShutdownCallback, this);
+ jackbridge_set_buffer_size_callback(fClient, jackBufferSizeCallback, this);
+ jackbridge_set_sample_rate_callback(fClient, jackSampleRateCallback, this);
+ jackbridge_set_process_callback(fClient, jackProcessCallback, this);
+ jackbridge_on_shutdown(fClient, jackShutdownCallback, this);
fPlugin.activate();
- jack_activate(fClient);
+ jackbridge_activate(fClient);
#if DISTRHO_PLUGIN_HAS_UI
- if (const char* const name = jack_get_client_name(fClient))
+ if (const char* const name = jackbridge_get_client_name(fClient))
fUI.setWindowTitle(name);
else
fUI.setWindowTitle(fPlugin.getName());
@@ -218,7 +218,7 @@ public:
~PluginJack()
{
if (fClient != nullptr)
- jack_deactivate(fClient);
+ jackbridge_deactivate(fClient);
if (fLastOutputValues != nullptr)
{
@@ -240,17 +240,17 @@ public:
return;
#if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT
- jack_port_unregister(fClient, fPortMidiOut);
+ jackbridge_port_unregister(fClient, fPortMidiOut);
fPortMidiOut = nullptr;
#endif
- jack_port_unregister(fClient, fPortEventsIn);
+ jackbridge_port_unregister(fClient, fPortEventsIn);
fPortEventsIn = nullptr;
#if DISTRHO_PLUGIN_NUM_INPUTS > 0
for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i)
{
- jack_port_unregister(fClient, fPortAudioIns[i]);
+ jackbridge_port_unregister(fClient, fPortAudioIns[i]);
fPortAudioIns[i] = nullptr;
}
#endif
@@ -258,12 +258,12 @@ public:
#if DISTRHO_PLUGIN_NUM_OUTPUTS > 0
for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)
{
- jack_port_unregister(fClient, fPortAudioOuts[i]);
+ jackbridge_port_unregister(fClient, fPortAudioOuts[i]);
fPortAudioOuts[i] = nullptr;
}
#endif
- jack_client_close(fClient);
+ jackbridge_client_close(fClient);
}
// -------------------------------------------------------------------
@@ -322,7 +322,7 @@ protected:
const float* audioIns[DISTRHO_PLUGIN_NUM_INPUTS];
for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_INPUTS; ++i)
- audioIns[i] = (const float*)jack_port_get_buffer(fPortAudioIns[i], nframes);
+ audioIns[i] = (const float*)jackbridge_port_get_buffer(fPortAudioIns[i], nframes);
#else
static const float** audioIns = nullptr;
#endif
@@ -331,20 +331,20 @@ protected:
float* audioOuts[DISTRHO_PLUGIN_NUM_OUTPUTS];
for (uint32_t i=0; i < DISTRHO_PLUGIN_NUM_OUTPUTS; ++i)
- audioOuts[i] = (float*)jack_port_get_buffer(fPortAudioOuts[i], nframes);
+ audioOuts[i] = (float*)jackbridge_port_get_buffer(fPortAudioOuts[i], nframes);
#else
static float** audioOuts = nullptr;
#endif
#if DISTRHO_PLUGIN_WANT_TIMEPOS
jack_position_t pos;
- fTimePosition.playing = (jack_transport_query(fClient, &pos) == JackTransportRolling);
+ fTimePosition.playing = (jackbridge_transport_query(fClient, &pos) == JackTransportRolling);
if (pos.unique_1 == pos.unique_2)
{
fTimePosition.frame = pos.frame;
- if (pos.valid & JackTransportBBT)
+ if (pos.valid & JackPositionBBT)
{
fTimePosition.bbt.valid = true;
@@ -374,8 +374,8 @@ protected:
updateParameterTriggers();
#if DISTRHO_PLUGIN_WANT_MIDI_OUTPUT
- fPortMidiOutBuffer = jack_port_get_buffer(fPortMidiOut, nframes);
- jack_midi_clear_buffer(fPortMidiOutBuffer);
+ fPortMidiOutBuffer = jackbridge_port_get_buffer(fPortMidiOut, nframes);
+ jackbridge_midi_clear_buffer(fPortMidiOutBuffer);
#endif
#if DISTRHO_PLUGIN_WANT_MIDI_INPUT
@@ -402,15 +402,15 @@ protected:
static const uint32_t midiEventCount = 0;
#endif
- void* const midiInBuf = jack_port_get_buffer(fPortEventsIn, nframes);
+ void* const midiInBuf = jackbridge_port_get_buffer(fPortEventsIn, nframes);
- if (const uint32_t eventCount = std::max(512u - midiEventCount, jack_midi_get_event_count(midiInBuf)))
+ if (const uint32_t eventCount = std::max(512u - midiEventCount, jackbridge_midi_get_event_count(midiInBuf)))
{
jack_midi_event_t jevent;
for (uint32_t i=0; i < eventCount; ++i)
{
- if (jack_midi_event_get(&jevent, midiInBuf, i) != 0)
+ if (jackbridge_midi_event_get(&jevent, midiInBuf, i) != 0)
break;
// Check if message is control change on channel 1
@@ -575,26 +575,26 @@ private:
{
DISTRHO_SAFE_ASSERT_RETURN(jackport != nullptr,);
- const jack_uuid_t uuid = jack_port_uuid(jackport);
+ const jack_uuid_t uuid = jackbridge_port_uuid(jackport);
- if (jack_uuid_empty(uuid))
+ if (uuid == JACK_UUID_EMPTY_INITIALIZER)
return;
- jack_set_property(fClient, uuid, JACK_METADATA_PRETTY_NAME, port.name, "text/plain");
+ jackbridge_set_property(fClient, uuid, JACK_METADATA_PRETTY_NAME, port.name, "text/plain");
{
char strBuf[0xff];
snprintf(strBuf, sizeof(0xff)-1, "%u", index);
- jack_set_property(fClient, uuid, JACK_METADATA_ORDER, strBuf, "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, JACK_METADATA_ORDER, strBuf, "http://www.w3.org/2001/XMLSchema#integer");
}
if (port.hints & kAudioPortIsCV)
{
- jack_set_property(fClient, uuid, JACK_METADATA_SIGNAL_TYPE, "CV", "text/plain");
+ jackbridge_set_property(fClient, uuid, JACK_METADATA_SIGNAL_TYPE, "CV", "text/plain");
}
else
{
- jack_set_property(fClient, uuid, JACK_METADATA_SIGNAL_TYPE, "AUDIO", "text/plain");
+ jackbridge_set_property(fClient, uuid, JACK_METADATA_SIGNAL_TYPE, "AUDIO", "text/plain");
return;
}
@@ -605,39 +605,39 @@ private:
{
if (cvPortScaled)
{
- jack_set_property(fClient, uuid, LV2_CORE__minimum, "-5", "http://www.w3.org/2001/XMLSchema#integer");
- jack_set_property(fClient, uuid, LV2_CORE__maximum, "5", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__minimum, "-5", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__maximum, "5", "http://www.w3.org/2001/XMLSchema#integer");
}
else
{
- jack_set_property(fClient, uuid, LV2_CORE__minimum, "-1", "http://www.w3.org/2001/XMLSchema#integer");
- jack_set_property(fClient, uuid, LV2_CORE__maximum, "1", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__minimum, "-1", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__maximum, "1", "http://www.w3.org/2001/XMLSchema#integer");
}
}
else if (port.hints & kCVPortHasNegativeUnipolarRange)
{
if (cvPortScaled)
{
- jack_set_property(fClient, uuid, LV2_CORE__minimum, "-10", "http://www.w3.org/2001/XMLSchema#integer");
- jack_set_property(fClient, uuid, LV2_CORE__maximum, "0", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__minimum, "-10", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__maximum, "0", "http://www.w3.org/2001/XMLSchema#integer");
}
else
{
- jack_set_property(fClient, uuid, LV2_CORE__minimum, "-1", "http://www.w3.org/2001/XMLSchema#integer");
- jack_set_property(fClient, uuid, LV2_CORE__maximum, "0", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__minimum, "-1", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__maximum, "0", "http://www.w3.org/2001/XMLSchema#integer");
}
}
else if (port.hints & kCVPortHasPositiveUnipolarRange)
{
if (cvPortScaled)
{
- jack_set_property(fClient, uuid, LV2_CORE__minimum, "0", "http://www.w3.org/2001/XMLSchema#integer");
- jack_set_property(fClient, uuid, LV2_CORE__maximum, "10", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__minimum, "0", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__maximum, "10", "http://www.w3.org/2001/XMLSchema#integer");
}
else
{
- jack_set_property(fClient, uuid, LV2_CORE__minimum, "0", "http://www.w3.org/2001/XMLSchema#integer");
- jack_set_property(fClient, uuid, LV2_CORE__maximum, "1", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__minimum, "0", "http://www.w3.org/2001/XMLSchema#integer");
+ jackbridge_set_property(fClient, uuid, LV2_CORE__maximum, "1", "http://www.w3.org/2001/XMLSchema#integer");
}
}
}
@@ -738,7 +738,7 @@ int main()
USE_NAMESPACE_DISTRHO;
jack_status_t status = jack_status_t(0x0);
- jack_client_t* client = jack_client_open(DISTRHO_PLUGIN_NAME, JackNoStartServer, &status);
+ jack_client_t* client = jackbridge_client_open(DISTRHO_PLUGIN_NAME, JackNoStartServer, &status);
if (client == nullptr)
{
@@ -786,8 +786,8 @@ int main()
initSignalHandler();
- d_lastBufferSize = jack_get_buffer_size(client);
- d_lastSampleRate = jack_get_sample_rate(client);
+ d_lastBufferSize = jackbridge_get_buffer_size(client);
+ d_lastSampleRate = jackbridge_get_sample_rate(client);
d_lastCanRequestParameterValueChanges = true;
const PluginJack p(client);
diff --git a/distrho/src/jackbridge/JackBridge.cpp b/distrho/src/jackbridge/JackBridge.cpp
@@ -0,0 +1,2079 @@
+/*
+ * JackBridge for DPF
+ * Copyright (C) 2013-2021 Filipe Coelho <falktx@falktx.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with
+ * or without fee is hereby granted, provided that the above copyright notice and this
+ * permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+ * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
+ * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "JackBridge.hpp"
+
+#if ! (defined(JACKBRIDGE_DIRECT) || defined(JACKBRIDGE_DUMMY))
+
+#ifdef __WINE__
+# include <windows.h>
+# include <pthread.h>
+#endif
+
+#if defined(DISTRHO_OS_WINDOWS) && ! defined(__WINE__)
+# define JACKSYM_API __cdecl
+#else
+# define JACKSYM_API
+#endif
+
+#include <cerrno>
+#include "../../extra/LibraryUtils.hpp"
+
+// -----------------------------------------------------------------------------
+
+extern "C" {
+
+typedef void (JACKSYM_API *JackSymLatencyCallback)(jack_latency_callback_mode_t, void*);
+typedef int (JACKSYM_API *JackSymProcessCallback)(jack_nframes_t, void*);
+typedef void (JACKSYM_API *JackSymThreadInitCallback)(void*);
+typedef int (JACKSYM_API *JackSymGraphOrderCallback)(void*);
+typedef int (JACKSYM_API *JackSymXRunCallback)(void*);
+typedef int (JACKSYM_API *JackSymBufferSizeCallback)(jack_nframes_t, void*);
+typedef int (JACKSYM_API *JackSymSampleRateCallback)(jack_nframes_t, void*);
+typedef void (JACKSYM_API *JackSymPortRegistrationCallback)(jack_port_id_t, int, void*);
+typedef void (JACKSYM_API *JackSymClientRegistrationCallback)(const char*, int, void*);
+typedef void (JACKSYM_API *JackSymPortConnectCallback)(jack_port_id_t, jack_port_id_t, int, void*);
+typedef void (JACKSYM_API *JackSymPortRenameCallback)(jack_port_id_t, const char*, const char*, void*);
+typedef void (JACKSYM_API *JackSymFreewheelCallback)(int, void*);
+typedef void (JACKSYM_API *JackSymShutdownCallback)(void*);
+typedef void (JACKSYM_API *JackSymInfoShutdownCallback)(jack_status_t, const char*, void*);
+typedef int (JACKSYM_API *JackSymSyncCallback)(jack_transport_state_t, jack_position_t*, void*);
+typedef void (JACKSYM_API *JackSymTimebaseCallback)(jack_transport_state_t, jack_nframes_t, jack_position_t*, int, void*);
+typedef void (JACKSYM_API *JackSymSessionCallback)(jack_session_event_t*, void*);
+typedef void (JACKSYM_API *JackSymPropertyChangeCallback)(jack_uuid_t, const char*, jack_property_change_t, void*);
+
+typedef void (JACKSYM_API *jacksym_get_version)(int*, int*, int*, int*);
+typedef const char* (JACKSYM_API *jacksym_get_version_string)(void);
+
+typedef jack_client_t* (JACKSYM_API *jacksym_client_open)(const char*, jack_options_t, jack_status_t*, ...);
+typedef int (JACKSYM_API *jacksym_client_close)(jack_client_t*);
+
+typedef int (JACKSYM_API *jacksym_client_name_size)(void);
+typedef char* (JACKSYM_API *jacksym_get_client_name)(jack_client_t*);
+
+typedef char* (JACKSYM_API *jacksym_client_get_uuid)(jack_client_t*);
+typedef char* (JACKSYM_API *jacksym_get_uuid_for_client_name)(jack_client_t*, const char*);
+typedef char* (JACKSYM_API *jacksym_get_client_name_by_uuid)(jack_client_t*, const char*);
+
+typedef int (JACKBRIDGE_API *jacksym_uuid_parse)(const char*, jack_uuid_t*);
+typedef void (JACKBRIDGE_API *jacksym_uuid_unparse)(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);
+
+typedef int (JACKSYM_API *jacksym_activate)(jack_client_t*);
+typedef int (JACKSYM_API *jacksym_deactivate)(jack_client_t*);
+typedef int (JACKSYM_API *jacksym_is_realtime)(jack_client_t*);
+
+typedef int (JACKSYM_API *jacksym_set_thread_init_callback)(jack_client_t*, JackSymThreadInitCallback, void*);
+typedef void (JACKSYM_API *jacksym_on_shutdown)(jack_client_t*, JackSymShutdownCallback, void*);
+typedef void (JACKSYM_API *jacksym_on_info_shutdown)(jack_client_t*, JackSymInfoShutdownCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_process_callback)(jack_client_t*, JackSymProcessCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_freewheel_callback)(jack_client_t*, JackSymFreewheelCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_buffer_size_callback)(jack_client_t*, JackSymBufferSizeCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_sample_rate_callback)(jack_client_t*, JackSymSampleRateCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_client_registration_callback)(jack_client_t*, JackSymClientRegistrationCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_port_registration_callback)(jack_client_t*, JackSymPortRegistrationCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_port_rename_callback)(jack_client_t*, JackSymPortRenameCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_port_connect_callback)(jack_client_t*, JackSymPortConnectCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_graph_order_callback)(jack_client_t*, JackSymGraphOrderCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_xrun_callback)(jack_client_t*, JackSymXRunCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_latency_callback)(jack_client_t*, JackSymLatencyCallback, void*);
+
+typedef int (JACKSYM_API *jacksym_set_freewheel)(jack_client_t*, int);
+typedef int (JACKSYM_API *jacksym_set_buffer_size)(jack_client_t*, jack_nframes_t);
+
+typedef jack_nframes_t (JACKSYM_API *jacksym_get_sample_rate)(jack_client_t*);
+typedef jack_nframes_t (JACKSYM_API *jacksym_get_buffer_size)(jack_client_t*);
+typedef float (JACKSYM_API *jacksym_cpu_load)(jack_client_t*);
+
+typedef jack_port_t* (JACKSYM_API *jacksym_port_register)(jack_client_t*, const char*, const char*, ulong, ulong);
+typedef int (JACKSYM_API *jacksym_port_unregister)(jack_client_t*, jack_port_t*);
+typedef void* (JACKSYM_API *jacksym_port_get_buffer)(jack_port_t*, jack_nframes_t);
+
+typedef const char* (JACKSYM_API *jacksym_port_name)(const jack_port_t*);
+typedef jack_uuid_t (JACKSYM_API *jacksym_port_uuid)(const jack_port_t*);
+typedef const char* (JACKSYM_API *jacksym_port_short_name)(const jack_port_t*);
+typedef int (JACKSYM_API *jacksym_port_flags)(const jack_port_t*);
+typedef const char* (JACKSYM_API *jacksym_port_type)(const jack_port_t*);
+typedef int (JACKSYM_API *jacksym_port_is_mine)(const jack_client_t*, const jack_port_t*);
+typedef int (JACKSYM_API *jacksym_port_connected)(const jack_port_t*);
+typedef int (JACKSYM_API *jacksym_port_connected_to)(const jack_port_t*, const char*);
+typedef const char** (JACKSYM_API *jacksym_port_get_connections)(const jack_port_t*);
+typedef const char** (JACKSYM_API *jacksym_port_get_all_connections)(const jack_client_t*, const jack_port_t*);
+
+typedef int (JACKSYM_API *jacksym_port_rename)(jack_client_t*, jack_port_t*, const char*);
+typedef int (JACKSYM_API *jacksym_port_set_name)(jack_port_t*, const char*);
+typedef int (JACKSYM_API *jacksym_port_set_alias)(jack_port_t*, const char*);
+typedef int (JACKSYM_API *jacksym_port_unset_alias)(jack_port_t*, const char*);
+typedef int (JACKSYM_API *jacksym_port_get_aliases)(const jack_port_t*, char* const aliases[2]);
+
+typedef int (JACKSYM_API *jacksym_port_request_monitor)(jack_port_t*, int);
+typedef int (JACKSYM_API *jacksym_port_request_monitor_by_name)(jack_client_t*, const char*, int);
+typedef int (JACKSYM_API *jacksym_port_ensure_monitor)(jack_port_t*, int);
+typedef int (JACKSYM_API *jacksym_port_monitoring_input)(jack_port_t*);
+
+typedef int (JACKSYM_API *jacksym_connect)(jack_client_t*, const char*, const char*);
+typedef int (JACKSYM_API *jacksym_disconnect)(jack_client_t*, const char*, const char*);
+typedef int (JACKSYM_API *jacksym_port_disconnect)(jack_client_t*, jack_port_t*);
+
+typedef int (JACKSYM_API *jacksym_port_name_size)(void);
+typedef int (JACKSYM_API *jacksym_port_type_size)(void);
+typedef size_t (JACKSYM_API *jacksym_port_type_get_buffer_size)(jack_client_t*, const char*);
+
+typedef void (JACKSYM_API *jacksym_port_get_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);
+typedef void (JACKSYM_API *jacksym_port_set_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);
+typedef int (JACKSYM_API *jacksym_recompute_total_latencies)(jack_client_t*);
+
+typedef const char** (JACKSYM_API *jacksym_get_ports)(jack_client_t*, const char*, const char*, ulong);
+typedef jack_port_t* (JACKSYM_API *jacksym_port_by_name)(jack_client_t*, const char*);
+typedef jack_port_t* (JACKSYM_API *jacksym_port_by_id)(jack_client_t*, jack_port_id_t);
+
+typedef void (JACKSYM_API *jacksym_free)(void*);
+
+typedef uint32_t (JACKSYM_API *jacksym_midi_get_event_count)(void*);
+typedef int (JACKSYM_API *jacksym_midi_event_get)(jack_midi_event_t*, void*, uint32_t);
+typedef void (JACKSYM_API *jacksym_midi_clear_buffer)(void*);
+typedef int (JACKSYM_API *jacksym_midi_event_write)(void*, jack_nframes_t, const jack_midi_data_t*, size_t);
+typedef jack_midi_data_t* (JACKSYM_API *jacksym_midi_event_reserve)(void*, jack_nframes_t, size_t);
+
+typedef int (JACKSYM_API *jacksym_release_timebase)(jack_client_t*);
+typedef int (JACKSYM_API *jacksym_set_sync_callback)(jack_client_t*, JackSymSyncCallback, void*);
+typedef int (JACKSYM_API *jacksym_set_sync_timeout)(jack_client_t*, jack_time_t);
+typedef int (JACKSYM_API *jacksym_set_timebase_callback)(jack_client_t*, int, JackSymTimebaseCallback, void*);
+typedef int (JACKSYM_API *jacksym_transport_locate)(jack_client_t*, jack_nframes_t);
+
+typedef jack_transport_state_t (JACKSYM_API *jacksym_transport_query)(const jack_client_t*, jack_position_t*);
+typedef jack_nframes_t (JACKSYM_API *jacksym_get_current_transport_frame)(const jack_client_t*);
+
+typedef int (JACKSYM_API *jacksym_transport_reposition)(jack_client_t*, const jack_position_t*);
+typedef void (JACKSYM_API *jacksym_transport_start)(jack_client_t*);
+typedef void (JACKSYM_API *jacksym_transport_stop)(jack_client_t*);
+
+typedef int (JACKSYM_API *jacksym_set_property)(jack_client_t*, jack_uuid_t, const char*, const char*, const char*);
+typedef int (JACKSYM_API *jacksym_get_property)(jack_uuid_t, const char*, char**, char**);
+typedef void (JACKSYM_API *jacksym_free_description)(jack_description_t*, int);
+typedef int (JACKSYM_API *jacksym_get_properties)(jack_uuid_t, jack_description_t*);
+typedef int (JACKSYM_API *jacksym_get_all_properties)(jack_description_t**);
+typedef int (JACKSYM_API *jacksym_remove_property)(jack_client_t*, jack_uuid_t, const char*);
+typedef int (JACKSYM_API *jacksym_remove_properties)(jack_client_t*, jack_uuid_t);
+typedef int (JACKSYM_API *jacksym_remove_all_properties)(jack_client_t*);
+typedef int (JACKSYM_API *jacksym_set_property_change_callback)(jack_client_t*, JackSymPropertyChangeCallback, void*);
+
+#ifdef __WINE__
+typedef int (JACKSYM_API *jacksym_thread_creator_t)(pthread_t*, const pthread_attr_t*, void *(*)(void*), void*);
+typedef void (JACKSYM_API *jacksym_set_thread_creator)(jacksym_thread_creator_t);
+#endif
+
+} // extern "C"
+
+// -----------------------------------------------------------------------------
+
+struct JackBridge {
+ lib_t lib;
+
+ jacksym_get_version get_version_ptr;
+ jacksym_get_version_string get_version_string_ptr;
+
+ jacksym_client_open client_open_ptr;
+ jacksym_client_close client_close_ptr;
+
+ jacksym_client_name_size client_name_size_ptr;
+ jacksym_get_client_name get_client_name_ptr;
+
+ jacksym_client_get_uuid client_get_uuid_ptr;
+ jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;
+ jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;
+
+ jacksym_uuid_parse uuid_parse_ptr;
+ jacksym_uuid_unparse uuid_unparse_ptr;
+
+ jacksym_activate activate_ptr;
+ jacksym_deactivate deactivate_ptr;
+ jacksym_is_realtime is_realtime_ptr;
+
+ jacksym_set_thread_init_callback set_thread_init_callback_ptr;
+ jacksym_on_shutdown on_shutdown_ptr;
+ jacksym_on_info_shutdown on_info_shutdown_ptr;
+ jacksym_set_process_callback set_process_callback_ptr;
+ jacksym_set_freewheel_callback set_freewheel_callback_ptr;
+ jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;
+ jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;
+ jacksym_set_client_registration_callback set_client_registration_callback_ptr;
+ jacksym_set_port_registration_callback set_port_registration_callback_ptr;
+ jacksym_set_port_rename_callback set_port_rename_callback_ptr;
+ jacksym_set_port_connect_callback set_port_connect_callback_ptr;
+ jacksym_set_graph_order_callback set_graph_order_callback_ptr;
+ jacksym_set_xrun_callback set_xrun_callback_ptr;
+ jacksym_set_latency_callback set_latency_callback_ptr;
+
+ jacksym_set_freewheel set_freewheel_ptr;
+ jacksym_set_buffer_size set_buffer_size_ptr;
+
+ jacksym_get_sample_rate get_sample_rate_ptr;
+ jacksym_get_buffer_size get_buffer_size_ptr;
+ jacksym_cpu_load cpu_load_ptr;
+
+ jacksym_port_register port_register_ptr;
+ jacksym_port_unregister port_unregister_ptr;
+ jacksym_port_get_buffer port_get_buffer_ptr;
+
+ jacksym_port_name port_name_ptr;
+ jacksym_port_uuid port_uuid_ptr;
+ jacksym_port_short_name port_short_name_ptr;
+ jacksym_port_flags port_flags_ptr;
+ jacksym_port_type port_type_ptr;
+ jacksym_port_is_mine port_is_mine_ptr;
+ jacksym_port_connected port_connected_ptr;
+ jacksym_port_connected_to port_connected_to_ptr;
+ jacksym_port_get_connections port_get_connections_ptr;
+ jacksym_port_get_all_connections port_get_all_connections_ptr;
+
+ jacksym_port_rename port_rename_ptr;
+ jacksym_port_set_name port_set_name_ptr;
+ jacksym_port_set_alias port_set_alias_ptr;
+ jacksym_port_unset_alias port_unset_alias_ptr;
+ jacksym_port_get_aliases port_get_aliases_ptr;
+
+ jacksym_port_request_monitor port_request_monitor_ptr;
+ jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;
+ jacksym_port_ensure_monitor port_ensure_monitor_ptr;
+ jacksym_port_monitoring_input port_monitoring_input_ptr;
+
+ jacksym_connect connect_ptr;
+ jacksym_disconnect disconnect_ptr;
+ jacksym_port_disconnect port_disconnect_ptr;
+
+ jacksym_port_name_size port_name_size_ptr;
+ jacksym_port_type_size port_type_size_ptr;
+ jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;
+
+ jacksym_port_get_latency_range port_get_latency_range_ptr;
+ jacksym_port_set_latency_range port_set_latency_range_ptr;
+ jacksym_recompute_total_latencies recompute_total_latencies_ptr;
+
+ jacksym_get_ports get_ports_ptr;
+ jacksym_port_by_name port_by_name_ptr;
+ jacksym_port_by_id port_by_id_ptr;
+
+ jacksym_free free_ptr;
+
+ jacksym_midi_get_event_count midi_get_event_count_ptr;
+ jacksym_midi_event_get midi_event_get_ptr;
+ jacksym_midi_clear_buffer midi_clear_buffer_ptr;
+ jacksym_midi_event_write midi_event_write_ptr;
+ jacksym_midi_event_reserve midi_event_reserve_ptr;
+
+ jacksym_release_timebase release_timebase_ptr;
+ jacksym_set_sync_callback set_sync_callback_ptr;
+ jacksym_set_sync_timeout set_sync_timeout_ptr;
+ jacksym_set_timebase_callback set_timebase_callback_ptr;
+ jacksym_transport_locate transport_locate_ptr;
+
+ jacksym_transport_query transport_query_ptr;
+ jacksym_get_current_transport_frame get_current_transport_frame_ptr;
+
+ jacksym_transport_reposition transport_reposition_ptr;
+ jacksym_transport_start transport_start_ptr;
+ jacksym_transport_stop transport_stop_ptr;
+
+ jacksym_set_property set_property_ptr;
+ jacksym_get_property get_property_ptr;
+ jacksym_free_description free_description_ptr;
+ jacksym_get_properties get_properties_ptr;
+ jacksym_get_all_properties get_all_properties_ptr;
+ jacksym_remove_property remove_property_ptr;
+ jacksym_remove_properties remove_properties_ptr;
+ jacksym_remove_all_properties remove_all_properties_ptr;
+ jacksym_set_property_change_callback set_property_change_callback_ptr;
+
+#ifdef __WINE__
+ jacksym_set_thread_creator set_thread_creator_ptr;
+#endif
+
+ JackBridge()
+ : lib(nullptr),
+ get_version_ptr(nullptr),
+ get_version_string_ptr(nullptr),
+ client_open_ptr(nullptr),
+ client_close_ptr(nullptr),
+ client_name_size_ptr(nullptr),
+ get_client_name_ptr(nullptr),
+ client_get_uuid_ptr(nullptr),
+ get_uuid_for_client_name_ptr(nullptr),
+ get_client_name_by_uuid_ptr(nullptr),
+ uuid_parse_ptr(nullptr),
+ uuid_unparse_ptr(nullptr),
+ activate_ptr(nullptr),
+ deactivate_ptr(nullptr),
+ is_realtime_ptr(nullptr),
+ set_thread_init_callback_ptr(nullptr),
+ on_shutdown_ptr(nullptr),
+ on_info_shutdown_ptr(nullptr),
+ set_process_callback_ptr(nullptr),
+ set_freewheel_callback_ptr(nullptr),
+ set_buffer_size_callback_ptr(nullptr),
+ set_sample_rate_callback_ptr(nullptr),
+ set_client_registration_callback_ptr(nullptr),
+ set_port_registration_callback_ptr(nullptr),
+ set_port_rename_callback_ptr(nullptr),
+ set_port_connect_callback_ptr(nullptr),
+ set_graph_order_callback_ptr(nullptr),
+ set_xrun_callback_ptr(nullptr),
+ set_latency_callback_ptr(nullptr),
+ set_freewheel_ptr(nullptr),
+ set_buffer_size_ptr(nullptr),
+ get_sample_rate_ptr(nullptr),
+ get_buffer_size_ptr(nullptr),
+ cpu_load_ptr(nullptr),
+ port_register_ptr(nullptr),
+ port_unregister_ptr(nullptr),
+ port_get_buffer_ptr(nullptr),
+ port_name_ptr(nullptr),
+ port_uuid_ptr(nullptr),
+ port_short_name_ptr(nullptr),
+ port_flags_ptr(nullptr),
+ port_type_ptr(nullptr),
+ port_is_mine_ptr(nullptr),
+ port_connected_ptr(nullptr),
+ port_connected_to_ptr(nullptr),
+ port_get_connections_ptr(nullptr),
+ port_get_all_connections_ptr(nullptr),
+ port_rename_ptr(nullptr),
+ port_set_name_ptr(nullptr),
+ port_set_alias_ptr(nullptr),
+ port_unset_alias_ptr(nullptr),
+ port_get_aliases_ptr(nullptr),
+ port_request_monitor_ptr(nullptr),
+ port_request_monitor_by_name_ptr(nullptr),
+ port_ensure_monitor_ptr(nullptr),
+ port_monitoring_input_ptr(nullptr),
+ connect_ptr(nullptr),
+ disconnect_ptr(nullptr),
+ port_disconnect_ptr(nullptr),
+ port_name_size_ptr(nullptr),
+ port_type_size_ptr(nullptr),
+ port_type_get_buffer_size_ptr(nullptr),
+ port_get_latency_range_ptr(nullptr),
+ port_set_latency_range_ptr(nullptr),
+ recompute_total_latencies_ptr(nullptr),
+ get_ports_ptr(nullptr),
+ port_by_name_ptr(nullptr),
+ port_by_id_ptr(nullptr),
+ free_ptr(nullptr),
+ midi_get_event_count_ptr(nullptr),
+ midi_event_get_ptr(nullptr),
+ midi_clear_buffer_ptr(nullptr),
+ midi_event_write_ptr(nullptr),
+ midi_event_reserve_ptr(nullptr),
+ release_timebase_ptr(nullptr),
+ set_sync_callback_ptr(nullptr),
+ set_sync_timeout_ptr(nullptr),
+ set_timebase_callback_ptr(nullptr),
+ transport_locate_ptr(nullptr),
+ transport_query_ptr(nullptr),
+ get_current_transport_frame_ptr(nullptr),
+ transport_reposition_ptr(nullptr),
+ transport_start_ptr(nullptr),
+ transport_stop_ptr(nullptr),
+ set_property_ptr(nullptr),
+ get_property_ptr(nullptr),
+ free_description_ptr(nullptr),
+ get_properties_ptr(nullptr),
+ get_all_properties_ptr(nullptr),
+ remove_property_ptr(nullptr),
+ remove_properties_ptr(nullptr),
+ remove_all_properties_ptr(nullptr),
+ set_property_change_callback_ptr(nullptr)
+#ifdef __WINE__
+ , set_thread_creator_ptr(nullptr)
+#endif
+ {
+# if defined(DISTRHO_OS_MAC)
+ const char* const filename("libjack.dylib");
+# elif defined(DISTRHO_OS_WINDOWS) && defined(_WIN64)
+ const char* const filename("libjack64.dll");
+# elif defined(DISTRHO_OS_WINDOWS)
+ const char* const filename("libjack.dll");
+# else
+ const char* const filename("libjack.so.0");
+# endif
+
+ lib = lib_open(filename);
+
+ if (lib == nullptr)
+ {
+ fprintf(stderr, "Failed to load JACK DLL, reason:\n%s\n", lib_error(filename));
+ return;
+ }
+ else
+ {
+ fprintf(stdout, "%s loaded successfully!\n", filename);
+ }
+
+ #define JOIN(a, b) a ## b
+ #define LIB_SYMBOL(NAME) JOIN(NAME, _ptr) = lib_symbol<jacksym_##NAME>(lib, "jack_" #NAME);
+
+ LIB_SYMBOL(get_version)
+ LIB_SYMBOL(get_version_string)
+
+ LIB_SYMBOL(client_open)
+ LIB_SYMBOL(client_close)
+
+ LIB_SYMBOL(client_name_size)
+ LIB_SYMBOL(get_client_name)
+
+ LIB_SYMBOL(client_get_uuid)
+ LIB_SYMBOL(get_uuid_for_client_name)
+ LIB_SYMBOL(get_client_name_by_uuid)
+
+ LIB_SYMBOL(uuid_parse)
+ LIB_SYMBOL(uuid_unparse)
+
+ LIB_SYMBOL(activate)
+ LIB_SYMBOL(deactivate)
+ LIB_SYMBOL(is_realtime)
+
+ LIB_SYMBOL(set_thread_init_callback)
+ LIB_SYMBOL(on_shutdown)
+ LIB_SYMBOL(on_info_shutdown)
+ LIB_SYMBOL(set_process_callback)
+ LIB_SYMBOL(set_freewheel_callback)
+ LIB_SYMBOL(set_buffer_size_callback)
+ LIB_SYMBOL(set_sample_rate_callback)
+ LIB_SYMBOL(set_client_registration_callback)
+ LIB_SYMBOL(set_port_registration_callback)
+ LIB_SYMBOL(set_port_rename_callback)
+ LIB_SYMBOL(set_port_connect_callback)
+ LIB_SYMBOL(set_graph_order_callback)
+ LIB_SYMBOL(set_xrun_callback)
+ LIB_SYMBOL(set_latency_callback)
+
+ LIB_SYMBOL(set_freewheel)
+ LIB_SYMBOL(set_buffer_size)
+
+ LIB_SYMBOL(get_sample_rate)
+ LIB_SYMBOL(get_buffer_size)
+ LIB_SYMBOL(cpu_load)
+
+ LIB_SYMBOL(port_register)
+ LIB_SYMBOL(port_unregister)
+ LIB_SYMBOL(port_get_buffer)
+
+ LIB_SYMBOL(port_name)
+ LIB_SYMBOL(port_uuid)
+ LIB_SYMBOL(port_short_name)
+ LIB_SYMBOL(port_flags)
+ LIB_SYMBOL(port_type)
+ LIB_SYMBOL(port_is_mine)
+ LIB_SYMBOL(port_connected)
+ LIB_SYMBOL(port_connected_to)
+ LIB_SYMBOL(port_get_connections)
+ LIB_SYMBOL(port_get_all_connections)
+
+ LIB_SYMBOL(port_rename)
+ LIB_SYMBOL(port_set_name)
+ LIB_SYMBOL(port_set_alias)
+ LIB_SYMBOL(port_unset_alias)
+ LIB_SYMBOL(port_get_aliases)
+
+ LIB_SYMBOL(port_request_monitor)
+ LIB_SYMBOL(port_request_monitor_by_name)
+ LIB_SYMBOL(port_ensure_monitor)
+ LIB_SYMBOL(port_monitoring_input)
+
+ LIB_SYMBOL(connect)
+ LIB_SYMBOL(disconnect)
+ LIB_SYMBOL(port_disconnect)
+
+ LIB_SYMBOL(port_name_size)
+ LIB_SYMBOL(port_type_size)
+ LIB_SYMBOL(port_type_get_buffer_size)
+
+ LIB_SYMBOL(port_get_latency_range)
+ LIB_SYMBOL(port_set_latency_range)
+ LIB_SYMBOL(recompute_total_latencies)
+
+ LIB_SYMBOL(get_ports)
+ LIB_SYMBOL(port_by_name)
+ LIB_SYMBOL(port_by_id)
+
+ LIB_SYMBOL(free)
+
+ LIB_SYMBOL(midi_get_event_count)
+ LIB_SYMBOL(midi_event_get)
+ LIB_SYMBOL(midi_clear_buffer)
+ LIB_SYMBOL(midi_event_write)
+ LIB_SYMBOL(midi_event_reserve)
+
+ LIB_SYMBOL(release_timebase)
+ LIB_SYMBOL(set_sync_callback)
+ LIB_SYMBOL(set_sync_timeout)
+ LIB_SYMBOL(set_timebase_callback)
+ LIB_SYMBOL(transport_locate)
+ LIB_SYMBOL(transport_query)
+ LIB_SYMBOL(get_current_transport_frame)
+ LIB_SYMBOL(transport_reposition)
+ LIB_SYMBOL(transport_start)
+ LIB_SYMBOL(transport_stop)
+
+ LIB_SYMBOL(set_property)
+ LIB_SYMBOL(get_property)
+ LIB_SYMBOL(free_description)
+ LIB_SYMBOL(get_properties)
+ LIB_SYMBOL(get_all_properties)
+ LIB_SYMBOL(remove_property)
+ LIB_SYMBOL(remove_properties)
+ LIB_SYMBOL(remove_all_properties)
+ LIB_SYMBOL(set_property_change_callback)
+
+#ifdef __WINE__
+ LIB_SYMBOL(set_thread_creator)
+#endif
+
+ #undef JOIN
+ #undef LIB_SYMBOL
+ }
+
+ ~JackBridge() noexcept
+ {
+ if (lib != nullptr)
+ {
+ lib_close(lib);
+ lib = nullptr;
+ }
+ }
+
+ DISTRHO_DECLARE_NON_COPYABLE(JackBridge);
+};
+
+// -----------------------------------------------------------------------------
+
+static const JackBridge& getBridgeInstance() noexcept
+{
+ static const JackBridge bridge;
+ return bridge;
+}
+
+#endif // ! (defined(JACKBRIDGE_DIRECT) || defined(JACKBRIDGE_DUMMY))
+
+// -----------------------------------------------------------------------------
+
+#if defined(__WINE__) && ! defined(JACKBRIDGE_DIRECT)
+
+struct WineBridge {
+ void* ptr;
+ JackLatencyCallback latency_cb;
+ JackProcessCallback process_cb;
+ JackThreadInitCallback thread_init_cb;
+ JackGraphOrderCallback graph_order_cb;
+ JackXRunCallback xrun_cb;
+ JackBufferSizeCallback bufsize_cb;
+ JackSampleRateCallback srate_cb;
+ JackPortRegistrationCallback port_reg_cb;
+ JackClientRegistrationCallback client_reg_cb;
+ JackPortConnectCallback port_conn_cb;
+ JackPortRenameCallback port_rename_cb;
+ JackFreewheelCallback freewheel_cb;
+ JackShutdownCallback shutdown_cb;
+ JackInfoShutdownCallback info_shutdown_cb;
+ JackSyncCallback sync_cb;
+ JackTimebaseCallback timebase_cb;
+ JackSessionCallback session_cb;
+ JackPropertyChangeCallback prop_change_cb;
+
+ void* (*creator_func)(void*);
+ void* creator_arg;
+ HANDLE creator_handle;
+ pthread_t creator_pthread;
+
+ WineBridge() noexcept
+ : ptr(nullptr),
+ latency_cb(nullptr),
+ process_cb(nullptr),
+ thread_init_cb(nullptr),
+ graph_order_cb(nullptr),
+ xrun_cb(nullptr),
+ bufsize_cb(nullptr),
+ srate_cb(nullptr),
+ port_reg_cb(nullptr),
+ client_reg_cb(nullptr),
+ port_conn_cb(nullptr),
+ port_rename_cb(nullptr),
+ freewheel_cb(nullptr),
+ shutdown_cb(nullptr),
+ info_shutdown_cb(nullptr),
+ sync_cb(nullptr),
+ timebase_cb(nullptr),
+ session_cb(nullptr),
+ prop_change_cb(nullptr),
+ creator_func(nullptr),
+ creator_arg(nullptr),
+ creator_handle(nullptr),
+ creator_pthread(0) {}
+
+ static WineBridge& getInstance() noexcept
+ {
+ static WineBridge bridge;
+ return bridge;
+ }
+
+ void set_latency (JackLatencyCallback cb) noexcept { latency_cb = cb; }
+ void set_process (JackProcessCallback cb) noexcept { process_cb = cb; }
+ void set_thread_init (JackThreadInitCallback cb) noexcept { thread_init_cb = cb; }
+ void set_graph_order (JackGraphOrderCallback cb) noexcept { graph_order_cb = cb; }
+ void set_xrun (JackXRunCallback cb) noexcept { xrun_cb = cb; }
+ void set_bufsize (JackBufferSizeCallback cb) noexcept { bufsize_cb = cb; }
+ void set_srate (JackSampleRateCallback cb) noexcept { srate_cb = cb; }
+ void set_port_reg (JackPortRegistrationCallback cb) noexcept { port_reg_cb = cb; }
+ void set_client_reg (JackClientRegistrationCallback cb) noexcept { client_reg_cb = cb; }
+ void set_port_conn (JackPortConnectCallback cb) noexcept { port_conn_cb = cb; }
+ void set_port_rename (JackPortRenameCallback cb) noexcept { port_rename_cb = cb; }
+ void set_freewheel (JackFreewheelCallback cb) noexcept { freewheel_cb = cb; }
+ void set_shutdown (JackShutdownCallback cb) noexcept { shutdown_cb = cb; }
+ void set_info_shutdown(JackInfoShutdownCallback cb) noexcept { info_shutdown_cb = cb; }
+ void set_sync (JackSyncCallback cb) noexcept { sync_cb = cb; }
+ void set_timebase (JackTimebaseCallback cb) noexcept { timebase_cb = cb; }
+ void set_session (JackSessionCallback cb) noexcept { session_cb = cb; }
+ void set_prop_change (JackPropertyChangeCallback cb) noexcept { prop_change_cb = cb; }
+
+ static DWORD WINAPI thread_creator_helper(LPVOID)
+ {
+ WineBridge& inst(getInstance());
+
+ inst.creator_pthread = pthread_self();
+ SetEvent(inst.creator_handle);
+ inst.creator_func(inst.creator_arg);
+ return 0;
+ }
+
+ static int thread_creator(pthread_t* thread_id, const pthread_attr_t*, void *(*function)(void*), void* arg)
+ {
+ WineBridge& inst(getInstance());
+
+ inst.creator_func = function;
+ inst.creator_arg = arg;
+ inst.creator_handle = ::CreateEventW(nullptr, false, false, nullptr);
+
+#if 0
+ ::CreateThread(nullptr, 0, thread_creator_helper, arg, 0, nullptr);
+#else
+ HANDLE handle = ::CreateThread(nullptr, 0, thread_creator_helper, arg, CREATE_SUSPENDED, nullptr);
+
+ if (handle == INVALID_HANDLE_VALUE)
+ return 1;
+
+ // TODO read attrs and decide this
+ ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
+ ::ResumeThread(handle);
+#endif
+
+ ::WaitForSingleObject(inst.creator_handle, INFINITE);
+ *thread_id = inst.creator_pthread;
+ return 0;
+ }
+
+ static void latency(jack_latency_callback_mode_t mode, void* arg)
+ {
+ return getInstance().latency_cb(mode, arg);
+ }
+
+ static int process(jack_nframes_t nframes, void* arg)
+ {
+ return getInstance().process_cb(nframes, arg);
+ }
+
+ static void thread_init(void* arg)
+ {
+ return getInstance().thread_init_cb(arg);
+ }
+
+ static int graph_order(void* arg)
+ {
+ return getInstance().graph_order_cb(arg);
+ }
+
+ static int xrun(void* arg)
+ {
+ return getInstance().xrun_cb(arg);
+ }
+
+ static int bufsize(jack_nframes_t nframes, void* arg)
+ {
+ return getInstance().bufsize_cb(nframes, arg);
+ }
+
+ static int srate(jack_nframes_t nframes, void* arg)
+ {
+ return getInstance().srate_cb(nframes, arg);
+ }
+
+ static void port_reg(jack_port_id_t port, int register_, void* arg)
+ {
+ return getInstance().port_reg_cb(port, register_, arg);
+ }
+
+ static void client_reg(const char* name, int register_, void* arg)
+ {
+ return getInstance().client_reg_cb(name, register_, arg);
+ }
+
+ static void port_conn(jack_port_id_t a, jack_port_id_t b, int connect, void* arg)
+ {
+ return getInstance().port_conn_cb(a, b, connect, arg);
+ }
+
+ static void port_rename(jack_port_id_t port, const char* old_name, const char* new_name, void* arg)
+ {
+ getInstance().port_rename_cb(port, old_name, new_name, arg);
+ }
+
+ static void freewheel(int starting, void* arg)
+ {
+ return getInstance().freewheel_cb(starting, arg);
+ }
+
+ static void shutdown(void* arg)
+ {
+ return getInstance().shutdown_cb(arg);
+ }
+
+ static void info_shutdown(jack_status_t code, const char* reason, void* arg)
+ {
+ return getInstance().info_shutdown_cb(code, reason, arg);
+ }
+
+ static int sync(jack_transport_state_t state, jack_position_t* pos, void* arg)
+ {
+ return getInstance().sync_cb(state, pos, arg);
+ }
+
+ static void timebase(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg)
+ {
+ return getInstance().timebase_cb(state, nframes, pos, new_pos, arg);
+ }
+
+ static void session(jack_session_event_t* event, void* arg)
+ {
+ return getInstance().session_cb(event, arg);
+ }
+
+ static void prop_change(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg)
+ {
+ return getInstance().prop_change_cb(subject, key, change, arg);
+ }
+
+ DISTRHO_DECLARE_NON_COPYABLE(WineBridge);
+};
+
+#endif // __WINE__ && ! JACKBRIDGE_DIRECT
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_is_ok() noexcept
+{
+#if defined(JACKBRIDGE_DUMMY)
+ return false;
+#elif defined(JACKBRIDGE_DIRECT)
+ return true;
+#else
+ return (getBridgeInstance().lib != nullptr);
+#endif
+}
+
+void jackbridge_init()
+{
+#if defined(__WINE__) && ! defined(JACKBRIDGE_DIRECT)
+ if (getBridgeInstance().set_thread_creator_ptr != nullptr)
+ getBridgeInstance().set_thread_creator_ptr(WineBridge::thread_creator);
+#endif
+}
+
+// -----------------------------------------------------------------------------
+
+void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_version(major_ptr, minor_ptr, micro_ptr, proto_ptr);
+#else
+ if (getBridgeInstance().get_version_ptr != nullptr)
+ return getBridgeInstance().get_version_ptr(major_ptr, minor_ptr, micro_ptr, proto_ptr);
+#endif
+ if (major_ptr != nullptr)
+ *major_ptr = 0;
+ if (minor_ptr != nullptr)
+ *minor_ptr = 0;
+ if (micro_ptr != nullptr)
+ *micro_ptr = 0;
+ if (proto_ptr != nullptr)
+ *proto_ptr = 0;
+}
+
+const char* jackbridge_get_version_string()
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_version_string();
+#else
+ if (getBridgeInstance().get_version_string_ptr != nullptr)
+ return getBridgeInstance().get_version_string_ptr();
+#endif
+ return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_client_open(client_name, static_cast<jack_options_t>(options), status);
+#else
+ if (getBridgeInstance().client_open_ptr != nullptr)
+ return getBridgeInstance().client_open_ptr(client_name, static_cast<jack_options_t>(options), status);
+#endif
+ if (status != nullptr)
+ *status = JackServerError;
+ return nullptr;
+}
+
+bool jackbridge_client_close(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_client_close(client) == 0);
+#else
+ if (getBridgeInstance().client_close_ptr != nullptr)
+ return (getBridgeInstance().client_close_ptr(client) == 0);
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
+
+int jackbridge_client_name_size()
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_client_name_size();
+#else
+ if (getBridgeInstance().client_name_size_ptr != nullptr)
+ return getBridgeInstance().client_name_size_ptr();
+#endif
+ return 33;
+}
+
+char* jackbridge_get_client_name(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_client_name(client);
+#else
+ if (getBridgeInstance().get_client_name_ptr != nullptr)
+ return getBridgeInstance().get_client_name_ptr(client);
+#endif
+ return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+char* jackbridge_client_get_uuid(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_client_get_uuid(client);
+#else
+ if (const jacksym_client_get_uuid func = getBridgeInstance().client_get_uuid_ptr)
+ return func(client);
+#endif
+ return nullptr;
+}
+
+char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_uuid_for_client_name(client, name);
+#else
+ if (getBridgeInstance().get_uuid_for_client_name_ptr != nullptr)
+ return getBridgeInstance().get_uuid_for_client_name_ptr(client, name);
+#endif
+ return nullptr;
+}
+
+char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_client_name_by_uuid(client, uuid);
+#else
+ if (getBridgeInstance().get_client_name_by_uuid_ptr != nullptr)
+ return getBridgeInstance().get_client_name_by_uuid_ptr(client, uuid);
+#endif
+ return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_uuid_parse(buf, uuid) == 0);
+#else
+ if (const jacksym_uuid_parse func = getBridgeInstance().uuid_parse_ptr)
+ return (func(buf, uuid) == 0);
+#endif
+ return false;
+}
+
+void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE])
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_uuid_unparse(uuid, buf);
+#else
+ if (const jacksym_uuid_unparse func = getBridgeInstance().uuid_unparse_ptr)
+ return func(uuid, buf);
+#endif
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_activate(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_activate(client) == 0);
+#else
+ if (getBridgeInstance().activate_ptr != nullptr)
+ return (getBridgeInstance().activate_ptr(client) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_deactivate(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_deactivate(client) == 0);
+#else
+ if (getBridgeInstance().deactivate_ptr != nullptr)
+ return (getBridgeInstance().deactivate_ptr(client) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_is_realtime(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_is_realtime(client);
+#else
+ if (getBridgeInstance().is_realtime_ptr != nullptr)
+ return getBridgeInstance().is_realtime_ptr(client);
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_thread_init_callback(client, thread_init_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_thread_init_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_thread_init(thread_init_callback);
+ return (getBridgeInstance().set_thread_init_callback_ptr(client, WineBridge::thread_init, arg) == 0);
+# else
+ return (getBridgeInstance().set_thread_init_callback_ptr(client, thread_init_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_on_shutdown(client, shutdown_callback, arg);
+#else
+ if (getBridgeInstance().on_shutdown_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_shutdown(shutdown_callback);
+ getBridgeInstance().on_shutdown_ptr(client, WineBridge::shutdown, arg);
+# else
+ getBridgeInstance().on_shutdown_ptr(client, shutdown_callback, arg);
+# endif
+ }
+#endif
+}
+
+void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_on_info_shutdown(client, shutdown_callback, arg);
+#else
+ if (getBridgeInstance().on_info_shutdown_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_info_shutdown(shutdown_callback);
+ getBridgeInstance().on_info_shutdown_ptr(client, WineBridge::info_shutdown, arg);
+# else
+ getBridgeInstance().on_info_shutdown_ptr(client, shutdown_callback, arg);
+# endif
+ }
+#endif
+}
+
+bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_process_callback(client, process_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_process_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_process(process_callback);
+ return (getBridgeInstance().set_process_callback_ptr(client, WineBridge::process, arg) == 0);
+# else
+ return (getBridgeInstance().set_process_callback_ptr(client, process_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_freewheel_callback(client, freewheel_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_freewheel_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_freewheel(freewheel_callback);
+ return (getBridgeInstance().set_freewheel_callback_ptr(client, WineBridge::freewheel, arg) == 0);
+# else
+ return (getBridgeInstance().set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_buffer_size_callback(client, bufsize_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_buffer_size_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_bufsize(bufsize_callback);
+ return (getBridgeInstance().set_buffer_size_callback_ptr(client, WineBridge::bufsize, arg) == 0);
+# else
+ return (getBridgeInstance().set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_sample_rate_callback(client, srate_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_sample_rate_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_srate(srate_callback);
+ return (getBridgeInstance().set_sample_rate_callback_ptr(client, WineBridge::srate, arg) == 0);
+# else
+ return (getBridgeInstance().set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_client_registration_callback(client, registration_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_client_registration_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_client_reg(registration_callback);
+ return (getBridgeInstance().set_client_registration_callback_ptr(client, WineBridge::client_reg, arg) == 0);
+# else
+ return (getBridgeInstance().set_client_registration_callback_ptr(client, registration_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_port_registration_callback(client, registration_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_port_registration_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_port_reg(registration_callback);
+ return (getBridgeInstance().set_port_registration_callback_ptr(client, WineBridge::port_reg, arg) == 0);
+# else
+ return (getBridgeInstance().set_port_registration_callback_ptr(client, registration_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_port_rename_callback(client, rename_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_port_rename_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_port_rename(rename_callback);
+ return (getBridgeInstance().set_port_rename_callback_ptr(client, WineBridge::port_rename, arg) == 0);
+# else
+ return (getBridgeInstance().set_port_rename_callback_ptr(client, rename_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_port_connect_callback(client, connect_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_port_connect_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_port_conn(connect_callback);
+ return (getBridgeInstance().set_port_connect_callback_ptr(client, WineBridge::port_conn, arg) == 0);
+# else
+ return (getBridgeInstance().set_port_connect_callback_ptr(client, connect_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_graph_order_callback(client, graph_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_graph_order_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_graph_order(graph_callback);
+ return (getBridgeInstance().set_graph_order_callback_ptr(client, WineBridge::graph_order, arg) == 0);
+# else
+ return (getBridgeInstance().set_graph_order_callback_ptr(client, graph_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_xrun_callback(client, xrun_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_xrun_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_xrun(xrun_callback);
+ return (getBridgeInstance().set_xrun_callback_ptr(client, WineBridge::xrun, arg) == 0);
+# else
+ return (getBridgeInstance().set_xrun_callback_ptr(client, xrun_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_latency_callback(client, latency_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_latency_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_latency(latency_callback);
+ return (getBridgeInstance().set_latency_callback_ptr(client, WineBridge::latency, arg) == 0);
+# else
+ return (getBridgeInstance().set_latency_callback_ptr(client, latency_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_set_freewheel(jack_client_t* client, bool onoff)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_set_freewheel(client, onoff);
+#else
+ if (getBridgeInstance().set_freewheel_ptr != nullptr)
+ return getBridgeInstance().set_freewheel_ptr(client, onoff);
+#endif
+ return false;
+}
+
+bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_set_buffer_size(client, nframes);
+#else
+ if (getBridgeInstance().set_buffer_size_ptr != nullptr)
+ return getBridgeInstance().set_buffer_size_ptr(client, nframes);
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
+
+jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_sample_rate(client);
+#else
+ if (getBridgeInstance().get_sample_rate_ptr != nullptr)
+ return getBridgeInstance().get_sample_rate_ptr(client);
+#endif
+ return 0;
+}
+
+jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_buffer_size(client);
+#else
+ if (getBridgeInstance().get_buffer_size_ptr != nullptr)
+ return getBridgeInstance().get_buffer_size_ptr(client);
+#endif
+ return 0;
+}
+
+float jackbridge_cpu_load(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_cpu_load(client);
+#else
+ if (getBridgeInstance().cpu_load_ptr != nullptr)
+ return getBridgeInstance().cpu_load_ptr(client);
+#endif
+ return 0.0f;
+}
+
+// -----------------------------------------------------------------------------
+
+jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, uint64_t flags, uint64_t buffer_size)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_register(client, port_name, port_type, flags, buffer_size);
+#else
+ if (getBridgeInstance().port_register_ptr != nullptr)
+ return getBridgeInstance().port_register_ptr(client, port_name, port_type,
+ static_cast<ulong>(flags),
+ static_cast<ulong>(buffer_size));
+#endif
+ return nullptr;
+}
+
+bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_unregister(client, port) == 0);
+#else
+ if (getBridgeInstance().port_unregister_ptr != nullptr)
+ return (getBridgeInstance().port_unregister_ptr(client, port) == 0);
+#endif
+ return false;
+}
+
+void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_get_buffer(port, nframes);
+#else
+ if (getBridgeInstance().port_get_buffer_ptr != nullptr)
+ return getBridgeInstance().port_get_buffer_ptr(port, nframes);
+#endif
+ return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+const char* jackbridge_port_name(const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_name(port);
+#else
+ if (getBridgeInstance().port_name_ptr != nullptr)
+ return getBridgeInstance().port_name_ptr(port);
+#endif
+ return nullptr;
+}
+
+jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_uuid(port);
+#else
+ if (getBridgeInstance().port_uuid_ptr != nullptr)
+ return getBridgeInstance().port_uuid_ptr(port);
+#endif
+ return 0;
+}
+
+const char* jackbridge_port_short_name(const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_short_name(port);
+#else
+ if (getBridgeInstance().port_short_name_ptr != nullptr)
+ return getBridgeInstance().port_short_name_ptr(port);
+#endif
+ return nullptr;
+}
+
+int jackbridge_port_flags(const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_flags(port);
+#else
+ if (getBridgeInstance().port_flags_ptr != nullptr)
+ return getBridgeInstance().port_flags_ptr(port);
+#endif
+ return 0x0;
+}
+
+const char* jackbridge_port_type(const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_type(port);
+#else
+ if (getBridgeInstance().port_type_ptr != nullptr)
+ return getBridgeInstance().port_type_ptr(port);
+#endif
+ return nullptr;
+}
+
+bool jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_is_mine(client, port);
+#else
+ if (getBridgeInstance().port_is_mine_ptr != nullptr)
+ return getBridgeInstance().port_is_mine_ptr(client, port);
+#endif
+ return false;
+}
+
+int jackbridge_port_connected(const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_connected(port);
+#else
+ if (getBridgeInstance().port_connected_ptr != nullptr)
+ return getBridgeInstance().port_connected_ptr(port);
+#endif
+ return 0;
+}
+
+bool jackbridge_port_connected_to(const jack_port_t* port, const char* port_name)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_connected_to(port, port_name);
+#else
+ if (getBridgeInstance().port_connected_to_ptr != nullptr)
+ return getBridgeInstance().port_connected_to_ptr(port, port_name);
+#endif
+ return false;
+}
+
+const char** jackbridge_port_get_connections(const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_get_connections(port);
+#else
+ if (getBridgeInstance().port_get_connections_ptr != nullptr)
+ return getBridgeInstance().port_get_connections_ptr(port);
+#endif
+ return nullptr;
+}
+
+const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_get_all_connections(client, port);
+#else
+ if (getBridgeInstance().port_get_all_connections_ptr != nullptr)
+ return getBridgeInstance().port_get_all_connections_ptr(client, port);
+#endif
+ return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_rename(client, port, port_name) == 0);
+#else
+ // Try new API first
+ if (getBridgeInstance().port_rename_ptr != nullptr)
+ return (getBridgeInstance().port_rename_ptr(client, port, port_name) == 0);
+ // Try old API if using JACK2
+ if (getBridgeInstance().get_version_string_ptr != nullptr && getBridgeInstance().port_set_name_ptr != nullptr)
+ return (getBridgeInstance().port_set_name_ptr(port, port_name) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_port_set_alias(jack_port_t* port, const char* alias)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_set_alias(port, alias) == 0);
+#else
+ if (getBridgeInstance().port_set_alias_ptr != nullptr)
+ return (getBridgeInstance().port_set_alias_ptr(port, alias) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_unset_alias(port, alias) == 0);
+#else
+ if (getBridgeInstance().port_unset_alias_ptr != nullptr)
+ return (getBridgeInstance().port_unset_alias_ptr(port, alias) == 0);
+#endif
+ return false;
+}
+
+int jackbridge_port_get_aliases(const jack_port_t* port, char* const aliases[2])
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_get_aliases(port, aliases) == 0);
+#else
+ if (getBridgeInstance().port_get_aliases_ptr != nullptr)
+ return getBridgeInstance().port_get_aliases_ptr(port, aliases);
+#endif
+ return 0;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_request_monitor(port, onoff) == 0);
+#else
+ if (getBridgeInstance().port_request_monitor_ptr != nullptr)
+ return (getBridgeInstance().port_request_monitor_ptr(port, onoff) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_request_monitor_by_name(client, port_name, onoff) == 0);
+#else
+ if (getBridgeInstance().port_request_monitor_by_name_ptr != nullptr)
+ return (getBridgeInstance().port_request_monitor_by_name_ptr(client, port_name, onoff) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_ensure_monitor(port, onoff) == 0);
+#else
+ if (getBridgeInstance().port_ensure_monitor_ptr != nullptr)
+ return (getBridgeInstance().port_ensure_monitor_ptr(port, onoff) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_port_monitoring_input(jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_monitoring_input(port);
+#else
+ if (getBridgeInstance().port_monitoring_input_ptr != nullptr)
+ return getBridgeInstance().port_monitoring_input_ptr(port);
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_connect(client, source_port, destination_port) == 0);
+#else
+ if (getBridgeInstance().connect_ptr != nullptr)
+ {
+ const int ret = getBridgeInstance().connect_ptr(client, source_port, destination_port);
+ return ret == 0 || ret == EEXIST;
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_disconnect(client, source_port, destination_port) == 0);
+#else
+ if (getBridgeInstance().disconnect_ptr != nullptr)
+ return (getBridgeInstance().disconnect_ptr(client, source_port, destination_port) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_port_disconnect(client, port) == 0);
+#else
+ if (getBridgeInstance().port_disconnect_ptr != nullptr)
+ return (getBridgeInstance().port_disconnect_ptr(client, port) == 0);
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
+
+int jackbridge_port_name_size()
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_name_size();
+#else
+ if (getBridgeInstance().port_name_size_ptr != nullptr)
+ return getBridgeInstance().port_name_size_ptr();
+#endif
+ return 256;
+}
+
+int jackbridge_port_type_size()
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_type_size();
+#else
+ if (getBridgeInstance().port_type_size_ptr != nullptr)
+ return getBridgeInstance().port_type_size_ptr();
+#endif
+ return 32;
+}
+
+uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return static_cast<uint32_t>(jack_port_type_get_buffer_size(client, port_type));
+#else
+ if (getBridgeInstance().port_type_get_buffer_size_ptr != nullptr)
+ return static_cast<uint32_t>(getBridgeInstance().port_type_get_buffer_size_ptr(client, port_type));
+#endif
+ return 0;
+}
+
+// -----------------------------------------------------------------------------
+
+void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_get_latency_range(port, static_cast<jack_latency_callback_mode_t>(mode), range);
+#else
+ if (getBridgeInstance().port_get_latency_range_ptr != nullptr)
+ return getBridgeInstance().port_get_latency_range_ptr(port,
+ static_cast<jack_latency_callback_mode_t>(mode),
+ range);
+#endif
+ range->min = 0;
+ range->max = 0;
+}
+
+void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_port_set_latency_range(port, static_cast<jack_latency_callback_mode_t>(mode), range);
+#else
+ if (getBridgeInstance().port_set_latency_range_ptr != nullptr)
+ getBridgeInstance().port_set_latency_range_ptr(port,
+ static_cast<jack_latency_callback_mode_t>(mode),
+ range);
+#endif
+}
+
+bool jackbridge_recompute_total_latencies(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_recompute_total_latencies(client) == 0);
+#else
+ if (getBridgeInstance().recompute_total_latencies_ptr != nullptr)
+ return (getBridgeInstance().recompute_total_latencies_ptr(client) == 0);
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
+
+const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_ports(client, port_name_pattern, type_name_pattern, flags);
+#else
+ if (getBridgeInstance().get_ports_ptr != nullptr)
+ return getBridgeInstance().get_ports_ptr(client, port_name_pattern, type_name_pattern,
+ static_cast<ulong>(flags));
+#endif
+ return nullptr;
+}
+
+jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_by_name(client, port_name);
+#else
+ if (getBridgeInstance().port_by_name_ptr != nullptr)
+ return getBridgeInstance().port_by_name_ptr(client, port_name);
+#endif
+ return nullptr;
+}
+
+jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_port_by_id(client, port_id);
+#else
+ if (getBridgeInstance().port_by_id_ptr != nullptr)
+ return getBridgeInstance().port_by_id_ptr(client, port_id);
+#endif
+ return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+void jackbridge_free(void* ptr)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_free(ptr);
+#else
+ if (getBridgeInstance().free_ptr != nullptr)
+ return getBridgeInstance().free_ptr(ptr);
+
+ // just in case
+ std::free(ptr);
+#endif
+}
+
+// -----------------------------------------------------------------------------
+
+uint32_t jackbridge_midi_get_event_count(void* port_buffer)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_midi_get_event_count(port_buffer);
+#else
+ if (getBridgeInstance().midi_get_event_count_ptr != nullptr)
+ return getBridgeInstance().midi_get_event_count_ptr(port_buffer);
+#endif
+ return 0;
+}
+
+bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_midi_event_get(event, port_buffer, event_index) == 0);
+#else
+ if (getBridgeInstance().midi_event_get_ptr != nullptr)
+ return (getBridgeInstance().midi_event_get_ptr(event, port_buffer, event_index) == 0);
+#endif
+ return false;
+}
+
+void jackbridge_midi_clear_buffer(void* port_buffer)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_midi_clear_buffer(port_buffer);
+#else
+ if (getBridgeInstance().midi_clear_buffer_ptr != nullptr)
+ getBridgeInstance().midi_clear_buffer_ptr(port_buffer);
+#endif
+}
+
+bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_midi_event_write(port_buffer, time, data, data_size) == 0);
+#else
+ if (getBridgeInstance().midi_event_write_ptr != nullptr)
+ return (getBridgeInstance().midi_event_write_ptr(port_buffer, time, data, data_size) == 0);
+#endif
+ return false;
+}
+
+jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_midi_event_reserve(port_buffer, time, data_size);
+#else
+ if (getBridgeInstance().midi_event_reserve_ptr != nullptr)
+ return getBridgeInstance().midi_event_reserve_ptr(port_buffer, time, data_size);
+#endif
+ return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_release_timebase(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_release_timebase(client) == 0);
+#else
+ if (getBridgeInstance().release_timebase_ptr != nullptr)
+ return (getBridgeInstance().release_timebase_ptr(client) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_sync_callback(client, sync_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_sync_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_sync(sync_callback);
+ return (getBridgeInstance().set_sync_callback_ptr(client, WineBridge::sync, arg) == 0);
+# else
+ return (getBridgeInstance().set_sync_callback_ptr(client, sync_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_sync_timeout(client, timeout) == 0);
+#else
+ if (getBridgeInstance().set_sync_timeout_ptr != nullptr)
+ return (getBridgeInstance().set_sync_timeout_ptr(client, timeout) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_timebase_callback(client, conditional, timebase_callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_timebase_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_timebase(timebase_callback);
+ return (getBridgeInstance().set_timebase_callback_ptr(client, conditional, WineBridge::timebase, arg) == 0);
+# else
+ return (getBridgeInstance().set_timebase_callback_ptr(client, conditional, timebase_callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_transport_locate(client, frame) == 0);
+#else
+ if (getBridgeInstance().transport_locate_ptr != nullptr)
+ return (getBridgeInstance().transport_locate_ptr(client, frame) == 0);
+#endif
+ return false;
+}
+
+uint32_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_transport_query(client, pos);
+#else
+ if (getBridgeInstance().transport_query_ptr != nullptr)
+ return getBridgeInstance().transport_query_ptr(client, pos);
+#endif
+ if (pos != nullptr)
+ {
+ // invalidate
+ pos->unique_1 = 0;
+ pos->unique_2 = 1;
+ }
+ return JackTransportStopped;
+}
+
+jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_get_current_transport_frame(client);
+#else
+ if (getBridgeInstance().get_current_transport_frame_ptr != nullptr)
+ return getBridgeInstance().get_current_transport_frame_ptr(client);
+#endif
+ return 0;
+}
+
+bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_transport_reposition(client, pos) == 0);
+#else
+ if (getBridgeInstance().transport_reposition_ptr != nullptr)
+ return (getBridgeInstance().transport_reposition_ptr(client, pos) == 0);
+#endif
+ return false;
+}
+
+void jackbridge_transport_start(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_transport_start(client);
+#else
+ if (getBridgeInstance().transport_start_ptr != nullptr)
+ getBridgeInstance().transport_start_ptr(client);
+#endif
+}
+
+void jackbridge_transport_stop(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_transport_stop(client);
+#else
+ if (getBridgeInstance().transport_stop_ptr != nullptr)
+ getBridgeInstance().transport_stop_ptr(client);
+#endif
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_property(client, subject, key, value, type) == 0);
+#else
+ if (getBridgeInstance().set_property_ptr != nullptr)
+ return (getBridgeInstance().set_property_ptr(client, subject, key, value, type) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_get_property(subject, key, value, type) == 0);
+#else
+ if (getBridgeInstance().get_property_ptr != nullptr)
+ return (getBridgeInstance().get_property_ptr(subject, key, value, type) == 0);
+#endif
+ return false;
+}
+
+void jackbridge_free_description(jack_description_t* desc, bool free_description_itself)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ jack_free_description(desc, free_description_itself);
+#else
+ if (getBridgeInstance().free_description_ptr != nullptr)
+ getBridgeInstance().free_description_ptr(desc, free_description_itself);
+#endif
+}
+
+bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_get_properties(subject, desc) == 0);
+#else
+ if (getBridgeInstance().get_properties_ptr != nullptr)
+ return (getBridgeInstance().get_properties_ptr(subject, desc) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_get_all_properties(jack_description_t** descs)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_get_all_properties(descs) == 0);
+#else
+ if (getBridgeInstance().get_all_properties_ptr != nullptr)
+ return (getBridgeInstance().get_all_properties_ptr(descs) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_remove_property(client, subject, key) == 0);
+#else
+ if (getBridgeInstance().remove_property_ptr != nullptr)
+ return (getBridgeInstance().remove_property_ptr(client, subject, key) == 0);
+#endif
+ return false;
+}
+
+int jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return jack_remove_properties(client, subject);
+#else
+ if (getBridgeInstance().remove_properties_ptr != nullptr)
+ return getBridgeInstance().remove_properties_ptr(client, subject);
+#endif
+ return 0;
+}
+
+bool jackbridge_remove_all_properties(jack_client_t* client)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_remove_all_properties(client) == 0);
+#else
+ if (getBridgeInstance().remove_all_properties_ptr != nullptr)
+ return (getBridgeInstance().remove_all_properties_ptr(client) == 0);
+#endif
+ return false;
+}
+
+bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg)
+{
+#if defined(JACKBRIDGE_DUMMY)
+#elif defined(JACKBRIDGE_DIRECT)
+ return (jack_set_property_change_callback(client, callback, arg) == 0);
+#else
+ if (getBridgeInstance().set_property_change_callback_ptr != nullptr)
+ {
+# ifdef __WINE__
+ WineBridge::getInstance().set_prop_change(callback);
+ return (getBridgeInstance().set_property_change_callback_ptr(client, WineBridge::prop_change, arg) == 0);
+# else
+ return (getBridgeInstance().set_property_change_callback_ptr(client, callback, arg) == 0);
+# endif
+ }
+#endif
+ return false;
+}
+
+// -----------------------------------------------------------------------------
diff --git a/distrho/src/jackbridge/JackBridge.hpp b/distrho/src/jackbridge/JackBridge.hpp
@@ -0,0 +1,422 @@
+/*
+ * JackBridge for DPF
+ * Copyright (C) 2013-2021 Filipe Coelho <falktx@falktx.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with
+ * or without fee is hereby granted, provided that the above copyright notice and this
+ * permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+ * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
+ * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef JACKBRIDGE_HPP_INCLUDED
+#define JACKBRIDGE_HPP_INCLUDED
+
+#ifdef __WINE__
+# if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
+# define __WINE64__
+# endif
+# undef WIN32
+# undef WIN64
+# undef _WIN32
+# undef _WIN64
+# undef __WIN32__
+# undef __WIN64__
+#endif
+
+#include "../DistrhoDefines.h"
+
+#if (defined(__WINE__) || defined(DISTRHO_OS_WINDOWS)) && defined(__cdecl)
+# define JACKBRIDGE_API __cdecl
+#else
+# define JACKBRIDGE_API
+#endif
+
+#ifdef JACKBRIDGE_DIRECT
+# include <jack/jack.h>
+# include <jack/midiport.h>
+# include <jack/transport.h>
+# include <jack/session.h>
+# include <jack/metadata.h>
+# include <jack/uuid.h>
+#else
+
+#include <cstddef>
+
+#ifdef DISTRHO_PROPER_CPP11_SUPPORT
+# include <cstdint>
+#else
+# include <stdint.h>
+#endif
+
+#ifndef POST_PACKED_STRUCTURE
+# if defined(__GNUC__)
+ /* POST_PACKED_STRUCTURE needs to be a macro which
+ expands into a compiler directive. The directive must
+ tell the compiler to arrange the preceding structure
+ declaration so that it is packed on byte-boundaries rather
+ than use the natural alignment of the processor and/or
+ compiler.
+ */
+ #define PRE_PACKED_STRUCTURE
+ #define POST_PACKED_STRUCTURE __attribute__((__packed__))
+# elif defined(_MSC_VER)
+ #define PRE_PACKED_STRUCTURE1 __pragma(pack(push,1))
+ #define PRE_PACKED_STRUCTURE PRE_PACKED_STRUCTURE1
+ /* PRE_PACKED_STRUCTURE needs to be a macro which
+ expands into a compiler directive. The directive must
+ tell the compiler to arrange the following structure
+ declaration so that it is packed on byte-boundaries rather
+ than use the natural alignment of the processor and/or
+ compiler.
+ */
+ #define POST_PACKED_STRUCTURE ;__pragma(pack(pop))
+ /* and POST_PACKED_STRUCTURE needs to be a macro which
+ restores the packing to its previous setting */
+# else
+ #define PRE_PACKED_STRUCTURE
+ #define POST_PACKED_STRUCTURE
+# endif
+#endif
+
+#define JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"
+#define JACK_DEFAULT_MIDI_TYPE "8 bit raw midi"
+
+#define JACK_MAX_FRAMES (4294967295U)
+
+#define JackOpenOptions (JackSessionID|JackServerName|JackNoStartServer|JackUseExactName)
+#define JackLoadOptions (JackLoadInit|JackLoadName|JackUseExactName)
+
+#define JACK_POSITION_MASK (JackPositionBBT|JackPositionTimecode|JackBBTFrameOffset|JackAudioVideoRatio|JackVideoFrameOffset)
+#define EXTENDED_TIME_INFO
+
+#define JACK_UUID_SIZE 36
+#define JACK_UUID_STRING_SIZE (JACK_UUID_SIZE+1) /* includes trailing null */
+#define JACK_UUID_EMPTY_INITIALIZER 0
+
+extern "C" {
+
+enum JackOptions {
+ JackNullOption = 0x00,
+ JackNoStartServer = 0x01,
+ JackUseExactName = 0x02,
+ JackServerName = 0x04,
+ JackLoadName = 0x08,
+ JackLoadInit = 0x10,
+ JackSessionID = 0x20
+};
+
+enum JackStatus {
+ JackFailure = 0x0001,
+ JackInvalidOption = 0x0002,
+ JackNameNotUnique = 0x0004,
+ JackServerStarted = 0x0008,
+ JackServerFailed = 0x0010,
+ JackServerError = 0x0020,
+ JackNoSuchClient = 0x0040,
+ JackLoadFailure = 0x0080,
+ JackInitFailure = 0x0100,
+ JackShmFailure = 0x0200,
+ JackVersionError = 0x0400,
+ JackBackendError = 0x0800,
+ JackClientZombie = 0x1000
+};
+
+enum JackLatencyCallbackMode {
+ JackCaptureLatency,
+ JackPlaybackLatency
+};
+
+enum JackPortFlags {
+ JackPortIsInput = 0x01,
+ JackPortIsOutput = 0x02,
+ JackPortIsPhysical = 0x04,
+ JackPortCanMonitor = 0x08,
+ JackPortIsTerminal = 0x10,
+ JackPortIsControlVoltage = 0x100
+};
+
+enum JackTransportState {
+ JackTransportStopped = 0,
+ JackTransportRolling = 1,
+ JackTransportLooping = 2,
+ JackTransportStarting = 3
+};
+
+enum JackPositionBits {
+ JackPositionBBT = 0x010,
+ JackPositionTimecode = 0x020,
+ JackBBTFrameOffset = 0x040,
+ JackAudioVideoRatio = 0x080,
+ JackVideoFrameOffset = 0x100
+};
+
+enum JackSessionEventType {
+ JackSessionSave = 1,
+ JackSessionSaveAndQuit = 2,
+ JackSessionSaveTemplate = 3
+};
+
+enum JackSessionFlags {
+ JackSessionSaveError = 0x1,
+ JackSessionNeedTerminal = 0x2
+};
+
+enum JackPropertyChange {
+ PropertyCreated,
+ PropertyChanged,
+ PropertyDeleted
+};
+
+typedef uint32_t jack_nframes_t;
+typedef uint32_t jack_port_id_t;
+typedef uint64_t jack_time_t;
+typedef uint64_t jack_uuid_t;
+typedef uint64_t jack_unique_t;
+typedef uchar jack_midi_data_t;
+typedef float jack_default_audio_sample_t;
+
+typedef enum JackOptions jack_options_t;
+typedef enum JackStatus jack_status_t;
+typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;
+typedef enum JackTransportState jack_transport_state_t;
+typedef enum JackPositionBits jack_position_bits_t;
+typedef enum JackSessionEventType jack_session_event_type_t;
+typedef enum JackSessionFlags jack_session_flags_t;
+typedef enum JackPropertyChange jack_property_change_t;
+
+struct _jack_midi_event {
+ jack_nframes_t time;
+ size_t size;
+ jack_midi_data_t* buffer;
+};
+
+// NOTE: packed in JACK2 but not in JACK1
+PRE_PACKED_STRUCTURE
+struct _jack_latency_range {
+ jack_nframes_t min;
+ jack_nframes_t max;
+} POST_PACKED_STRUCTURE;
+
+PRE_PACKED_STRUCTURE
+struct _jack_position {
+ jack_unique_t unique_1;
+ jack_time_t usecs;
+ jack_nframes_t frame_rate;
+ jack_nframes_t frame;
+ jack_position_bits_t valid;
+ int32_t bar;
+ int32_t beat;
+ int32_t tick;
+ double bar_start_tick;
+ float beats_per_bar;
+ float beat_type;
+ double ticks_per_beat;
+ double beats_per_minute;
+ double frame_time;
+ double next_time;
+ jack_nframes_t bbt_offset;
+ float audio_frames_per_video_frame;
+ jack_nframes_t video_offset;
+ int32_t padding[7];
+ jack_unique_t unique_2;
+} POST_PACKED_STRUCTURE;
+
+struct _jack_session_event {
+ jack_session_event_type_t type;
+ const char* session_dir;
+ const char* client_uuid;
+ char* command_line;
+ jack_session_flags_t flags;
+ uint32_t future;
+};
+
+struct _jack_session_command_t {
+ const char* uuid;
+ const char* client_name;
+ const char* command;
+ jack_session_flags_t flags;
+};
+
+typedef struct {
+ const char* key;
+ const char* data;
+ const char* type;
+} jack_property_t;
+
+typedef struct {
+ jack_uuid_t subject;
+ uint32_t property_cnt;
+ jack_property_t* properties;
+ uint32_t property_size;
+} jack_description_t;
+
+typedef struct _jack_port jack_port_t;
+typedef struct _jack_client jack_client_t;
+typedef struct _jack_midi_event jack_midi_event_t;
+typedef struct _jack_latency_range jack_latency_range_t;
+typedef struct _jack_position jack_position_t;
+typedef struct _jack_session_event jack_session_event_t;
+typedef struct _jack_session_command_t jack_session_command_t;
+
+typedef void (JACKBRIDGE_API *JackLatencyCallback)(jack_latency_callback_mode_t mode, void* arg);
+typedef int (JACKBRIDGE_API *JackProcessCallback)(jack_nframes_t nframes, void* arg);
+typedef void (JACKBRIDGE_API *JackThreadInitCallback)(void* arg);
+typedef int (JACKBRIDGE_API *JackGraphOrderCallback)(void* arg);
+typedef int (JACKBRIDGE_API *JackXRunCallback)(void* arg);
+typedef int (JACKBRIDGE_API *JackBufferSizeCallback)(jack_nframes_t nframes, void* arg);
+typedef int (JACKBRIDGE_API *JackSampleRateCallback)(jack_nframes_t nframes, void* arg);
+typedef void (JACKBRIDGE_API *JackPortRegistrationCallback)(jack_port_id_t port, int register_, void* arg);
+typedef void (JACKBRIDGE_API *JackClientRegistrationCallback)(const char* name, int register_, void* arg);
+typedef void (JACKBRIDGE_API *JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);
+typedef void (JACKBRIDGE_API *JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg);
+typedef void (JACKBRIDGE_API *JackFreewheelCallback)(int starting, void* arg);
+typedef void (JACKBRIDGE_API *JackShutdownCallback)(void* arg);
+typedef void (JACKBRIDGE_API *JackInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg);
+typedef int (JACKBRIDGE_API *JackSyncCallback)(jack_transport_state_t state, jack_position_t* pos, void* arg);
+typedef void (JACKBRIDGE_API *JackTimebaseCallback)(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg);
+typedef void (JACKBRIDGE_API *JackSessionCallback)(jack_session_event_t* event, void* arg);
+typedef void (JACKBRIDGE_API *JackPropertyChangeCallback)(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg);
+
+} // extern "C"
+
+#endif // ! JACKBRIDGE_DIRECT
+
+JACKBRIDGE_API bool jackbridge_is_ok() noexcept;
+JACKBRIDGE_API void jackbridge_init();
+
+JACKBRIDGE_API void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr);
+JACKBRIDGE_API const char* jackbridge_get_version_string();
+
+JACKBRIDGE_API jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status);
+JACKBRIDGE_API bool jackbridge_client_close(jack_client_t* client);
+
+JACKBRIDGE_API int jackbridge_client_name_size();
+JACKBRIDGE_API char* jackbridge_get_client_name(jack_client_t* client);
+
+JACKBRIDGE_API char* jackbridge_client_get_uuid(jack_client_t* client);
+JACKBRIDGE_API char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name);
+JACKBRIDGE_API char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid);
+
+JACKBRIDGE_API bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid);
+JACKBRIDGE_API void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE]);
+
+JACKBRIDGE_API bool jackbridge_activate(jack_client_t* client);
+JACKBRIDGE_API bool jackbridge_deactivate(jack_client_t* client);
+JACKBRIDGE_API bool jackbridge_is_realtime(jack_client_t* client);
+
+JACKBRIDGE_API bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg);
+JACKBRIDGE_API void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);
+JACKBRIDGE_API void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);
+
+JACKBRIDGE_API bool jackbridge_set_freewheel(jack_client_t* client, bool onoff);
+JACKBRIDGE_API bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes);
+
+JACKBRIDGE_API jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);
+JACKBRIDGE_API jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);
+JACKBRIDGE_API float jackbridge_cpu_load(jack_client_t* client);
+
+JACKBRIDGE_API jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, uint64_t flags, uint64_t buffer_size);
+JACKBRIDGE_API bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);
+JACKBRIDGE_API void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);
+
+JACKBRIDGE_API const char* jackbridge_port_name(const jack_port_t* port);
+JACKBRIDGE_API jack_uuid_t jackbridge_port_uuid(const jack_port_t* port);
+JACKBRIDGE_API const char* jackbridge_port_short_name(const jack_port_t* port);
+JACKBRIDGE_API int jackbridge_port_flags(const jack_port_t* port);
+JACKBRIDGE_API const char* jackbridge_port_type(const jack_port_t* port);
+JACKBRIDGE_API bool jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port);
+JACKBRIDGE_API int jackbridge_port_connected(const jack_port_t* port);
+JACKBRIDGE_API bool jackbridge_port_connected_to(const jack_port_t* port, const char* port_name);
+JACKBRIDGE_API const char** jackbridge_port_get_connections(const jack_port_t* port);
+JACKBRIDGE_API const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port);
+
+JACKBRIDGE_API bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name);
+JACKBRIDGE_API bool jackbridge_port_set_alias(jack_port_t* port, const char* alias);
+JACKBRIDGE_API bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias);
+JACKBRIDGE_API int jackbridge_port_get_aliases(const jack_port_t* port, char* const al[2]);
+
+JACKBRIDGE_API bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff);
+JACKBRIDGE_API bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff);
+JACKBRIDGE_API bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff);
+JACKBRIDGE_API bool jackbridge_port_monitoring_input(jack_port_t* port);
+
+JACKBRIDGE_API bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);
+JACKBRIDGE_API bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);
+JACKBRIDGE_API bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port);
+
+JACKBRIDGE_API int jackbridge_port_name_size();
+JACKBRIDGE_API int jackbridge_port_type_size();
+JACKBRIDGE_API uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type);
+
+JACKBRIDGE_API void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);
+JACKBRIDGE_API void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range);
+JACKBRIDGE_API bool jackbridge_recompute_total_latencies(jack_client_t* client);
+
+JACKBRIDGE_API const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags);
+JACKBRIDGE_API jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);
+JACKBRIDGE_API jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);
+
+JACKBRIDGE_API void jackbridge_free(void* ptr);
+
+JACKBRIDGE_API uint32_t jackbridge_midi_get_event_count(void* port_buffer);
+JACKBRIDGE_API bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);
+JACKBRIDGE_API void jackbridge_midi_clear_buffer(void* port_buffer);
+JACKBRIDGE_API bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size);
+JACKBRIDGE_API jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size);
+
+JACKBRIDGE_API bool jackbridge_release_timebase(jack_client_t* client);
+JACKBRIDGE_API bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout);
+JACKBRIDGE_API bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg);
+JACKBRIDGE_API bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);
+
+JACKBRIDGE_API uint32_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);
+JACKBRIDGE_API jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client);
+
+JACKBRIDGE_API bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos);
+JACKBRIDGE_API void jackbridge_transport_start(jack_client_t* client);
+JACKBRIDGE_API void jackbridge_transport_stop(jack_client_t* client);
+
+JACKBRIDGE_API bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type);
+JACKBRIDGE_API bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type);
+JACKBRIDGE_API void jackbridge_free_description(jack_description_t* desc, bool free_description_itself);
+JACKBRIDGE_API bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc);
+JACKBRIDGE_API bool jackbridge_get_all_properties(jack_description_t** descs);
+JACKBRIDGE_API bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key);
+JACKBRIDGE_API int jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject);
+JACKBRIDGE_API bool jackbridge_remove_all_properties(jack_client_t* client);
+JACKBRIDGE_API bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg);
+
+JACKBRIDGE_API bool jackbridge_sem_init(void* sem) noexcept;
+JACKBRIDGE_API void jackbridge_sem_destroy(void* sem) noexcept;
+JACKBRIDGE_API bool jackbridge_sem_connect(void* sem) noexcept;
+JACKBRIDGE_API void jackbridge_sem_post(void* sem, bool server) noexcept;
+JACKBRIDGE_API bool jackbridge_sem_timedwait(void* sem, uint msecs, bool server) noexcept;
+
+JACKBRIDGE_API bool jackbridge_shm_is_valid(const void* shm) noexcept;
+JACKBRIDGE_API void jackbridge_shm_init(void* shm) noexcept;
+JACKBRIDGE_API void jackbridge_shm_attach(void* shm, const char* name) noexcept;
+JACKBRIDGE_API void jackbridge_shm_close(void* shm) noexcept;
+JACKBRIDGE_API void* jackbridge_shm_map(void* shm, uint64_t size) noexcept;
+JACKBRIDGE_API void jackbridge_shm_unmap(void* shm, void* ptr) noexcept;
+
+JACKBRIDGE_API void jackbridge_parent_deathsig(bool kill) noexcept;
+
+#endif // JACKBRIDGE_HPP_INCLUDED
diff --git a/distrho/src/jackbridge/Makefile b/distrho/src/jackbridge/Makefile
@@ -0,0 +1,257 @@
+#!/usr/bin/make -f
+# Makefile for jackbridge #
+# ----------------------- #
+# Created by falkTX
+#
+
+CWD=..
+MODULENAME=jackbridge
+include ../modules/Makefile.mk
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+BUILD_CXX_FLAGS += $(JACKBRIDGE_FLAGS)
+LINK_FLAGS += $(JACKBRIDGE_LIBS)
+
+WINE_32BIT_FLAGS = $(32BIT_FLAGS) -fpermissive
+WINE_64BIT_FLAGS = $(64BIT_FLAGS) -fpermissive
+WINE_LINK_FLAGS = $(LINK_FLAGS) $(LIBDL_LIBS) -lpthread -lstdc++
+
+ifeq ($(JACKBRIDGE_DIRECT),true)
+BUILD_CXX_FLAGS += $(JACK_FLAGS) -DJACKBRIDGE_DIRECT
+LINK_FLAGS += $(JACK_LIBS)
+endif
+
+ifneq ($(MACOS),true)
+WINE_32BIT_FLAGS += -I/usr/include/wine/wine/windows
+WINE_32BIT_FLAGS += -I/usr/include/wine-development/windows
+WINE_32BIT_FLAGS += -I/opt/wine-devel/include/wine/windows
+WINE_32BIT_FLAGS += -L/usr/lib32/wine
+WINE_32BIT_FLAGS += -L/usr/lib/wine
+WINE_32BIT_FLAGS += -L/usr/lib/i386-linux-gnu/wine
+WINE_32BIT_FLAGS += -L/usr/lib/i386-linux-gnu/wine-development
+WINE_32BIT_FLAGS += -L/opt/wine-stable/lib
+WINE_32BIT_FLAGS += -L/opt/wine-stable/lib/wine
+WINE_32BIT_FLAGS += -L/opt/wine-staging/lib
+WINE_32BIT_FLAGS += -L/opt/wine-staging/lib/wine
+
+WINE_64BIT_FLAGS += -I/usr/include/wine/wine/windows
+WINE_64BIT_FLAGS += -I/usr/include/wine-development/windows
+WINE_64BIT_FLAGS += -I/opt/wine-devel/include/wine/windows
+WINE_64BIT_FLAGS += -L/usr/lib64/wine
+WINE_64BIT_FLAGS += -L/usr/lib/x86_64-linux-gnu/wine
+WINE_64BIT_FLAGS += -L/usr/lib/x86_64-linux-gnu/wine-development
+WINE_64BIT_FLAGS += -L/opt/wine-stable/lib64
+WINE_64BIT_FLAGS += -L/opt/wine-stable/lib64/wine
+WINE_64BIT_FLAGS += -L/opt/wine-staging/lib64
+WINE_64BIT_FLAGS += -L/opt/wine-staging/lib64/wine
+
+WINE_LINK_FLAGS += -lrt
+endif
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+OBJS = $(OBJDIR)/JackBridge1.cpp.o $(OBJDIR)/JackBridge2.cpp.o
+OBJS_arm32 = $(OBJDIR)/JackBridge1.cpp.arm32.o $(OBJDIR)/JackBridge2.cpp.arm32.o
+OBJS_posix32 = $(OBJDIR)/JackBridge1.cpp.posix32.o $(OBJDIR)/JackBridge2.cpp.posix32.o
+OBJS_posix64 = $(OBJDIR)/JackBridge1.cpp.posix64.o $(OBJDIR)/JackBridge2.cpp.posix64.o
+OBJS_win32 = $(OBJDIR)/JackBridge1.cpp.win32.o $(OBJDIR)/JackBridge2.cpp.win32.o
+OBJS_win64 = $(OBJDIR)/JackBridge1.cpp.win64.o $(OBJDIR)/JackBridge2.cpp.win64.o
+OBJS_wine32 = $(OBJDIR)/JackBridge1.cpp.wine32.o $(OBJDIR)/JackBridge2.cpp.wine32.o $(OBJDIR)/JackBridge3.cpp.wine32.o
+OBJS_wine64 = $(OBJDIR)/JackBridge1.cpp.wine64.o $(OBJDIR)/JackBridge2.cpp.wine64.o $(OBJDIR)/JackBridge3.cpp.wine64.o
+
+OBJS_posix32e = $(OBJDIR)/JackBridgeExport.cpp.posix32e.o
+OBJS_posix64e = $(OBJDIR)/JackBridgeExport.cpp.posix64e.o
+OBJS_win64e = $(OBJDIR)/JackBridgeExport.cpp.win64e.o
+OBJS_win32e = $(OBJDIR)/JackBridgeExport.cpp.win32e.o
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+all: $(MODULEDIR)/$(MODULENAME).a
+
+ifeq ($(WIN32),true)
+posix32:
+posix64:
+posix32e:
+posix64e:
+win32: $(MODULEDIR)/$(MODULENAME).win32.a
+win64: $(MODULEDIR)/$(MODULENAME).win64.a
+win32e: $(MODULEDIR)/$(MODULENAME).win32e.a
+win64e: $(MODULEDIR)/$(MODULENAME).win64e.a
+wine32:
+wine64:
+else
+arm32: $(MODULEDIR)/$(MODULENAME).arm32.a
+posix32: $(MODULEDIR)/$(MODULENAME).posix32.a
+posix64: $(MODULEDIR)/$(MODULENAME).posix64.a
+posix32e: $(MODULEDIR)/$(MODULENAME).posix32e.a
+posix64e: $(MODULEDIR)/$(MODULENAME).posix64e.a
+win32:
+win64:
+win32e:
+win64e:
+wine32: $(MODULEDIR)/$(MODULENAME)-wine32.dll$(LIB_EXT)
+wine64: $(MODULEDIR)/$(MODULENAME)-wine64.dll$(LIB_EXT)
+endif
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+clean:
+ rm -f $(OBJDIR)/*.o $(MODULEDIR)/$(MODULENAME)*.*
+
+debug:
+ $(MAKE) DEBUG=true
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+$(MODULEDIR)/$(MODULENAME).a: $(OBJS)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).arm32.a: $(OBJS_arm32)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).arm32.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).posix32.a: $(OBJS_posix32)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).posix32.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).posix64.a: $(OBJS_posix64)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).posix64.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).win32.a: $(OBJS_win32)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).win32.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).win64.a: $(OBJS_win64)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).win64.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+$(MODULEDIR)/$(MODULENAME).posix32e.a: $(OBJS_posix32e)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).posix32e.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).posix64e.a: $(OBJS_posix64e)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).posix64e.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).win32e.a: $(OBJS_win32e)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).win32e.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+$(MODULEDIR)/$(MODULENAME).win64e.a: $(OBJS_win64e)
+ -@mkdir -p $(MODULEDIR)
+ @echo "Creating $(MODULENAME).win64e.a"
+ @rm -f $@
+ @$(AR) crs $@ $^
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+$(MODULEDIR)/$(MODULENAME)-wine32.dll$(LIB_EXT): $(OBJS_wine32) JackBridgeExport.def
+ -@mkdir -p $(MODULEDIR)
+ @echo "Linking $(MODULENAME)-wine32.dll$(LIB_EXT)"
+ @$(WINECC) $^ $(WINE_32BIT_FLAGS) $(WINE_LINK_FLAGS) $(SHARED) -o $@
+
+$(MODULEDIR)/$(MODULENAME)-wine64.dll$(LIB_EXT): $(OBJS_wine64) JackBridgeExport.def
+ -@mkdir -p $(MODULEDIR)
+ @echo "Linking $(MODULENAME)-wine64.dll$(LIB_EXT)"
+ @$(WINECC) $^ $(WINE_64BIT_FLAGS) $(WINE_LINK_FLAGS) $(SHARED) -o $@
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+$(OBJDIR)/JackBridge1.cpp.o: JackBridge1.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling JackBridge1.cpp"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@
+
+$(OBJDIR)/JackBridge2.cpp.o: JackBridge2.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling JackBridge2.cpp"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+$(OBJDIR)/JackBridgeExport.cpp.%32e.o: JackBridgeExport.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $<"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) $(32BIT_FLAGS) -fpermissive -c -o $@
+
+$(OBJDIR)/JackBridgeExport.cpp.%64e.o: JackBridgeExport.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $<"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) $(64BIT_FLAGS) -fpermissive -c -o $@
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+$(OBJDIR)/%.cpp.arm32.o: %.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $< (arm32)"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) $(ARM32_FLAGS) -c -o $@
+
+$(OBJDIR)/%.cpp.posix32.o: %.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $< (posix32)"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) $(32BIT_FLAGS) -c -o $@
+
+$(OBJDIR)/%.cpp.posix64.o: %.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $< (posix64)"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) $(64BIT_FLAGS) -c -o $@
+
+$(OBJDIR)/%.cpp.win32.o: %.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $< (win32)"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) $(32BIT_FLAGS) -c -o $@
+
+$(OBJDIR)/%.cpp.win64.o: %.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $< (win64)"
+ @$(CXX) $< $(BUILD_CXX_FLAGS) $(64BIT_FLAGS) -c -o $@
+
+$(OBJDIR)/%.cpp.wine32.o: %.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $< (wine32)"
+ @$(WINECC) $< $(BUILD_CXX_FLAGS) $(WINE_32BIT_FLAGS) -c -o $@
+
+$(OBJDIR)/%.cpp.wine64.o: %.cpp
+ -@mkdir -p $(OBJDIR)
+ @echo "Compiling $< (wine64)"
+ @$(WINECC) $< $(BUILD_CXX_FLAGS) $(WINE_64BIT_FLAGS) -c -o $@
+
+# ---------------------------------------------------------------------------------------------------------------------
+
+-include $(OBJS:%.o=%.d)
+-include $(OBJS_arm32:%.o=%.d)
+-include $(OBJS_posix32:%.o=%.d)
+-include $(OBJS_posix32e:%.o=%.d)
+-include $(OBJS_posix64:%.o=%.d)
+-include $(OBJS_posix64e:%.o=%.d)
+-include $(OBJS_win32:%.o=%.d)
+-include $(OBJS_win32e:%.o=%.d)
+-include $(OBJS_win64:%.o=%.d)
+-include $(OBJS_win64e:%.o=%.d)
+-include $(OBJS_wine32:%.o=%.d)
+-include $(OBJS_wine64:%.o=%.d)
+
+# ---------------------------------------------------------------------------------------------------------------------
diff --git a/examples/Info/Makefile b/examples/Info/Makefile
@@ -26,11 +26,9 @@ include ../../Makefile.plugins.mk
# --------------------------------------------------------------
# Enable all possible plugin types
-ifeq ($(HAVE_JACK),true)
ifeq ($(HAVE_OPENGL),true)
TARGETS += jack
endif # HAVE_OPENGL
-endif # HAVE_JACK
ifeq ($(HAVE_OPENGL),true)
TARGETS += lv2_sep
