Cleanup; Complete JACK bridge (JACK build always enabled now)

source/Makefile.mk

@@ -48,7 +48,6 @@ BUILD_CXX_FLAGS += -DVESTIGE_HEADER
 
 # --------------------------------------------------------------
 
-HAVE_JACK         = $(shell pkg-config --exists jack && echo true)
 HAVE_OPENGL       = $(shell pkg-config --exists gl && echo true)
 HAVE_QT4          = $(shell pkg-config --exists QtCore && echo true)
 
@@ -57,11 +56,6 @@ HAVE_MF_DEPS      = $(shell pkg-config --exists smf && echo true)
 HAVE_ZYN_DEPS     = $(shell pkg-config --exists fftw3 mxml zlib && echo true)
 HAVE_ZYN_UI_DEPS  = $(shell pkg-config --exists ntk ntk_images && echo true)
 
-ifeq ($(HAVE_JACK),true)
-HAVE_JACK_LATENCY = $(shell pkg-config --atleast-version=0.121.0 jack && echo true)
-HAVE_JACK2        = $(shell pkg-config --atleast-version=1.9.0 jack && echo true)
-endif
-
 ifeq ($(CARLA_SAMPLERS_SUPPORT),true)
 HAVE_FLUIDSYNTH   = $(shell pkg-config --exists fluidsynth && echo true)
 HAVE_LINUXSAMPLER = $(shell pkg-config --exists linuxsampler && echo true)

source/backend/CarlaEngine.hpp

@@ -1028,9 +1028,7 @@ protected:
 # endif
 
 private:
-# ifdef WANT_JACK
     static CarlaEngine* newJack();
-# endif
 # ifdef WANT_RTAUDIO
     enum RtAudioApi {
         RTAUDIO_DUMMY        = 0,

source/backend/Makefile

@@ -44,11 +44,7 @@ ifeq ($(HAVE_ALSA),true)
 else
 	@echo "ALSA:      $(ANS_NO)"
 endif
-ifeq ($(HAVE_JACK),true)
 	@echo "JACK:      $(ANS_YES)"
-else
-	@echo "JACK:      $(ANS_NO)"
-endif
 ifeq ($(HAVE_PULSEAUDIO),true)
 	@echo "PulseAudio:$(ANS_YES)"
 else

source/backend/Makefile.mk

@@ -30,18 +30,6 @@ endif
 
 # --------------------------------------------------------------
 
-ifeq ($(HAVE_JACK),true)
-BUILD_CXX_FLAGS += -DWANT_JACK
-endif
-
-ifeq ($(HAVE_JACK_LATENCY),true)
-# BUILD_CXX_FLAGS += -DWANT_JACK_LATENCY # unfinished
-endif
-
-ifeq ($(HAVE_JACK2),true)
-BUILD_CXX_FLAGS += -DWANT_JACK_PORT_RENAME
-endif
-
 ifeq ($(HAVE_FLUIDSYNTH),true)
 BUILD_CXX_FLAGS += -DWANT_FLUIDSYNTH
 endif

source/backend/engine/CarlaEngine.cpp

@@ -444,11 +444,8 @@ unsigned int CarlaEngine::getDriverCount()
 {
     carla_debug("CarlaEngine::getDriverCount()");
 
-    unsigned int count = 0;
+    unsigned int count = 1;
 
-#ifdef WANT_JACK
-    count += 1;
-#endif
 #ifdef WANT_RTAUDIO
     count += getRtAudioApiCount();
 #endif
@@ -460,12 +457,10 @@ const char* CarlaEngine::getDriverName(unsigned int index)
 {
     carla_debug("CarlaEngine::getDriverName(%i)", index);
 
-#ifdef WANT_JACK
     if (index == 0)
         return "JACK";
     else
         index -= 1;
-#endif
 
 #ifdef WANT_RTAUDIO
     if (index < getRtAudioApiCount())
@@ -480,10 +475,8 @@ CarlaEngine* CarlaEngine::newDriverByName(const char* const driverName)
 {
     carla_debug("CarlaEngine::newDriverByName(\"%s\")", driverName);
 
-#ifdef WANT_JACK
     if (std::strcmp(driverName, "JACK") == 0)
         return newJack();
-#endif
 
 #ifdef WANT_RTAUDIO
 # ifdef __LINUX_ALSA__
@@ -558,6 +551,9 @@ bool CarlaEngine::init(const char* const clientName)
     kData->aboutToClose = false;
     kData->curPluginCount = 0;
 
+#ifdef BUILD_BRIDGE
+    kData->maxPluginNumber = 1;
+#else
     switch (fOptions.processMode)
     {
     case PROCESS_MODE_CONTINUOUS_RACK:
@@ -568,13 +564,11 @@ bool CarlaEngine::init(const char* const clientName)
     case PROCESS_MODE_PATCHBAY:
         kData->maxPluginNumber = MAX_PATCHBAY_PLUGINS;
         break;
-    case PROCESS_MODE_BRIDGE:
-        kData->maxPluginNumber = 1;
-        break;
     default:
         kData->maxPluginNumber = MAX_DEFAULT_PLUGINS;
         break;
     }
+#endif
 
     //kData->pluginsPool.resize(maxPluginNumber, 999);
     kData->plugins = new EnginePluginData[kData->maxPluginNumber];
@@ -627,6 +621,7 @@ bool CarlaEngine::close()
         kData->plugins = nullptr;
     }
 
+#ifndef BUILD_BRIDGE
     if (kData->rack.in != nullptr)
     {
         delete[] kData->rack.in;
@@ -638,6 +633,7 @@ bool CarlaEngine::close()
         delete[] kData->rack.out;
         kData->rack.out = nullptr;
     }
+#endif
 
     fName.clear();
 

source/backend/engine/CarlaEngine.pro

@@ -23,9 +23,6 @@ DEFINES   += WANT_LV2
 DEFINES   += WANT_VST
 DEFINES   += WANT_PLUGIN
 DEFINES   += WANT_RTAUDIO
-DEFINES   += WANT_JACK
-DEFINES   += WANT_JACK_LATENCY
-DEFINES   += WANT_JACK_PORT_RENAME
 DEFINES   += WANT_FLUIDSYNTH
 DEFINES   += WANT_LINUXSAMPLER
 DEFINES   += WANT_OPENGL

source/backend/engine/CarlaEngineBridge.cpp

@@ -21,10 +21,10 @@
 #include "CarlaBackendUtils.hpp"
 #include "CarlaMIDI.h"
 
-#include "../CarlaBridge.hpp"
+#include "CarlaBridgeUtils.hpp"
 #include "CarlaShmUtils.hpp"
 
-#include "jackbridge/jackbridge.h"
+#include "jackbridge/JackBridge.hpp"
 
 #include <ctime>
 
@@ -41,7 +41,7 @@ CARLA_BACKEND_START_NAMESPACE
 // -----------------------------------------
 
 class CarlaEngineBridge : public CarlaEngine,
-                          public CarlaThread
+                          public QThread
 {
 public:
     CarlaEngineBridge(const char* const audioBaseName, const char* const controlBaseName)
@@ -123,7 +123,7 @@ public:
         fQuitNow = false;
         fIsRunning = true;
 
-        CarlaThread::start();
+        QThread::start();
         CarlaEngine::init(clientName);
         return true;
     }
@@ -134,7 +134,7 @@ public:
         CarlaEngine::close();
 
         fQuitNow = true;
-        CarlaThread::stop();
+        QThread::wait();
 
         _cleanup();
 
@@ -185,7 +185,7 @@ public:
                 ts_timeout.tv_sec++;
             }
 
-            if (linux_sem_timedwait(&fShmControl.data->runServer, &ts_timeout))
+            //if (linux_sem_timedwait(&fShmControl.data->runServer, &ts_timeout))
             {
                 if (errno == ETIMEDOUT)
                 {
@@ -243,8 +243,8 @@ public:
                 }
             }
 
-            if (linux_sem_post(&fShmControl.data->runClient) != 0)
-                carla_stderr2("Could not post to semaphore");
+            //if (linux_sem_post(&fShmControl.data->runClient) != 0)
+            //    carla_stderr2("Could not post to semaphore");
         }
 
         fIsRunning = false;

source/backend/engine/CarlaEngineInternal.hpp

@@ -173,6 +173,7 @@ struct CarlaEngineProtectedData {
             : in(nullptr),
               out(nullptr) {}
     } rack;
+#endif
 
     struct Time {
         bool playing;
@@ -182,7 +183,6 @@ struct CarlaEngineProtectedData {
             : playing(false),
               frame(0) {}
     } time;
-#endif
 
     EnginePluginData* plugins;
 

source/backend/engine/CarlaEngineJack.cpp

@@ -15,13 +15,15 @@
  * For a full copy of the GNU General Public License see the GPL.txt file
  */
 
-#ifdef WANT_JACK
-
 #include "CarlaEngineInternal.hpp"
 #include "CarlaBackendUtils.hpp"
 #include "CarlaMIDI.h"
 
-#include "jackbridge/JackBridge.cpp"
+#ifdef BUILD_BRIDGE
+# include "jackbridge/JackBridge.hpp"
+#else
+# include "jackbridge/JackBridge.cpp"
+#endif
 
 #include <cmath>
 #include <QtCore/QStringList>
@@ -182,7 +184,7 @@ public:
 
         jack_midi_event_t jackEvent;
 
-        if (jackbridge_midi_event_get(&jackEvent, fJackBuffer, index) != 0 || jackEvent.size > 3)
+        if ((! jackbridge_midi_event_get(&jackEvent, fJackBuffer, index)) || jackEvent.size > 4)
             return kFallbackJackEngineEvent;
 
         fRetEvent.clear();
@@ -204,19 +206,19 @@ public:
 
                 fRetEvent.ctrl.type  = kEngineControlEventTypeMidiBank;
                 fRetEvent.ctrl.param = midiBank;
-                fRetEvent.ctrl.value = 0.0;
+                fRetEvent.ctrl.value = 0.0f;
             }
             else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)
             {
                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllSoundOff;
                 fRetEvent.ctrl.param = 0;
-                fRetEvent.ctrl.value = 0.0;
+                fRetEvent.ctrl.value = 0.0f;
             }
             else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)
             {
                 fRetEvent.ctrl.type  = kEngineControlEventTypeAllNotesOff;
                 fRetEvent.ctrl.param = 0;
-                fRetEvent.ctrl.value = 0.0;
+                fRetEvent.ctrl.value = 0.0f;
             }
             else
             {
@@ -224,7 +226,7 @@ public:
 
                 fRetEvent.ctrl.type  = kEngineControlEventTypeParameter;
                 fRetEvent.ctrl.param = midiControl;
-                fRetEvent.ctrl.value = double(midiValue)/127.0;
+                fRetEvent.ctrl.value = float(midiValue)/127.0f;
             }
         }
         else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))
