Misc cleanup & fixing

source/backend/CarlaEngine.hpp

@@ -759,7 +759,6 @@ public:
      */
     CarlaPlugin* getPluginUnchecked(const unsigned int id) const;
 
-    // FIXME - this one should not be public
     /*!
      * Get a unique plugin name within the engine.\n
      * Returned variable must NOT be free'd.
@@ -825,7 +824,7 @@ public:
     }
 
     /*!
-     * TODO.
+     * Get the engine proccess mode.
      */
     ProcessMode getProccessMode() const
     {
@@ -858,7 +857,6 @@ public:
     // -------------------------------------------------------------------
     // Callback
 
-    // FIXME - this one should not be public
     /*!
      * TODO.
      */
@@ -913,7 +911,6 @@ public:
      */
     const char* getLastError() const;
 
-    // FIXME - this one should not be public
     /*!
      * Set last error.
      */
@@ -951,7 +948,6 @@ public:
     bool isOscControlRegistered() const;
 #endif
 
-    // FIXME - this one should not be public
     /*!
      * Idle OSC.
      */

source/backend/engine/CarlaEngineBridge.cpp

@@ -28,10 +28,6 @@
 
 #include <ctime>
 
-#ifdef CARLA_OS_WIN
-# include <sys/time.h>
-#endif
-
 CARLA_BACKEND_START_NAMESPACE
 
 #if 0
@@ -163,35 +159,11 @@ public:
     {
         // TODO - set RT permissions
 
-        const int timeout = 5000;
-
         while (! fQuitNow)
         {
-            timespec ts_timeout;
-#ifdef CARLA_OS_WIN
-            timeval now;
-            gettimeofday(&now, nullptr);
-            ts_timeout.tv_sec = now.tv_sec;
-            ts_timeout.tv_nsec = now.tv_usec * 1000;
-#else
-            clock_gettime(CLOCK_REALTIME, &ts_timeout);
-#endif
-
-            time_t seconds = timeout / 1000;
-            ts_timeout.tv_sec += seconds;
-            ts_timeout.tv_nsec += (timeout - seconds * 1000) * 1000000;
-            if (ts_timeout.tv_nsec >= 1000000000) {
-                ts_timeout.tv_nsec -= 1000000000;
-                ts_timeout.tv_sec++;
-            }
-
-            //if (linux_sem_timedwait(&fShmControl.data->runServer, &ts_timeout))
+            if (! jackbridge_sem_timedwait(&fShmControl.data->runServer, 5))
             {
-                if (errno == ETIMEDOUT)
-                {
-                    continue;
-                }
-                else
+                if (errno != ETIMEDOUT)
                 {
                     fQuitNow = true;
                     break;
@@ -200,7 +172,7 @@ public:
 
             while (rdwr_dataAvailable(&fShmControl.data->ringBuffer))
             {
-                const PluginBridgeOpcode opcode = rdwr_readOpcode(&fShmControl.data->ringBuffer);
+                const PluginBridgeOpcode opcode(rdwr_readOpcode(&fShmControl.data->ringBuffer));
 
                 switch (opcode)
                 {
@@ -243,8 +215,8 @@ public:
                 }
             }
 
-            //if (linux_sem_post(&fShmControl.data->runClient) != 0)
-            //    carla_stderr2("Could not post to semaphore");
+            if (jackbridge_sem_post(&fShmControl.data->runClient) != 0)
+                carla_stderr2("Could not post to semaphore");
         }
 
         fIsRunning = false;

source/backend/engine/CarlaEngineJack.cpp

@@ -430,7 +430,7 @@ public:
         carla_debug("CarlaEngineJackClient::isOk()");
 
         if (kUseClient)
-            return bool(kClient);
+            return (kClient != nullptr);
 
         return CarlaEngineClient::isOk();
     }

source/backend/standalone/CarlaStandalone.cpp

@@ -26,10 +26,16 @@
 
 #ifndef BUILD_BRIDGE
 # include "CarlaStyle.hpp"
+# include <QtCore/QSettings>
+#else
+# include <QtCore/Qt>
 #endif
 
-#include <QtCore/QSettings>
-#include <QtCore/QThread>
+#if defined(NDEBUG) && ! defined(BUILD_BRIDGE)
+# WANT_LOGS
+# include <fcntl.h>
+# include <QtCore/QThread>
+#endif
 
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
 # include <QtWidgets/QApplication>
@@ -37,15 +43,13 @@
 # include <QtGui/QApplication>
 #endif
 
-#include <fcntl.h>
-
 using CarlaBackend::CarlaEngine;
 using CarlaBackend::CarlaPlugin;
 using CarlaBackend::CallbackFunc;
 using CarlaBackend::EngineOptions;
 using CarlaBackend::EngineTimeInfo;
 
-#ifdef NDEBUG
+#ifdef WANT_LOGS
 // -------------------------------------------------------------------------------------------------------------------
 // Log thread
 
@@ -170,7 +174,7 @@ struct CarlaBackendStandalone {
     QApplication* app;
     bool needsInit;
 
-#ifdef NDEBUG
+#ifdef WANT_LOGS
     LogThread logThread;
 #endif
 
@@ -209,7 +213,7 @@ struct CarlaBackendStandalone {
     {
         CARLA_ASSERT(engine == nullptr);
 
-#ifdef NDEBUG
+#ifdef WANT_LOGS
         logThread.stop();
 #endif
     }
@@ -221,6 +225,15 @@ struct CarlaBackendStandalone {
         if (app != nullptr)
             return;
 
+        // try again, app might be registered now
+        app = qApp;
+
+        if (app != nullptr)
+        {
+            needsInit = false;
+            return;
+        }
+
         static int    argc = 0;
         static char** argv = nullptr;
         app = new QApplication(argc, argv, true);
@@ -2317,7 +2330,7 @@ bool carla_engine_init_bridge(const char* audioBaseName, const char* controlBase
     standalone.engine->setOption(CarlaBackend::OPTION_PREFER_UI_BRIDGES,     false, nullptr);
 
     // TODO - read from environment
-#ifndef BUILD_BRIDGE
+#if 0
     standalone.engine->setOption(CarlaBackend::OPTION_FORCE_STEREO,          standalone.options.forceStereo ? 1 : 0,             nullptr);
 # ifdef WANT_DSSI
     standalone.engine->setOption(CarlaBackend::OPTION_USE_DSSI_VST_CHUNKS,   standalone.options.useDssiVstChunks ? 1 : 0,        nullptr);
@@ -2325,20 +2338,18 @@ bool carla_engine_init_bridge(const char* audioBaseName, const char* controlBase
     standalone.engine->setOption(CarlaBackend::OPTION_MAX_PARAMETERS,        static_cast<int>(standalone.options.maxParameters),       nullptr);
 #endif
 
-    const bool initiated = standalone.engine->init(clientName);
-
-    if (initiated)
+    if (standalone.engine->init(clientName))
     {
         standalone.lastError = "no error";
         standalone.init();
+        return true;
     }
     else
     {
         standalone.lastError = standalone.engine->getLastError();
         delete standalone.engine;
         standalone.engine = nullptr;
+        return false;
     }
-
-    return initiated;
 }
 #endif

source/bridges/CarlaBridgePlugin.cpp

@@ -15,8 +15,6 @@
  * For a full copy of the GNU General Public License see the GPL.txt file
  */
 
-#ifdef BRIDGE_PLUGIN
-
 #include "CarlaBridgeClient.hpp"
 #include "CarlaBridgeToolkit.hpp"
 
@@ -591,5 +589,3 @@ int main(int argc, char* argv[])
 
     return ret;
 }
-
-#endif // BRIDGE_PLUGIN

source/bridges/qtcreator/carla-bridge-plugin.pro

@@ -60,6 +60,18 @@ PKGCONFIG += fluidsynth
 # LinuxSampler
 PKGCONFIG += linuxsampler
 
+# AudioFile
+PKGCONFIG += libavcodec libavformat libavutil sndfile
+
+# MidiFile
+PKGCONFIG += smf
+
+# OpenGL
+PKGCONFIG += gl
+
+# ZynAddSubFX
+PKGCONFIG += fftw3 mxml zlib ntk ntk_images
+
 # -----------------------------------------------------------
 
 SOURCES = \

source/includes/CarlaDefines.hpp

@@ -19,16 +19,16 @@
 #define __CARLA_DEFINES_HPP__
 
 // Check OS
-#if defined(__APPLE__)
+#if defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
+# define CARLA_OS_WIN64
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+# define CARLA_OS_WIN32
+#elif defined(__APPLE__)
 # define CARLA_OS_MAC
 #elif defined(__HAIKU__)
 # define CARLA_OS_HAIKU
 #elif defined(__linux__) || defined(__linux)
 # define CARLA_OS_LINUX
-#elif defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
-# define CARLA_OS_WIN64
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-# define CARLA_OS_WIN32
 #else
 # warning Unsupported platform!
 #endif

source/libs/jackbridge/JackBridge.cpp

@@ -16,21 +16,25 @@
 
 #include "JackBridge.hpp"
 
-#ifdef __WINE__
-# define __CARLA_UTILS_HPP__
-# undef CARLA_ASSERT
-# define CARLA_ASSERT(...)
-#endif
-
-#include "CarlaLibUtils.hpp"
-
+#include <stdlib.h>
 #include <stdio.h>
 
 #ifndef JACKBRIDGE_DUMMY
-# include <time.h>
 # include <semaphore.h>
+# include <sys/time.h>
+#endif
+
+#ifdef __WINE__
+struct timespec {  // FIXME!
+    __time_t tv_sec;  /* Seconds.  */
+    long int tv_nsec; /* Nanoseconds.  */
+};
 #endif
 
+#ifndef JACKBRIDGE_DIRECT
+
+#include "CarlaLibUtils.hpp"
+
 // -----------------------------------------------------------------------------
 
 typedef const char*    (*jacksym_get_version_string)();
@@ -201,7 +205,7 @@ struct JackBridge {
     {
 #if defined(CARLA_OS_MAC)
         const char* const filename = "libjack.dylib";
-#elif defined(CARLA_OS_WIN) && ! defined(__WINE__)
+#elif defined(CARLA_OS_WIN)
         const char* const filename = "libjack.dll";
 #else
         const char* const filename = "libjack.so.0";
@@ -214,6 +218,10 @@ struct JackBridge {
             fprintf(stderr, "Failed to load JACK DLL, reason:\n%s\n", lib_error(filename));
             return;
         }
+        else
+        {
+            fprintf(stdout, "%s loaded sucessfully!\n", filename);
+        }
 
         #define JOIN(a, b) a ## b
         #define LIB_SYMBOL(NAME) JOIN(NAME, _ptr) = (jacksym_##NAME)lib_symbol(lib, "jack_" #NAME);
@@ -282,354 +290,551 @@ struct JackBridge {
 
 static JackBridge bridge;
 
+#endif // ! JACKBRIDGE_DIRECT
+
 // -----------------------------------------------------------------------------
 
 const char* jackbridge_get_version_string()
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_get_version_string();
+#else
     if (bridge.get_version_string_ptr != nullptr)
         return bridge.get_version_string_ptr();
     return nullptr;
+#endif
 }
 
 jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_client_open(client_name, options, status);
+#else
     if (bridge.client_open_ptr != nullptr)
         return bridge.client_open_ptr(client_name, options, status);
     return nullptr;
+#endif
 }
 
 const char* jackbridge_client_rename(jack_client_t* client, const char* new_name)
 {
+#ifdef JACKBRIDGE_DIRECT
+    //return jack_client_rename(client, new_name);
+    return nullptr;
+    (void)client;
+    (void)new_name;
+#else
     if (bridge.client_rename_ptr != nullptr)
         return bridge.client_rename_ptr(client, new_name);
     return nullptr;
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 bool jackbridge_client_close(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_client_close(client) == 0);
+#else
     if (bridge.client_close_ptr != nullptr)
         return (bridge.client_close_ptr(client) == 0);
     return false;
+#endif
 }
 
 int jackbridge_client_name_size()
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_client_name_size();
+#else
     if (bridge.client_name_size_ptr != nullptr)
         return bridge.client_name_size_ptr();
     return 0;
+#endif
 }
 
 char* jackbridge_get_client_name(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_get_client_name(client);
+#else
     if (bridge.get_client_name_ptr != nullptr)
         return bridge.get_client_name_ptr(client);
     return nullptr;
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 bool jackbridge_activate(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_activate(client) == 0);
+#else
     if (bridge.activate_ptr != nullptr)
         return (bridge.activate_ptr(client) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_deactivate(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_deactivate(client) == 0);
+#else
     if (bridge.deactivate_ptr != nullptr)
         return (bridge.deactivate_ptr(client) == 0);
     return false;
+#endif
 }
 
 void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    jack_on_shutdown(client, shutdown_callback, arg);
+#else
     if (bridge.on_shutdown_ptr != nullptr)
         bridge.on_shutdown_ptr(client, shutdown_callback, arg);
+#endif
 }
 
 bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_process_callback(client, process_callback, arg) == 0);
+#else
     if (bridge.set_process_callback_ptr != nullptr)
         return (bridge.set_process_callback_ptr(client, process_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_freewheel_callback(client, freewheel_callback, arg) == 0);
+#else
     if (bridge.set_freewheel_callback_ptr != nullptr)
         return (bridge.set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_buffer_size_callback(client, bufsize_callback, arg) == 0);
+#else
     if (bridge.set_buffer_size_callback_ptr != nullptr)
         return (bridge.set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_sample_rate_callback(client, srate_callback, arg) == 0);
+#else
     if (bridge.set_sample_rate_callback_ptr != nullptr)
         return (bridge.set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_client_registration_callback(client, registration_callback, arg) == 0);
+#else
     if (bridge.set_client_registration_callback_ptr != nullptr)
         return (bridge.set_client_registration_callback_ptr(client, registration_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_port_registration_callback (jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_port_registration_callback(client, registration_callback, arg) == 0);
+#else
     if (bridge.set_port_registration_callback_ptr != nullptr)
         return (bridge.set_port_registration_callback_ptr(client, registration_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_port_connect_callback (jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_port_connect_callback(client, connect_callback, arg) == 0);
+#else
     if (bridge.set_port_connect_callback_ptr != nullptr)
         return (bridge.set_port_connect_callback_ptr(client, connect_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_port_rename_callback (jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_port_rename_callback(client, rename_callback, arg) == 0);
+#else
     if (bridge.set_port_rename_callback_ptr != nullptr)
         return (bridge.set_port_rename_callback_ptr(client, rename_callback, arg) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_set_latency_callback(client, latency_callback, arg) == 0);
+#else
     if (bridge.set_latency_callback_ptr != nullptr)
         return (bridge.set_latency_callback_ptr(client, latency_callback, arg) == 0);
     return false;
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_get_sample_rate(client);
+#else
     if (bridge.get_sample_rate_ptr != nullptr)
         return bridge.get_sample_rate_ptr(client);
     return 0;
+#endif
 }
 
 jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_get_buffer_size(client);
+#else
     if (bridge.get_buffer_size_ptr != nullptr)
         return bridge.get_buffer_size_ptr(client);
     return 0;
+#endif
 }
 
 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)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_register(client, port_name, port_type, flags, buffer_size);
+#else
     if (bridge.port_register_ptr != nullptr)
         return bridge.port_register_ptr(client, port_name, port_type, flags, buffer_size);
     return nullptr;
+#endif
 }
 
 bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_port_unregister(client, port) == 0);
+#else
     if (bridge.port_unregister_ptr != nullptr)
         return (bridge.port_unregister_ptr(client, port) == 0);
     return false;
+#endif
 }
 
 void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_get_buffer(port, nframes);
+#else
     if (bridge.port_get_buffer_ptr != nullptr)
         return bridge.port_get_buffer_ptr(port, nframes);
     return nullptr;
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 const char* jackbridge_port_name(const jack_port_t* port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_name(port);
+#else
     if (bridge.port_name_ptr != nullptr)
         return bridge.port_name_ptr(port);
     return nullptr;
+#endif
 }
 
 const char* jackbridge_port_short_name(const jack_port_t* port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_short_name(port);
+#else
     if (bridge.port_short_name_ptr != nullptr)
         return bridge.port_short_name_ptr(port);
     return nullptr;
+#endif
 }
 
 int jackbridge_port_flags(const jack_port_t* port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_flags(port);
+#else
     if (bridge.port_flags_ptr != nullptr)
         return bridge.port_flags_ptr(port);
     return 0;
+#endif
 }
 
 const char* jackbridge_port_type(const jack_port_t* port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_type(port);
+#else
     if (bridge.port_type_ptr != nullptr)
         return bridge.port_type_ptr(port);
     return nullptr;
+#endif
 }
 
 const char** jackbridge_port_get_connections(const jack_port_t* port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_get_connections(port);
+#else
     if (bridge.port_get_connections_ptr != nullptr)
         return bridge.port_get_connections_ptr(port);
     return nullptr;
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 bool jackbridge_port_set_name(jack_port_t* port, const char* port_name)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_port_set_name(port, port_name) == 0);
+#else
     if (bridge.port_set_name_ptr != nullptr)
         return (bridge.port_set_name_ptr(port, port_name) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_connect(client, source_port, destination_port) == 0);
+#else
     if (bridge.connect_ptr != nullptr)
         return (bridge.connect_ptr(client, source_port, destination_port) == 0);
     return false;
+#endif
 }
 
 bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_disconnect(client, source_port, destination_port) == 0);
+#else
     if (bridge.disconnect_ptr != nullptr)
         return (bridge.disconnect_ptr(client, source_port, destination_port) == 0);
     return false;
+#endif
 }
 
 int jackbridge_port_name_size()
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_name_size();
+#else
     if (bridge.port_name_size_ptr != nullptr)
         return bridge.port_name_size_ptr();
     return 0;
+#endif
 }
 
 void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_get_latency_range(port, mode, range);
+#else
     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)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_set_latency_range(port, mode, range);
+#else
     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)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_recompute_total_latencies(client) == 0);