@@ -234,7 +236,7 @@ public:
 
             fRetEvent.ctrl.type  = kEngineControlEventTypeMidiProgram;
             fRetEvent.ctrl.param = midiProgram;
-            fRetEvent.ctrl.value = 0.0;
+            fRetEvent.ctrl.value = 0.0f;
         }
         else
         {
@@ -432,7 +434,7 @@ public:
         return CarlaEngineClient::isOk();
     }
 
-#if WANT_JACK_LATENCY
+#if 0
     void setLatency(const uint32_t samples) override
     {
         CarlaEngineClient::setLatency(samples);
@@ -583,7 +585,7 @@ public:
             jackbridge_set_freewheel_callback(fClient, carla_jack_freewheel_callback, this);
             jackbridge_set_process_callback(fClient, carla_jack_process_callback, this);
             jackbridge_on_shutdown(fClient, carla_jack_shutdown_callback, this);
-# if WANT_JACK_LATENCY
+# if 0
             jackbridge_set_latency_callback(fClient, carla_jack_latency_callback, this);
 # endif
 
@@ -606,7 +608,7 @@ public:
                 fRackPorts[rackPortEventOut]  = jackbridge_port_register(fClient, "events-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
             }
 
-            if (jackbridge_activate(fClient) == 0)
+            if (jackbridge_activate(fClient))
             {
                 return CarlaEngine::init(jackClientName);
             }
@@ -648,7 +650,7 @@ public:
         fHasQuit = true;
         return true;
 #else
-        if (jackbridge_deactivate(fClient) == 0)
+        if (jackbridge_deactivate(fClient))
         {
             if (fOptions.processMode == PROCESS_MODE_CONTINUOUS_RACK)
             {
@@ -660,7 +662,7 @@ public:
                 jackbridge_port_unregister(fClient, fRackPorts[rackPortEventOut]);
             }
 
-            if (jackbridge_client_close(fClient) == 0)
+            if (jackbridge_client_close(fClient))
             {
                 fClient = nullptr;
                 return true;
@@ -714,7 +716,7 @@ public:
         jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);
         jackbridge_set_process_callback(client, carla_jack_process_callback, this);
         jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);
-# if WANT_JACK_LATENCY
+# if 0
         jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);
 # endif
 #else
@@ -726,7 +728,7 @@ public:
         {
             client = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);
             jackbridge_set_process_callback(client, carla_jack_process_callback_plugin, plugin);
-# if WANT_JACK_LATENCY
+# if 0
             jackbridge_set_latency_callback(client, carla_jack_latency_callback_plugin, plugin);
 # endif
         }
@@ -752,7 +754,7 @@ public:
         const char* const portNameA = getFullPortName(portA).toUtf8().constData();
         const char* const portNameB = getFullPortName(portB).toUtf8().constData();
 
-        if (jack_connect(fClient, portNameA, portNameB) != 0)
+        if (! jackbridge_connect(fClient, portNameA, portNameB))
         {
             setLastError("JACK operation failed");
             return false;
@@ -778,7 +780,7 @@ public:
                 const char* const portNameA = getFullPortName(fUsedConnections[i].portOut).toUtf8().constData();
                 const char* const portNameB = getFullPortName(fUsedConnections[i].portIn).toUtf8().constData();
 
-                if (jack_disconnect(fClient, portNameA, portNameB) != 0)
+                if (! jackbridge_disconnect(fClient, portNameA, portNameB))
                 {
                     setLastError("JACK operation failed");
                     return false;
@@ -1147,7 +1149,7 @@ protected:
         proccessPendingEvents();
     }
 
-#if WANT_JACK_LATENCY
+#if 0
     void handleJackLatencyCallback(const jack_latency_callback_mode_t mode)
     {
         if (fOptions.processMode != PROCESS_MODE_SINGLE_CLIENT)
@@ -1192,18 +1194,18 @@ protected:
 
     void handleJackPortRegistrationCallback(jack_port_id_t port, bool reg)
     {
-        jack_port_t* jackPort = jack_port_by_id(fClient, port);
+        jack_port_t* jackPort = jackbridge_port_by_id(fClient, port);
 
-        QString fullName(jack_port_name(jackPort));
+        QString fullName(jackbridge_port_name(jackPort));
         QString groupName = fullName.split(":").at(0);
         int     groupId   = getGroupId(groupName);
 
-        const char* portName = jack_port_short_name(jackPort);
+        const char* portName = jackbridge_port_short_name(jackPort);
 
         if (reg)
         {
-            bool portIsInput = (jack_port_flags(jackPort) & JackPortIsInput);
-            bool portIsAudio = (std::strcmp(jack_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);
+            bool portIsInput = (jackbridge_port_flags(jackPort) & JackPortIsInput);
+            bool portIsAudio = (std::strcmp(jackbridge_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);
 
             unsigned int portFlags = 0x0;
             portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;
@@ -1235,11 +1237,11 @@ protected:
 
     void handleJackPortConnectCallback(jack_port_id_t a, jack_port_id_t b, bool connect)
     {
-        jack_port_t* jackPortA = jack_port_by_id(fClient, a);
-        jack_port_t* jackPortB = jack_port_by_id(fClient, b);
+        jack_port_t* jackPortA = jackbridge_port_by_id(fClient, a);
+        jack_port_t* jackPortB = jackbridge_port_by_id(fClient, b);
 
-        int portIdA = getPortId(QString(jack_port_name(jackPortA)));
-        int portIdB = getPortId(QString(jack_port_name(jackPortB)));
+        int portIdA = getPortId(QString(jackbridge_port_name(jackPortA)));
+        int portIdB = getPortId(QString(jackbridge_port_name(jackPortB)));
 
         if (connect)
         {
@@ -1268,13 +1270,13 @@ protected:
 
     void handleJackPortRenameCallback(jack_port_id_t port, const char* oldName, const char* newName)
     {
-        jack_port_t* jackPort = jack_port_by_id(fClient, port);
+        jack_port_t* jackPort = jackbridge_port_by_id(fClient, port);
 
         QString fullName(oldName);
         QString groupName = fullName.split(":").at(0);
         int     groupId   = getGroupId(groupName);
 
-        const char* portName = jack_port_short_name(jackPort);
+        const char* portName = jackbridge_port_short_name(jackPort);
 
         for (int i=0, count=fUsedPortNames.count(); i < count; ++i)
         {
@@ -1416,12 +1418,12 @@ private:
             parsedGroups.append(QString(ourName));
         }
 
-        if (const char** ports = jack_get_ports(fClient, nullptr, nullptr, 0))
+        if (const char** ports = jackbridge_get_ports(fClient, nullptr, nullptr, 0))
         {
             for (int i=0; ports[i] != nullptr; ++i)
             {
-                jack_port_t* jackPort = jack_port_by_name(fClient, ports[i]);
-                const char* portName  = jack_port_short_name(jackPort);
+                jack_port_t* jackPort = jackbridge_port_by_name(fClient, ports[i]);
+                const char* portName  = jackbridge_port_short_name(jackPort);
 
                 QString fullName(ports[i]);
                 QString groupName(fullName.split(":").at(0));
@@ -1448,8 +1450,8 @@ private:
                     callback(CALLBACK_PATCHBAY_CLIENT_ADDED, 0, groupId, 0, 0.0f, groupName.toUtf8().constData());
                 }
 
-                bool portIsInput = (jack_port_flags(jackPort) & JackPortIsInput);
-                bool portIsAudio = (std::strcmp(jack_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);
+                bool portIsInput = (jackbridge_port_flags(jackPort) & JackPortIsInput);
+                bool portIsAudio = (std::strcmp(jackbridge_port_type(jackPort), JACK_DEFAULT_AUDIO_TYPE) == 0);
 
                 unsigned int portFlags = 0x0;
                 portFlags |= portIsInput ? PATCHBAY_PORT_IS_INPUT : PATCHBAY_PORT_IS_OUTPUT;
@@ -1466,19 +1468,19 @@ private:
                 fLastPortId++;
             }
 
-            jack_free(ports);
+            jackbridge_free(ports);
         }
 
         // query connections, after all ports are in place
-        if (const char** ports = jack_get_ports(fClient, nullptr, nullptr, JackPortIsOutput))
+        if (const char** ports = jackbridge_get_ports(fClient, nullptr, nullptr, JackPortIsOutput))
         {
             for (int i=0; ports[i] != nullptr; ++i)
             {
-                jack_port_t* jackPort = jack_port_by_name(fClient, ports[i]);
+                jack_port_t* jackPort = jackbridge_port_by_name(fClient, ports[i]);
 
                 int thisPortId = getPortId(QString(ports[i]));
 
-                if (const char** jackConnections = jack_port_get_connections(jackPort))
+                if (const char** jackConnections = jackbridge_port_get_connections(jackPort))
                 {
                     for (int j=0; jackConnections[j] != nullptr; ++j)
                     {
@@ -1494,11 +1496,11 @@ private:
                         fLastConnectionId++;
                     }
 
-                    jack_free(jackConnections);
+                    jackbridge_free(jackConnections);
                 }
             }
 
-            jack_free(ports);
+            jackbridge_free(ports);
         }
     }
 #endif
@@ -1560,7 +1562,7 @@ private:
         setPeaks(plugin->id(), inPeaks, outPeaks);
     }
 
-#if WANT_JACK_LATENCY
+#if 0
     void latencyPlugin(CarlaPlugin* const plugin, jack_latency_callback_mode_t mode)
     {
         const uint32_t inCount  = plugin->audioInCount();
@@ -1630,7 +1632,7 @@ private:
         return 0;
     }
 
-#if WANT_JACK_LATENCY
+#if 0
     static void carla_jack_latency_callback(jack_latency_callback_mode_t mode, void* arg)
     {
         handlePtr->handleJackLatencyCallback(mode);
@@ -1689,7 +1691,7 @@ private:
         return 0;
     }
 
-# if WANT_JACK_LATENCY
+# if 0
     static void carla_jack_latency_callback_plugin(jack_latency_callback_mode_t mode, void* arg)
     {
         CarlaPlugin* const plugin = (CarlaPlugin*)arg;
@@ -1717,5 +1719,3 @@ CarlaEngine* CarlaEngine::newJack()
 // -----------------------------------------
 
 CARLA_BACKEND_END_NAMESPACE
-
-#endif // CARLA_ENGINE_JACK

source/backend/engine/Makefile

@@ -8,15 +8,13 @@ include ../Makefile.mk
 
 # --------------------------------------------------------------
 
+BUILD_CXX_FLAGS += -D__UNIX_JACK__
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags liblo)
-LINK_FLAGS      += $(shell pkg-config --libs liblo)
 
 ifeq ($(HAVE_QT5),true)
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags Qt5Core Qt5Xml)
-LINK_FLAGS      += $(shell pkg-config --libs Qt5Core Qt5Xml)
 else
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags QtCore QtXml)
-LINK_FLAGS      += $(shell pkg-config --libs QtCore QtXml)
 endif
 
 # --------------------------------------------------------------
@@ -33,17 +31,10 @@ endif
 
 ifeq ($(HAVE_ALSA),true)
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags alsa) -D__LINUX_ALSA__ -D__LINUX_ALSASEQ__
-LINK_FLAGS      += $(shell pkg-config --libs alsa)
-endif
-
-ifeq ($(HAVE_JACK),true)
-BUILD_CXX_FLAGS += $(shell pkg-config --cflags jack) -D__UNIX_JACK__
-LINK_FLAGS      += $(shell pkg-config --libs jack)
 endif
 
 ifeq ($(HAVE_PULSEAUDIO),true)
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags libpulse-simple) -D__LINUX_PULSE__
-LINK_FLAGS      += $(shell pkg-config --libs libpulse-simple)
 endif
 
 ifeq ($(MACOS),true)
@@ -83,15 +74,14 @@ OBJS += \
 endif
 endif
 
-SHARED = ../libcarla_engine.so
-STATIC = ../libcarla_engine.a
+TARGET = ../libcarla_engine.a
 
 # --------------------------------------------------------------
 
-all: $(STATIC)
+all: $(TARGET)
 
 clean:
-	rm -f $(OBJS) $(SHARED) $(STATIC)
+	rm -f $(OBJS) $(TARGET)
 
 debug:
 	$(MAKE) DEBUG=true
@@ -110,8 +100,5 @@ debug:
 %.cpp.vst.o: %.cpp ../CarlaBackend.hpp ../CarlaEngine.hpp ../CarlaPlugin.hpp CarlaEngineInternal.hpp CarlaEngineOsc.hpp CarlaEngineThread.hpp
 	$(CXX) $< $(PLUGIN_CXX_FLAGS) -DDISTRHO_PLUGIN_TARGET_VST -c -o $@
 
-$(SHARED): $(OBJS)
-	$(CXX) $^ -shared $(LINK_FLAGS) -o $@ && $(STRIP) $@
-
-$(STATIC): $(OBJS)
+$(TARGET): $(OBJS)
 	$(AR) rs $@ $^

source/backend/native/Makefile

@@ -9,14 +9,11 @@ include ../Makefile.mk
 # --------------------------------------------------------------
 
 BUILD_CXX_FLAGS += -I. -I../../libs/distrho -I../../widgets
-LINK_FLAGS      += $(shell pkg-config --libs liblo)
 
 ifeq ($(HAVE_QT5),true)
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags Qt5Core Qt5Widgets)
-LINK_FLAGS      += $(shell pkg-config --libs Qt5Core Qt5Widgets)
 else
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags QtCore QtGui)
-LINK_FLAGS      += $(shell pkg-config --libs QtCore QtGui)
 endif
 
 # --------------------------------------------------------------
@@ -28,29 +25,24 @@ CARLA_CXX_FLAGS += -I../engine
 ifeq ($(HAVE_AF_DEPS),true)
 AF_C_FLAGS       = $(BUILD_C_FLAGS)
 AF_C_FLAGS      += $(shell pkg-config --cflags libavcodec libavformat libavutil sndfile)
-LINK_FLAGS      += $(shell pkg-config --libs libavcodec libavformat libavutil sndfile)
 endif
 
 ifeq ($(HAVE_MF_DEPS),true)
 MF_CXX_FLAGS     = $(BUILD_CXX_FLAGS)
 MF_CXX_FLAGS    += $(shell pkg-config --cflags smf)
-LINK_FLAGS      += $(shell pkg-config --libs smf)
 endif
 
 ifeq ($(HAVE_OPENGL),true)
 GL_CXX_FLAGS     = $(BUILD_CXX_FLAGS)
 GL_CXX_FLAGS    += $(shell pkg-config --cflags gl)
-LINK_FLAGS      += $(shell pkg-config --cflags gl)
 endif
 
 ifeq ($(HAVE_ZYN_DEPS),true)
 ZYN_CXX_FLAGS    = $(BUILD_CXX_FLAGS)
 ZYN_CXX_FLAGS   += $(shell pkg-config --cflags fftw3 mxml zlib)
-LINK_FLAGS      += $(shell pkg-config --libs fftw3 mxml zlib)
 ifeq ($(HAVE_ZYN_UI_DEPS),true)
 ZYN_CXX_FLAGS   += -DNTK_GUI
 ZYN_CXX_FLAGS   += $(shell pkg-config --cflags ntk ntk_images)
-LINK_FLAGS      += $(shell pkg-config --libs ntk ntk_images)
 endif
 endif
 
@@ -146,21 +138,14 @@ ZYN_UI_FILES_H = \
 endif
 endif
 
-SHARED = ../libcarla_native.so
-STATIC = ../libcarla_native.a
-
-LIBS  = ../../libs/widgets.a
-
-ifeq ($(HAVE_OPENGL),true)
-LIBS += ../../libs/dgl.a
-endif
+TARGET = ../libcarla_native.a
 
 # --------------------------------------------------------------
 
-all: $(STATIC)
+all: $(TARGET)
 
 clean:
-	rm -f $(OBJS) $(SHARED) $(STATIC)
+	rm -f $(OBJS) $(TARGET)
 	rm -f $(ZYN_UI_FILES_CPP)
 	rm -f $(ZYN_UI_FILES_H)
 	rm -f moc_*.cpp
@@ -176,10 +161,7 @@ debug:
 %.cpp.o: %.cpp ../CarlaNative.h ../CarlaNative.hpp
 	$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@
 
-$(SHARED): $(OBJS) $(LIBS)
-	$(CXX) $^ -shared $(LINK_FLAGS) -o $@
-
-$(STATIC): $(OBJS)
+$(TARGET): $(OBJS)
 	$(AR) rs $@ $^
 
 # --------------------------------------------------------------

source/backend/plugin/Makefile

@@ -9,26 +9,21 @@ include ../Makefile.mk
 # --------------------------------------------------------------
 
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags liblo)
-LINK_FLAGS      += $(shell pkg-config --libs liblo)
 
 ifeq ($(HAVE_QT5),true)
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags Qt5Core Qt5Xml Qt5Widgets)
-LINK_FLAGS      += $(shell pkg-config --libs Qt5Core Qt5Xml Qt5Widgets)
 else
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags QtCore QtGui QtXml)
-LINK_FLAGS      += $(shell pkg-config --libs QtCore QtGui QtXml)
 endif
 
 # --------------------------------------------------------------
 
 ifeq ($(HAVE_FLUIDSYNTH),true)
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags fluidsynth)
-LINK_FLAGS      += $(shell pkg-config --libs fluidsynth)
 endif
 
 ifeq ($(HAVE_LINUXSAMPLER),true)
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags linuxsampler)
-LINK_FLAGS      += $(shell pkg-config --libs linuxsampler)
 endif
 
 # --------------------------------------------------------------