+#else
     if (bridge.recompute_total_latencies_ptr != nullptr)
         return (bridge.recompute_total_latencies_ptr(client) == 0);
     return false;
+#endif
 }
 
 const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_get_ports(client, port_name_pattern, type_name_pattern, flags);
+#else
     if (bridge.get_ports_ptr != nullptr)
         return bridge.get_ports_ptr(client, port_name_pattern, type_name_pattern, flags);
     return nullptr;
+#endif
 }
 
 jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_by_name(client, port_name);
+#else
     if (bridge.port_by_name_ptr != nullptr)
         return bridge.port_by_name_ptr(client, port_name);
     return nullptr;
+#endif
 }
 
 jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_port_by_id(client, port_id);
+#else
     if (bridge.port_by_id_ptr != nullptr)
         return bridge.port_by_id_ptr(client, port_id);
     return nullptr;
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 void jackbridge_free(void* ptr)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_free(ptr);
+#else
     if (bridge.free_ptr != nullptr)
         return bridge.free_ptr(ptr);
 
     // just in case
     free(ptr);
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 uint32_t jackbridge_midi_get_event_count(void* port_buffer)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_midi_get_event_count(port_buffer);
+#else
     if (bridge.midi_get_event_count_ptr != nullptr)
         return bridge.midi_get_event_count_ptr(port_buffer);
     return 0;