@@ -47,15 +42,14 @@ OBJS = \
 	FluidSynthPlugin.cpp.o \
 	LinuxSamplerPlugin.cpp.o
 
-SHARED = ../libcarla_plugin.so
-STATIC = ../libcarla_plugin.a
+TARGET = ../libcarla_plugin.a
 
 # --------------------------------------------------------------
 
-all: $(STATIC)
+all: $(TARGET)
 
 clean:
-	rm -f $(OBJS) $(SHARED) $(STATIC)
+	rm -f $(OBJS) $(TARGET)
 
 debug:
 	$(MAKE) DEBUG=true
@@ -68,8 +62,5 @@ debug:
 moc_%.cpp: %.hpp
 	$(MOC) $< -DMOC_PARSING -o $@
 
-$(SHARED): $(OBJS)
-	$(CXX) $^ -shared $(LINK_FLAGS) -o $@
-
-$(STATIC): $(OBJS)
+$(TARGET): $(OBJS)
 	$(AR) rs $@ $^

source/backend/standalone/CarlaStandalone.cpp

@@ -23,7 +23,10 @@
 #include "CarlaPlugin.hpp"
 #include "CarlaMIDI.h"
 #include "CarlaNative.h"
-#include "CarlaStyle.hpp"
+
+#ifndef BUILD_BRIDGE
+# include "CarlaStyle.hpp"
+#endif
 
 #include <QtCore/QSettings>
 
@@ -48,9 +51,7 @@ struct CarlaBackendStandalone {
     CarlaEngine*  engine;
     CarlaString   lastError;
     CarlaString   procName;
-#ifndef BUILD_BRIDGE
     EngineOptions options;
-#endif
 
     QApplication* app;
     bool needsInit;
@@ -62,6 +63,7 @@ struct CarlaBackendStandalone {
           app(qApp),
           needsInit(app == nullptr)
     {
+#ifndef BUILD_BRIDGE
         if (app != nullptr)
         {
             QSettings settings;
@@ -82,6 +84,7 @@ struct CarlaBackendStandalone {
                     style->setColorScheme(CarlaStyle::COLOR_BLACK);
             }
         }
+#endif
     }
 
     ~CarlaBackendStandalone()

source/backend/standalone/Makefile

@@ -11,9 +11,9 @@ include ../Makefile.mk
 BUILD_CXX_FLAGS += $(shell pkg-config --cflags liblo) -I../../theme
 
 ifeq ($(HAVE_QT5),true)
-BUILD_CXX_FLAGS += $(shell pkg-config --cflags Qt5Core)
+BUILD_CXX_FLAGS += $(shell pkg-config --cflags Qt5Core Qt5Widgets)
 else
-BUILD_CXX_FLAGS += $(shell pkg-config --cflags QtCore)
+BUILD_CXX_FLAGS += $(shell pkg-config --cflags QtCore QtGui)
 endif
 
 # --------------------------------------------------------------
@@ -22,7 +22,7 @@ endif
 LINK_FLAGS += $(shell pkg-config --libs liblo)
 
 ifeq ($(HAVE_QT5),true)
-LINK_FLAGS += $(shell pkg-config --libs Qt5Core Qt5Xml Qt5Widgets)
+LINK_FLAGS += $(shell pkg-config --libs Qt5Core Qt5Gui Qt5Xml Qt5Widgets)
 else
 LINK_FLAGS += $(shell pkg-config --libs QtCore QtGui QtXml)
 endif
@@ -34,16 +34,12 @@ ifeq ($(HAVE_ALSA),true)
 LINK_FLAGS += $(shell pkg-config --libs alsa)
 endif
 
-ifeq ($(HAVE_JACK),true)
-LINK_FLAGS += $(shell pkg-config --libs jack)
-endif
-
 ifeq ($(HAVE_PULSEAUDIO),true)
 LINK_FLAGS += $(shell pkg-config --libs libpulse-simple)
 endif
 
 # --------------------------------------------------------------
-# Plugin
+# Samplers
 
 ifeq ($(HAVE_FLUIDSYNTH),true)
 LINK_FLAGS += $(shell pkg-config --libs fluidsynth)
@@ -106,20 +102,22 @@ endif
 OBJS  = \
      CarlaStandalone.cpp.o
 
-STATIC = ../libcarla_standalone.a
-
 ifeq ($(WIN32),true)
-SHARED = ../libcarla_standalone.dll
+TARGET = ../libcarla_standalone.dll
 else
-SHARED = ../libcarla_standalone.so
+ifeq ($(MACOS),true)
+TARGET = ../libcarla_standalone.dylib
+else
+TARGET = ../libcarla_standalone.so
+endif
 endif
 
 # --------------------------------------------------------------
 
-all: $(SHARED)
+all: $(TARGET)
 
 clean:
-	rm -f $(OBJS) $(SHARED) $(STATIC)
+	rm -f $(OBJS) $(TARGET)
 
 debug:
 	$(MAKE) DEBUG=true
@@ -129,9 +127,6 @@ debug:
 %.cpp.o: %.cpp ../CarlaBackend.hpp ../CarlaEngine.hpp ../CarlaPlugin.hpp
 	$(CXX) $< $(BUILD_CXX_FLAGS) -c -o $@
 
-$(STATIC): $(OBJS) $(LIBS)
-	$(AR) rs $@ $^
-
 ../libcarla_standalone.dll: $(OBJS) $(LIBS)
 	$(CXX) $^ -shared $(LINK_FLAGS) $(W32_LIBS) -Wl,--output-def,$@.def -o $@ && $(STRIP) $@
 

source/bridges/CarlaBridgePlugin.cpp

@@ -298,7 +298,7 @@ public:
         CARLA_ASSERT(fPlugin != nullptr);
 
         if (fPlugin != nullptr)
-            fPlugin->setParameterValueByRIndex(rindex, value, true, true, false);
+            fPlugin->setParameterValueByRealIndex(rindex, value, true, true, false);
     }
 
     void setProgram(const uint32_t index)

source/bridges/Makefile

@@ -30,9 +30,9 @@ LINK_FLAGS      += $(shell pkg-config --libs liblo QtCore)
 # Plugin bridges
 
 BUILD_PLUGIN_FLAGS  = $(BUILD_CXX_FLAGS)
-BUILD_PLUGIN_FLAGS += -DBUILD_BRIDGE_PLUGIN -DBRIDGE_PLUGIN
+BUILD_PLUGIN_FLAGS += -DBUILD_BRIDGE_PLUGIN -DBRIDGE_PLUGIN -DWANT_JACK
 BUILD_PLUGIN_FLAGS += -DWANT_LADSPA -DWANT_DSSI -DWANT_LV2 -DWANT_VST
-BUILD_PLUGIN_FLAGS += -I../backend/engine -I../backend/plugin -I../libs
+BUILD_PLUGIN_FLAGS += -I../backend/engine -I../backend/plugin -I../libs -I../theme
 BUILD_PLUGIN_FLAGS += $(QT_UI_FLAGS) $(shell pkg-config --cflags QtXml)
 
 LINK_PLUGIN_FLAGS   = $(LINK_FLAGS)
@@ -60,7 +60,7 @@ WIN_LINK_FLAGS      = $(LINK_PLUGIN_FLAGS) -mwindows -lwinspool -lole32 -luuid -
 NATIVE_BUILD_FLAGS  = $(POSIX_BUILD_FLAGS)
 NATIVE_LINK_FLAGS   = $(POSIX_LINK_FLAGS)
 
-NATIVE_BUILD_FLAGS += -DWANT_JACK -DWANT_NATIVE
+NATIVE_BUILD_FLAGS += -DWANT_NATIVE
 
 ifeq ($(HAVE_FLUIDSYNTH),true)
 NATIVE_BUILD_FLAGS += -DWANT_FLUIDSYNTH
@@ -302,6 +302,7 @@ OBJS_NATIVE += \
 # carla-plugin
 OBJS_NATIVE += \
 	../backend/plugin/CarlaPlugin__native.o \
+	../backend/plugin/CarlaPluginGui__native.o \
 	../backend/plugin/CarlaPluginThread__native.o \
 	../backend/plugin/NativePlugin__native.o \
 	../backend/plugin/LadspaPlugin__native.o \
@@ -347,6 +348,7 @@ OBJS_POSIX32 += \
 # carla-plugin
 OBJS_POSIX32 += \
 	../backend/plugin/CarlaPlugin__posix32.o \
+	../backend/plugin/CarlaPluginGui__posix32.o \
 	../backend/plugin/CarlaPluginThread__posix32.o \
 	../backend/plugin/NativePlugin__posix32.o \
 	../backend/plugin/LadspaPlugin__posix32.o \
@@ -390,6 +392,7 @@ OBJS_POSIX64 += \
 # carla-plugin
 OBJS_POSIX64 += \
 	../backend/plugin/CarlaPlugin__posix64.o \
+	../backend/plugin/CarlaPluginGui__posix64.o \
 	../backend/plugin/CarlaPluginThread__posix64.o \
 	../backend/plugin/NativePlugin__posix64.o \
 	../backend/plugin/LadspaPlugin__posix64.o \
@@ -427,11 +430,13 @@ OBJS_WIN32 += \
 	../backend/engine/CarlaEngine__win32.o \
 	../backend/engine/CarlaEngineOsc__win32.o \
 	../backend/engine/CarlaEngineThread__win32.o \
-	../backend/engine/CarlaEngineBridge__win32.o
+	../backend/engine/CarlaEngineBridge__win32.o \
+	../backend/engine/CarlaEngineJack__win32.o
 
 # carla-plugin
 OBJS_WIN32 += \
 	../backend/plugin/CarlaPlugin__win32.o \
+	../backend/plugin/CarlaPluginGui__win32.o \
 	../backend/plugin/CarlaPluginThread__win32.o \
 	../backend/plugin/NativePlugin__win32.o \
 	../backend/plugin/LadspaPlugin__win32.o \
@@ -469,11 +474,13 @@ OBJS_WIN64 += \
 	../backend/engine/CarlaEngine__win64.o \
 	../backend/engine/CarlaEngineOsc__win64.o \
 	../backend/engine/CarlaEngineThread__win64.o \
-	../backend/engine/CarlaEngineBridge__win64.o
+	../backend/engine/CarlaEngineBridge__win64.o \
+	../backend/engine/CarlaEngineJack__win64.o
 
 # carla-plugin
 OBJS_WIN64 += \
 	../backend/plugin/CarlaPlugin__win64.o \
+	../backend/plugin/CarlaPluginGui__win64.o \
 	../backend/plugin/CarlaPluginThread__win64.o \
 	../backend/plugin/NativePlugin__win64.o \
 	../backend/plugin/LadspaPlugin__win64.o \

source/libs/jackbridge/JackBridge.cpp

@@ -15,8 +15,17 @@
  */
 
 #include "JackBridge.hpp"
+
+#ifdef __WINE__
+# define __CARLA_UTILS_HPP__
+# undef CARLA_ASSERT
+# define CARLA_ASSERT(...)
+#endif
+
 #include "CarlaLibUtils.hpp"
 
+#include <stdio.h>
+
 #ifndef JACKBRIDGE_DUMMY
 # include <time.h>
 # include <semaphore.h>
@@ -51,10 +60,11 @@ typedef jack_port_t*   (*jacksym_port_register)(jack_client_t*, const char*, con
 typedef int   (*jacksym_port_unregister)(jack_client_t*, jack_port_t*);
 typedef void* (*jacksym_port_get_buffer)(jack_port_t*, jack_nframes_t);
 
-typedef const char* (*jacksym_port_name)(const jack_port_t*);
-typedef const char* (*jacksym_port_short_name)(const jack_port_t*);
-typedef int         (*jacksym_port_flags)(const jack_port_t*);
-typedef const char* (*jacksym_port_type)(const jack_port_t*);
+typedef const char*  (*jacksym_port_name)(const jack_port_t*);
+typedef const char*  (*jacksym_port_short_name)(const jack_port_t*);
+typedef int          (*jacksym_port_flags)(const jack_port_t*);
+typedef const char*  (*jacksym_port_type)(const jack_port_t*);
+typedef const char** (*jacksym_port_get_connections)(const jack_port_t*);
 
 typedef int  (*jacksym_port_set_name)(jack_port_t*, const char*);
 typedef int  (*jacksym_connect)(jack_client_t*, const char*, const char*);
@@ -63,6 +73,11 @@ typedef int  (*jacksym_port_name_size)();
 typedef void (*jacksym_port_get_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);
 typedef void (*jacksym_port_set_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);
 typedef int  (*jacksym_recompute_total_latencies)(jack_client_t*);
+
+typedef const char** (*jacksym_get_ports)(jack_client_t*, const char*, const char*, unsigned long);
+typedef jack_port_t* (*jacksym_port_by_name)(jack_client_t*, const char*);
+typedef jack_port_t* (*jacksym_port_by_id)(jack_client_t*, jack_port_id_t);
+
 typedef void (*jacksym_free)(void*);
 
 typedef uint32_t (*jacksym_midi_get_event_count)(void*);
@@ -78,8 +93,7 @@ typedef jack_transport_state_t (*jacksym_transport_query)(const jack_client_t*,
 
 // -----------------------------------------------------------------------------
 
-struct JackBridge
-{
+struct JackBridge {
     void* lib;
 
     jacksym_get_version_string get_version_string_ptr;
@@ -108,6 +122,7 @@ struct JackBridge
     jacksym_port_short_name port_short_name_ptr;
     jacksym_port_flags port_flags_ptr;
     jacksym_port_type port_type_ptr;
+    jacksym_port_get_connections port_get_connections_ptr;
     jacksym_port_set_name port_set_name_ptr;
     jacksym_connect connect_ptr;
     jacksym_disconnect disconnect_ptr;
@@ -115,6 +130,9 @@ struct JackBridge
     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;
@@ -156,6 +174,7 @@ struct JackBridge
           port_short_name_ptr(nullptr),
           port_flags_ptr(nullptr),
           port_type_ptr(nullptr),
+          port_get_connections_ptr(nullptr),
           port_set_name_ptr(nullptr),
           connect_ptr(nullptr),
           disconnect_ptr(nullptr),
@@ -163,6 +182,9 @@ struct JackBridge
           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),
@@ -176,14 +198,20 @@ struct JackBridge
     {
 #if defined(CARLA_OS_MAC)
         lib = lib_open("libjack.dylib");
-#elif defined(CARLA_OS_WIN)
+        fprintf(stderr, "load JACK DLL FOR MAC\n");
+#elif defined(CARLA_OS_WIN) && ! defined(__WINE__)
         lib = lib_open("libjack.dll");
+        fprintf(stderr, "load JACK DLL FOR WINDOWS\n");
 #else
         lib = lib_open("libjack.so");
+        fprintf(stderr, "load JACK DLL FOR LINUX\n");
 #endif
 
         if (lib == nullptr)
+        {
+            fprintf(stderr, "Failed to load JACK DLL\n");
             return;
+        }
 
         #define JOIN(a, b) a ## b
         #define LIB_SYMBOL(NAME) JOIN(NAME, _ptr) = (jacksym_##NAME)lib_symbol(lib, "jack_" #NAME);
@@ -214,6 +242,7 @@ struct JackBridge
         LIB_SYMBOL(port_short_name)
         LIB_SYMBOL(port_flags)
         LIB_SYMBOL(port_type)
+        LIB_SYMBOL(port_get_connections)
         LIB_SYMBOL(port_set_name)
         LIB_SYMBOL(connect)
         LIB_SYMBOL(disconnect)
@@ -221,6 +250,9 @@ struct JackBridge
         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)
@@ -247,294 +279,318 @@ struct JackBridge
 
 static JackBridge bridge;
 
-int main(){return 0;}
-
 // -----------------------------------------------------------------------------
 
 const char* jackbridge_get_version_string()
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.get_version_string_ptr != nullptr)
         return bridge.get_version_string_ptr();
-#endif
     return nullptr;
 }
 
 jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.client_open_ptr != nullptr)
         return bridge.client_open_ptr(client_name, options, status);
-#endif
     return nullptr;
 }
 
 // -----------------------------------------------------------------------------
 