+#endif
 }
 
 bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_midi_event_get(event, port_buffer, event_index) == 0);
+#else
     if (bridge.midi_event_get_ptr != nullptr)
         return (bridge.midi_event_get_ptr(event, port_buffer, event_index) == 0);
     return false;
+#endif
 }
 
 void jackbridge_midi_clear_buffer(void* port_buffer)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_midi_clear_buffer(port_buffer);
+#else
     if (bridge.midi_clear_buffer_ptr != nullptr)
         bridge.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, size_t data_size)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_midi_event_write(port_buffer, time, data, data_size) == 0);
+#else
     if (bridge.midi_event_write_ptr != nullptr)
         return (bridge.midi_event_write_ptr(port_buffer, time, data, data_size) == 0);
     return false;
+#endif
 }
 
 jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_midi_event_reserve(port_buffer, time, data_size);
+#else
     if (bridge.midi_event_reserve_ptr != nullptr)
         return bridge.midi_event_reserve_ptr(port_buffer, time, data_size);
     return nullptr;
+#endif
 }
 
 // -----------------------------------------------------------------------------
 
 int jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return (jack_transport_locate(client, frame) == 0);
+#else
     if (bridge.transport_locate_ptr != nullptr)
         return (bridge.transport_locate_ptr(client, frame) == 0);
     return false;