-int jackbridge_client_close(jack_client_t* client)
+bool jackbridge_client_close(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.client_close_ptr != nullptr)
-        return bridge.client_close_ptr(client);
-#endif
-    return 0;
+        return (bridge.client_close_ptr(client) == 0);
+    return false;
 }
 
 int jackbridge_client_name_size()
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.client_name_size_ptr != nullptr)
         return bridge.client_name_size_ptr();
-#endif
     return 0;
 }
 
 char* jackbridge_get_client_name(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.get_client_name_ptr != nullptr)
         return bridge.get_client_name_ptr(client);
-#endif
     return nullptr;
 }
 
 // -----------------------------------------------------------------------------
 
-int jackbridge_activate(jack_client_t* client)
+bool jackbridge_activate(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.activate_ptr != nullptr)
-        return bridge.activate_ptr(client);
-#endif
-    return 0;
+        return (bridge.activate_ptr(client) == 0);
+    return false;
 }
 
-int jackbridge_deactivate(jack_client_t* client)
+bool jackbridge_deactivate(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.deactivate_ptr != nullptr)
-        return bridge.deactivate_ptr(client);
-#endif
-    return 0;
+        return (bridge.deactivate_ptr(client) == 0);
+    return false;
 }
 
 void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.on_shutdown_ptr != nullptr)
         bridge.on_shutdown_ptr(client, shutdown_callback, arg);
-#endif
 }
 
-int jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)
+bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_process_callback_ptr != nullptr)
-        return bridge.set_process_callback_ptr(client, process_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_process_callback_ptr(client, process_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)
+bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_freewheel_callback_ptr != nullptr)
-        return bridge.set_freewheel_callback_ptr(client, freewheel_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)
+bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_buffer_size_callback_ptr != nullptr)
-        return bridge.set_buffer_size_callback_ptr(client, bufsize_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)
+bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_sample_rate_callback_ptr != nullptr)
-        return bridge.set_sample_rate_callback_ptr(client, srate_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)
+bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_client_registration_callback_ptr != nullptr)
-        return bridge.set_client_registration_callback_ptr(client, registration_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_client_registration_callback_ptr(client, registration_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_port_registration_callback (jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)
+bool jackbridge_set_port_registration_callback (jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_port_registration_callback_ptr != nullptr)
-        return bridge.set_port_registration_callback_ptr(client, registration_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_port_registration_callback_ptr(client, registration_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_port_connect_callback (jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)
+bool jackbridge_set_port_connect_callback (jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_port_connect_callback_ptr != nullptr)
-        return bridge.set_port_connect_callback_ptr(client, connect_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_port_connect_callback_ptr(client, connect_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_port_rename_callback (jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)
+bool jackbridge_set_port_rename_callback (jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_port_rename_callback_ptr != nullptr)
-        return bridge.set_port_rename_callback_ptr(client, rename_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_port_rename_callback_ptr(client, rename_callback, arg) == 0);
+    return false;
 }
 
-int jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)
+bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.set_latency_callback_ptr != nullptr)
-        return bridge.set_latency_callback_ptr(client, latency_callback, arg);
-#endif
-    return 0;
+        return (bridge.set_latency_callback_ptr(client, latency_callback, arg) == 0);
+    return false;
 }
 
 // -----------------------------------------------------------------------------
 
 jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.get_sample_rate_ptr != nullptr)
         return bridge.get_sample_rate_ptr(client);
-#endif
     return 0;
 }
 
 jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.get_buffer_size_ptr != nullptr)
         return bridge.get_buffer_size_ptr(client);
-#endif
     return 0;
 }
 
 jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.port_register_ptr != nullptr)
         return bridge.port_register_ptr(client, port_name, port_type, flags, buffer_size);
-#endif
     return nullptr;
 }
 
-int jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)
+bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.port_unregister_ptr != nullptr)
-        return bridge.port_unregister_ptr(client, port);
-#endif
-    return 0;
+        return (bridge.port_unregister_ptr(client, port) == 0);
+    return false;
 }
 
 void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.port_get_buffer_ptr != nullptr)
         return bridge.port_get_buffer_ptr(port, nframes);
-#endif
     return nullptr;
 }
 
 // -----------------------------------------------------------------------------
 
-// -----------------------------------------------------------------------------
+const char* jackbridge_port_name(const jack_port_t* port)
+{
+    if (bridge.port_name_ptr != nullptr)
+        return bridge.port_name_ptr(port);
+    return nullptr;
+}
 
-int jackbridge_port_name_size()
+const char* jackbridge_port_short_name(const jack_port_t* port)
 {
-#ifndef JACKBRIDGE_DUMMY
-    if (bridge.port_name_size_ptr != nullptr)
-        return bridge.port_name_size_ptr();
-#endif
+    if (bridge.port_short_name_ptr != nullptr)
+        return bridge.port_short_name_ptr(port);
+    return nullptr;
+}
+
+int jackbridge_port_flags(const jack_port_t* port)
+{
+    if (bridge.port_flags_ptr != nullptr)
+        return bridge.port_flags_ptr(port);
     return 0;
 }
 
-int jackbridge_recompute_total_latencies(jack_client_t* client)
+const char* jackbridge_port_type(const jack_port_t* port)
 {
-#ifndef JACKBRIDGE_DUMMY
-    if (bridge.recompute_total_latencies_ptr != nullptr)
-        return bridge.recompute_total_latencies_ptr(client);
-#endif
+    if (bridge.port_type_ptr != nullptr)
+        return bridge.port_type_ptr(port);
+    return nullptr;
+}
+
+const char** jackbridge_port_get_connections(const jack_port_t* port)
+{
+    if (bridge.port_get_connections_ptr != nullptr)
+        return bridge.port_get_connections_ptr(port);
+    return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+bool jackbridge_port_set_name(jack_port_t* port, const char* port_name)
+{
+    if (bridge.port_set_name_ptr != nullptr)
+        return (bridge.port_set_name_ptr(port, port_name) == 0);
+    return false;
+}
+
+bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port)
+{
+    if (bridge.connect_ptr != nullptr)
+        return (bridge.connect_ptr(client, source_port, destination_port) == 0);
+    return false;
+}
+
+bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port)
+{
+    if (bridge.disconnect_ptr != nullptr)
+        return (bridge.disconnect_ptr(client, source_port, destination_port) == 0);
+    return false;
+}
+
+int jackbridge_port_name_size()
+{
+    if (bridge.port_name_size_ptr != nullptr)
+        return bridge.port_name_size_ptr();
     return 0;
 }
 
 void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.port_get_latency_range_ptr != nullptr)
         bridge.port_get_latency_range_ptr(port, mode, range);
-#endif
 }
 
 void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.port_set_latency_range_ptr != nullptr)
         bridge.port_set_latency_range_ptr(port, mode, range);
-#endif
+}
+
+bool jackbridge_recompute_total_latencies(jack_client_t* client)
+{
+    if (bridge.recompute_total_latencies_ptr != nullptr)
+        return (bridge.recompute_total_latencies_ptr(client) == 0);
+    return false;
+}
+
+const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)
+{
+    if (bridge.get_ports_ptr != nullptr)
+        return bridge.get_ports_ptr(client, port_name_pattern, type_name_pattern, flags);
+    return nullptr;
+}
+
+jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name)
+{
+    if (bridge.port_by_name_ptr != nullptr)
+        return bridge.port_by_name_ptr(client, port_name);
+    return nullptr;
+}
+
+jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)
+{
+    if (bridge.port_by_id_ptr != nullptr)
+        return bridge.port_by_id_ptr(client, port_id);
+    return nullptr;
+}
+
+// -----------------------------------------------------------------------------
+
+void jackbridge_free(void* ptr)
+{
+    if (bridge.free_ptr != nullptr)
+        return bridge.free_ptr(ptr);
+
+    // just in case
+    free(ptr);
 }
 
 // -----------------------------------------------------------------------------
 
 uint32_t jackbridge_midi_get_event_count(void* port_buffer)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.midi_get_event_count_ptr != nullptr)
         return bridge.midi_get_event_count_ptr(port_buffer);
-#endif
     return 0;
 }
 
-int jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)
+bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.midi_event_get_ptr != nullptr)
-        return bridge.midi_event_get_ptr(event, port_buffer, event_index);
-#endif
-    return 0;
+        return (bridge.midi_event_get_ptr(event, port_buffer, event_index) == 0);
+    return false;
 }
 
 void jackbridge_midi_clear_buffer(void* port_buffer)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.midi_clear_buffer_ptr != nullptr)
         bridge.midi_clear_buffer_ptr(port_buffer);
-#endif
 }
 
-int jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size)
+bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.midi_event_write_ptr != nullptr)
-        return bridge.midi_event_write_ptr(port_buffer, time, data, data_size);
-#endif
-    return 0;
+        return (bridge.midi_event_write_ptr(port_buffer, time, data, data_size) == 0);
+    return false;
 }
 
 jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.midi_event_reserve_ptr != nullptr)
         return bridge.midi_event_reserve_ptr(port_buffer, time, data_size);
-#endif
     return nullptr;
 }
 
@@ -542,63 +598,68 @@ jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_
 
 int jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.transport_locate_ptr != nullptr)
-        return bridge.transport_locate_ptr(client, frame);
-#endif
-    return 0;
+        return (bridge.transport_locate_ptr(client, frame) == 0);
+    return false;
 }
 
 void jackbridge_transport_start(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.transport_start_ptr != nullptr)
         bridge.transport_start_ptr(client);
-#endif
 }
 
 void jackbridge_transport_stop(jack_client_t* client)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.transport_stop_ptr != nullptr)
         bridge.transport_stop_ptr(client);
-#endif
 }
 
 jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)
 {
-#ifndef JACKBRIDGE_DUMMY
     if (bridge.transport_query_ptr != nullptr)
         return bridge.transport_query_ptr(client, pos);
-#endif
     return JackTransportStopped;
 }
 
 // -----------------------------------------------------------------------------
 
-#if 0
-void linux_clock_gettime_rt(struct timespec* ts)
+#ifdef JACKBRIDGE_DUMMY
+bool jackbridge_sem_post(void* sem)
 {
-#ifndef JACKBRIDGE_DUMMY
-    clock_gettime(CLOCK_REALTIME, ts);
-#endif
+    return false;
 }
 
-int linux_sem_post(void* sem)
+bool jackbridge_sem_timedwait(void* sem, int secs)
 {
-#ifndef JACKBRIDGE_DUMMY
-    return sem_post(sem);
+    return false;
+}
 #else
-    return 1;
-#endif
+bool jackbridge_sem_post(void* sem)
+{
+    return (sem_post((sem_t*)sem) == 0);
 }
 
-int linux_sem_timedwait(void* sem, struct timespec* ts)
+bool jackbridge_sem_timedwait(void* sem, int secs)
 {
-#ifndef JACKBRIDGE_DUMMY
-    return sem_timedwait(sem, ts);
-#else
-    return 1;
-#endif
+# ifdef CARLA_OS_MAC
+        alarm(secs);
+        return (sem_wait((sem_t*)sem) == 0);
+# else
+        timespec timeout;
+
+#  ifdef CARLA_LIB_WINDOWS
+        timeval now;
+        gettimeofday(&now, nullptr);
+        timeout.tv_sec  = now.tv_sec;
+        timeout.tv_nsec = now.tv_usec * 1000;
+#  else
+        clock_gettime(CLOCK_REALTIME, &timeout);
+#  endif
+
+        timeout.tv_sec += secs;
+
+        return (sem_timedwait((sem_t*)sem, &timeout) == 0);
+# endif
 }
 #endif

source/libs/jackbridge/JackBridge.hpp

@@ -19,69 +19,200 @@
 
 #include "CarlaDefines.hpp"
 
+#define PRE_PACKED_STRUCTURE
+#define POST_PACKED_STRUCTURE __attribute__((__packed__))
+
+#define JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"
+#define JACK_DEFAULT_MIDI_TYPE  "8 bit raw midi"
+
 #ifndef JACKBRIDGE_EXPORT
 # undef CARLA_EXPORT
 # define CARLA_EXPORT
 #endif
 
-#ifdef __WINE__
-# define GNU_WIN32 // fix jack threads, always use pthread
-#endif
-
+#include <cstddef>
 #include <cstdint>
-#include <sys/time.h>
 
-#include <jack/jack.h>
-#include <jack/midiport.h>
-#include <jack/transport.h>
+enum JackOptions {
+    JackNullOption    = 0x00,
+    JackNoStartServer = 0x01,
+    JackUseExactName  = 0x02,
+    JackServerName    = 0x04,
+    JackLoadName      = 0x08,
+    JackLoadInit      = 0x10,
+    JackSessionID     = 0x20
+};
+
+enum JackStatus {
+    JackFailure       = 0x01,
+    JackInvalidOption = 0x02,
+    JackNameNotUnique = 0x04,
+    JackServerStarted = 0x08,
+    JackServerFailed  = 0x10,
+    JackServerError   = 0x20,
+    JackNoSuchClient  = 0x40,
+    JackLoadFailure   = 0x80,
+    JackInitFailure   = 0x100,
+    JackShmFailure    = 0x200,
+    JackVersionError  = 0x400,
+    JackBackendError  = 0x800,
+    JackClientZombie  = 0x1000
+};
+
+enum JackLatencyCallbackMode {
+     JackCaptureLatency,
+     JackPlaybackLatency
+};
+
+enum JackPortFlags {
+    JackPortIsInput    = 0x1,
+    JackPortIsOutput   = 0x2,
+    JackPortIsPhysical = 0x4,
+    JackPortCanMonitor = 0x8,
+    JackPortIsTerminal = 0x10,
+};
+
+enum JackTransportFlags {
+    JackTransportStopped     = 0,
+    JackTransportRolling     = 1,
+    JackTransportLooping     = 2,
+    JackTransportStarting    = 3,
+    JackTransportNetStarting = 4
+};
+
+enum JackPositionBits {
+    JackPositionBBT      = 0x010,
+    JackPositionTimecode = 0x020,
+    JackBBTFrameOffset   = 0x040,
+    JackAudioVideoRatio  = 0x080,
+    JackVideoFrameOffset = 0x100
+};
+
+enum JackTransportBits {
+    JackTransportState    = 0x01,
+    JackTransportPosition = 0x02,
+    JackTransportLoop     = 0x04,
+    JackTransportSMPTE    = 0x08,
+    JackTransportBBT      = 0x10
+};
+
+typedef uint32_t jack_nframes_t;
+typedef uint32_t jack_port_id_t;
+typedef uint64_t jack_time_t;
+typedef uint64_t jack_unique_t;
+typedef unsigned char jack_midi_data_t;
+
+typedef enum JackOptions jack_options_t;
+typedef enum JackStatus jack_status_t;
+typedef enum JackLatencyCallbackMode jack_latency_callback_mode_t;
+typedef enum JackTransportFlags jack_transport_state_t;
+typedef enum JackPositionBits jack_position_bits_t;
+typedef enum JackTransportBits jack_transport_bits_t;
+
+struct _jack_midi_event {
+    jack_nframes_t    time;
+    size_t            size;
+    jack_midi_data_t* buffer;
+};
+
+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;
+
+typedef struct _jack_port jack_port_t;
+typedef struct _jack_client jack_client_t;
+typedef struct _jack_latency_range jack_latency_range_t;
+typedef struct _jack_position jack_position_t;
+typedef struct _jack_midi_event jack_midi_event_t;
+
+typedef void (*JackLatencyCallback)(jack_latency_callback_mode_t mode, void *arg);
+typedef int  (*JackProcessCallback)(jack_nframes_t nframes, void *arg);
+typedef int  (*JackBufferSizeCallback)(jack_nframes_t nframes, void *arg);
+typedef int  (*JackSampleRateCallback)(jack_nframes_t nframes, void *arg);
+typedef void (*JackPortRegistrationCallback)(jack_port_id_t port, int register_, void *arg);
+typedef void (*JackClientRegistrationCallback)(const char* name, int register_, void *arg);
+typedef void (*JackPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);
+typedef int  (*JackPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void *arg);
+typedef void (*JackFreewheelCallback)(int starting, void *arg);
+typedef void (*JackShutdownCallback)(void *arg);
 
 CARLA_EXPORT const char*    jackbridge_get_version_string();
 CARLA_EXPORT jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...);
 