+#endif
 }
 
 void jackbridge_transport_start(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    jack_transport_start(client);
+#else
     if (bridge.transport_start_ptr != nullptr)
         bridge.transport_start_ptr(client);
+#endif
 }
 
 void jackbridge_transport_stop(jack_client_t* client)
 {
+#ifdef JACKBRIDGE_DIRECT
+    jack_transport_stop(client);
+#else
     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)
 {
+#ifdef JACKBRIDGE_DIRECT
+    return jack_transport_query(client, pos);
+#else
     if (bridge.transport_query_ptr != nullptr)
         return bridge.transport_query_ptr(client, pos);
     return JackTransportStopped;
+#endif
 }
 
 // -----------------------------------------------------------------------------
@@ -658,7 +863,7 @@ bool jackbridge_sem_timedwait(void* sem, int secs)
 # else
         timespec timeout;
 
-#  ifdef CARLA_LIB_WINDOWS
+#  ifdef CARLA_OS_WIN
         timeval now;
         gettimeofday(&now, nullptr);
         timeout.tv_sec  = now.tv_sec;

source/libs/jackbridge/JackBridge.hpp

@@ -19,17 +19,23 @@
 
 #include "CarlaDefines.hpp"
 
+#ifndef JACKBRIDGE_EXPORT
+# undef CARLA_EXPORT
+# define CARLA_EXPORT
+#endif
+
+#ifdef JACKBRIDGE_DIRECT
+# include <jack/jack.h>
+# include <jack/midiport.h>
+# include <jack/transport.h>
+#else
+
 #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