-CARLA_EXPORT int   jackbridge_client_close(jack_client_t* client);
+CARLA_EXPORT bool  jackbridge_client_close(jack_client_t* client);
 CARLA_EXPORT int   jackbridge_client_name_size();
 CARLA_EXPORT char* jackbridge_get_client_name(jack_client_t* client);
 
-CARLA_EXPORT int  jackbridge_activate(jack_client_t* client);
-CARLA_EXPORT int  jackbridge_deactivate(jack_client_t* client);
+CARLA_EXPORT bool jackbridge_activate(jack_client_t* client);
+CARLA_EXPORT bool jackbridge_deactivate(jack_client_t* client);
 CARLA_EXPORT void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_port_registration_callback (jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg);
-CARLA_EXPORT int  jackbridge_set_port_connect_callback (jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_port_rename_callback (jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);
-CARLA_EXPORT int  jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_port_registration_callback (jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg);
+CARLA_EXPORT bool jackbridge_set_port_connect_callback (jack_client_t* client, JackPortConnectCallback connect_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_port_rename_callback (jack_client_t* client, JackPortRenameCallback rename_callback, void* arg);
+CARLA_EXPORT bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg);
 
 CARLA_EXPORT jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client);
 CARLA_EXPORT jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client);
 CARLA_EXPORT jack_port_t*   jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
 
-CARLA_EXPORT int   jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);
+CARLA_EXPORT bool  jackbridge_port_unregister(jack_client_t* client, jack_port_t* port);
 CARLA_EXPORT void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes);
 
-//           port_register_ptr(nullptr),
-//           port_unregister_ptr(nullptr),
-//           port_get_buffer_ptr(nullptr),
-//           port_name_ptr(nullptr),
-//           port_short_name_ptr(nullptr),
-//           port_flags_ptr(nullptr),
-//           port_type_ptr(nullptr),
-//           port_set_name_ptr(nullptr),
-//           connect_ptr(nullptr),
-//           disconnect_ptr(nullptr),
+CARLA_EXPORT const char*  jackbridge_port_name(const jack_port_t* port);
+CARLA_EXPORT const char*  jackbridge_port_short_name(const jack_port_t* port);
+CARLA_EXPORT int          jackbridge_port_flags(const jack_port_t* port);
+CARLA_EXPORT const char*  jackbridge_port_type(const jack_port_t* port);
+CARLA_EXPORT const char** jackbridge_port_get_connections(const jack_port_t* port);
 
+CARLA_EXPORT bool jackbridge_port_set_name(jack_port_t* port, const char* port_name);
+CARLA_EXPORT bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port);
+CARLA_EXPORT bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port);
 CARLA_EXPORT int  jackbridge_port_name_size();
 CARLA_EXPORT void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);
 CARLA_EXPORT void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range);
-CARLA_EXPORT int  jackbridge_recompute_total_latencies(jack_client_t* client);
+CARLA_EXPORT bool jackbridge_recompute_total_latencies(jack_client_t* client);
+
+CARLA_EXPORT const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags);
+CARLA_EXPORT jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name);
+CARLA_EXPORT jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id);
+
+CARLA_EXPORT void jackbridge_free(void* ptr);
 
 CARLA_EXPORT uint32_t jackbridge_midi_get_event_count(void* port_buffer);
-CARLA_EXPORT int      jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);
+CARLA_EXPORT bool     jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index);
 CARLA_EXPORT void     jackbridge_midi_clear_buffer(void* port_buffer);
-CARLA_EXPORT int      jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size);
+CARLA_EXPORT bool     jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size);
 CARLA_EXPORT jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size);
 
 CARLA_EXPORT int  jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame);
@@ -89,8 +220,7 @@ CARLA_EXPORT void jackbridge_transport_start(jack_client_t* client);
 CARLA_EXPORT void jackbridge_transport_stop(jack_client_t* client);
 CARLA_EXPORT jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos);
 
-// CARLA_EXPORT void jackbridge_clock_gettime_rt(struct timespec*);
-// CARLA_EXPORT int  jackbridge_sem_post(void*);
-// CARLA_EXPORT int  jackbridge_sem_timedwait(void*, struct timespec*);
+CARLA_EXPORT bool jackbridge_sem_post(void* sem);
+CARLA_EXPORT bool jackbridge_sem_timedwait(void* sem, int secs);
 
 #endif // __JACKBRIDGE_HPP__

source/libs/jackbridge/Makefile

@@ -10,6 +10,7 @@ include ../../Makefile.mk
 
 WINECXX ?= wineg++
 
+BUILD_CXX_FLAGS += -DJACKBRIDGE_EXPORT
 BUILD_CXX_FLAGS += -I. -I../../includes -I../../utils
 
 ifeq ($(MACOS),true)

source/utils/CarlaLibUtils.hpp

@@ -20,7 +20,9 @@
 
 #include "CarlaUtils.hpp"
 
-#ifndef CARLA_OS_WIN
+#if defined(CARLA_OS_WIN) && ! defined(__WINE__)
+# define CARLA_LIB_WINDOWS
+#else
 # include <dlfcn.h>
 #endif
 
@@ -32,7 +34,7 @@ void* lib_open(const char* const filename)
 {
     CARLA_ASSERT(filename != nullptr);
 
-#ifdef CARLA_OS_WIN
+#ifdef CARLA_LIB_WINDOWS
     return (void*)LoadLibraryA(filename);
 #else
     return dlopen(filename, RTLD_NOW|RTLD_LOCAL);
@@ -47,7 +49,7 @@ bool lib_close(void* const lib)
     if (lib == nullptr)
         return false;
 
-#ifdef CARLA_OS_WIN
+#ifdef CARLA_LIB_WINDOWS
     return FreeLibrary((HMODULE)lib);
 #else
     return (dlclose(lib) == 0);
@@ -63,7 +65,7 @@ void* lib_symbol(void* const lib, const char* const symbol)
     if (lib == nullptr && symbol == nullptr)
         return nullptr;
 
-#ifdef CARLA_OS_WIN
+#ifdef CARLA_LIB_WINDOWS
     return (void*)GetProcAddress((HMODULE)lib, symbol);
 #else
     return dlsym(lib, symbol);
@@ -75,7 +77,7 @@ const char* lib_error(const char* const filename)
 {
     CARLA_ASSERT(filename != nullptr);
 
-#ifdef CARLA_OS_WIN
+#ifdef CARLA_LIB_WINDOWS
     static char libError[2048];
     carla_zeroMem(libError, sizeof(char)*2048);