-
 #include <cstddef>
 #include <cstdint>
 
@@ -162,6 +168,8 @@ typedef int  (*JackPortRenameCallback)(jack_port_id_t port, const char* old_name
 typedef void (*JackFreewheelCallback)(int starting, void *arg);
 typedef void (*JackShutdownCallback)(void *arg);
 
+#endif // ! JACKBRIDGE_DIRECT
+
 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 const char*    jackbridge_client_rename(jack_client_t* client, const char* new_name);

source/libs/jackbridge/Makefile

@@ -24,10 +24,10 @@ WIN_32BIT_FLAGS  = $(32BIT_FLAGS)
 WIN_64BIT_FLAGS  = $(64BIT_FLAGS)
 WIN_LINK_FLAGS   = $(LINK_FLAGS)
 
-WINE_BUILD_FLAGS = $(BUILD_CXX_FLAGS) -fPIC
+WINE_BUILD_FLAGS = $(BUILD_CXX_FLAGS) -DJACKBRIDGE_DIRECT -fPIC
 WINE_32BIT_FLAGS = $(32BIT_FLAGS) -L/usr/lib32/wine -L/usr/lib/i386-linux-gnu/wine
 WINE_64BIT_FLAGS = $(64BIT_FLAGS) -L/usr/lib64/wine -L/usr/lib/x86_64-linux-gnu/wine
-WINE_LINK_FLAGS  = $(LINK_FLAGS) -ldl -lrt -lpthread
+WINE_LINK_FLAGS  = $(LINK_FLAGS) -ldl -lrt -lpthread -ljack
 
 OBJS = JackBridge.cpp
 

source/utils/CarlaLibUtils.hpp

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