source/jackbridge/JackBridge1.cpp

   1 /*
   2  * JackBridge (Part 1, JACK functions)
   3  * Copyright (C) 2013-2022 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any purpose with
   6  * or without fee is hereby granted, provided that the above copyright notice and this
   7  * permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
  10  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
  11  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  13  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "JackBridge.hpp"
  18
  19 #if ! (defined(JACKBRIDGE_DIRECT) || defined(JACKBRIDGE_DUMMY))
  20
  21 #ifdef __WINE__
  22 # include <windows.h>
  23 # include <pthread.h>
  24 #endif
  25
  26 #if defined(CARLA_OS_WIN) && ! defined(__WINE__)
  27 # define JACKSYM_API __cdecl
  28 #else
  29 # define JACKSYM_API
  30 #endif
  31
  32 #include <cerrno>
  33 #include "CarlaLibUtils.hpp"
  34
  35 // -----------------------------------------------------------------------------
  36
  37 extern "C" {
  38
  39 typedef void (JACKSYM_API *JackSymLatencyCallback)(jack_latency_callback_mode_t, void*);
  40 typedef int  (JACKSYM_API *JackSymProcessCallback)(jack_nframes_t, void*);
  41 typedef void (JACKSYM_API *JackSymThreadInitCallback)(void*);
  42 typedef int  (JACKSYM_API *JackSymGraphOrderCallback)(void*);
  43 typedef int  (JACKSYM_API *JackSymXRunCallback)(void*);
  44 typedef int  (JACKSYM_API *JackSymBufferSizeCallback)(jack_nframes_t, void*);
  45 typedef int  (JACKSYM_API *JackSymSampleRateCallback)(jack_nframes_t, void*);
  46 typedef void (JACKSYM_API *JackSymPortRegistrationCallback)(jack_port_id_t, int, void*);
  47 typedef void (JACKSYM_API *JackSymClientRegistrationCallback)(const char*, int, void*);
  48 typedef void (JACKSYM_API *JackSymPortConnectCallback)(jack_port_id_t, jack_port_id_t, int, void*);
  49 typedef void (JACKSYM_API *JackSymPortRenameCallback)(jack_port_id_t, const char*, const char*, void*);
  50 typedef void (JACKSYM_API *JackSymFreewheelCallback)(int, void*);
  51 typedef void (JACKSYM_API *JackSymShutdownCallback)(void*);
  52 typedef void (JACKSYM_API *JackSymInfoShutdownCallback)(jack_status_t, const char*, void*);
  53 typedef int  (JACKSYM_API *JackSymSyncCallback)(jack_transport_state_t, jack_position_t*, void*);
  54 typedef void (JACKSYM_API *JackSymTimebaseCallback)(jack_transport_state_t, jack_nframes_t, jack_position_t*, int, void*);
  55 typedef void (JACKSYM_API *JackSymSessionCallback)(jack_session_event_t*, void*);
  56 typedef void (JACKSYM_API *JackSymPropertyChangeCallback)(jack_uuid_t, const char*, jack_property_change_t, void*);
  57
  58 typedef void        (JACKSYM_API *jacksym_get_version)(int*, int*, int*, int*);
  59 typedef const char* (JACKSYM_API *jacksym_get_version_string)(void);
  60
  61 typedef jack_client_t* (JACKSYM_API *jacksym_client_open)(const char*, jack_options_t, jack_status_t*, ...);
  62 typedef int            (JACKSYM_API *jacksym_client_close)(jack_client_t*);
  63
  64 typedef int   (JACKSYM_API *jacksym_client_name_size)(void);
  65 typedef char* (JACKSYM_API *jacksym_get_client_name)(jack_client_t*);
  66
  67 typedef char* (JACKSYM_API *jacksym_client_get_uuid)(jack_client_t*);
  68 typedef char* (JACKSYM_API *jacksym_get_uuid_for_client_name)(jack_client_t*, const char*);
  69 typedef char* (JACKSYM_API *jacksym_get_client_name_by_uuid)(jack_client_t*, const char*);
  70
  71 typedef int  (JACKBRIDGE_API *jacksym_uuid_parse)(const char*, jack_uuid_t*);
  72 typedef void (JACKBRIDGE_API *jacksym_uuid_unparse)(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);
  73
  74 typedef int (JACKSYM_API *jacksym_activate)(jack_client_t*);
  75 typedef int (JACKSYM_API *jacksym_deactivate)(jack_client_t*);
  76 typedef int (JACKSYM_API *jacksym_is_realtime)(jack_client_t*);
  77
  78 typedef int  (JACKSYM_API *jacksym_set_thread_init_callback)(jack_client_t*, JackSymThreadInitCallback, void*);
  79 typedef void (JACKSYM_API *jacksym_on_shutdown)(jack_client_t*, JackSymShutdownCallback, void*);
  80 typedef void (JACKSYM_API *jacksym_on_info_shutdown)(jack_client_t*, JackSymInfoShutdownCallback, void*);
  81 typedef int  (JACKSYM_API *jacksym_set_process_callback)(jack_client_t*, JackSymProcessCallback, void*);
  82 typedef int  (JACKSYM_API *jacksym_set_freewheel_callback)(jack_client_t*, JackSymFreewheelCallback, void*);
  83 typedef int  (JACKSYM_API *jacksym_set_buffer_size_callback)(jack_client_t*, JackSymBufferSizeCallback, void*);
  84 typedef int  (JACKSYM_API *jacksym_set_sample_rate_callback)(jack_client_t*, JackSymSampleRateCallback, void*);
  85 typedef int  (JACKSYM_API *jacksym_set_client_registration_callback)(jack_client_t*, JackSymClientRegistrationCallback, void*);
  86 typedef int  (JACKSYM_API *jacksym_set_port_registration_callback)(jack_client_t*, JackSymPortRegistrationCallback, void*);
  87 typedef int  (JACKSYM_API *jacksym_set_port_rename_callback)(jack_client_t*, JackSymPortRenameCallback, void*);
  88 typedef int  (JACKSYM_API *jacksym_set_port_connect_callback)(jack_client_t*, JackSymPortConnectCallback, void*);
  89 typedef int  (JACKSYM_API *jacksym_set_graph_order_callback)(jack_client_t*, JackSymGraphOrderCallback, void*);
  90 typedef int  (JACKSYM_API *jacksym_set_xrun_callback)(jack_client_t*, JackSymXRunCallback, void*);
  91 typedef int  (JACKSYM_API *jacksym_set_latency_callback)(jack_client_t*, JackSymLatencyCallback, void*);
  92
  93 typedef int (JACKSYM_API *jacksym_set_freewheel)(jack_client_t*, int);
  94 typedef int (JACKSYM_API *jacksym_set_buffer_size)(jack_client_t*, jack_nframes_t);
  95
  96 typedef jack_nframes_t (JACKSYM_API *jacksym_get_sample_rate)(jack_client_t*);
  97 typedef jack_nframes_t (JACKSYM_API *jacksym_get_buffer_size)(jack_client_t*);
  98 typedef float          (JACKSYM_API *jacksym_cpu_load)(jack_client_t*);
  99
 100 typedef jack_port_t* (JACKSYM_API *jacksym_port_register)(jack_client_t*, const char*, const char*, ulong, ulong);
 101 typedef int          (JACKSYM_API *jacksym_port_unregister)(jack_client_t*, jack_port_t*);
 102 typedef void*        (JACKSYM_API *jacksym_port_get_buffer)(jack_port_t*, jack_nframes_t);
 103
 104 typedef const char*  (JACKSYM_API *jacksym_port_name)(const jack_port_t*);
 105 typedef jack_uuid_t  (JACKSYM_API *jacksym_port_uuid)(const jack_port_t*);
 106 typedef const char*  (JACKSYM_API *jacksym_port_short_name)(const jack_port_t*);
 107 typedef int          (JACKSYM_API *jacksym_port_flags)(const jack_port_t*);
 108 typedef const char*  (JACKSYM_API *jacksym_port_type)(const jack_port_t*);
 109 typedef int          (JACKSYM_API *jacksym_port_is_mine)(const jack_client_t*, const jack_port_t*);
 110 typedef int          (JACKSYM_API *jacksym_port_connected)(const jack_port_t*);
 111 typedef int          (JACKSYM_API *jacksym_port_connected_to)(const jack_port_t*, const char*);
 112 typedef const char** (JACKSYM_API *jacksym_port_get_connections)(const jack_port_t*);
 113 typedef const char** (JACKSYM_API *jacksym_port_get_all_connections)(const jack_client_t*, const jack_port_t*);
 114
 115 typedef int (JACKSYM_API *jacksym_port_rename)(jack_client_t*, jack_port_t*, const char*);
 116 typedef int (JACKSYM_API *jacksym_port_set_name)(jack_port_t*, const char*);
 117 typedef int (JACKSYM_API *jacksym_port_set_alias)(jack_port_t*, const char*);
 118 typedef int (JACKSYM_API *jacksym_port_unset_alias)(jack_port_t*, const char*);
 119 typedef int (JACKSYM_API *jacksym_port_get_aliases)(const jack_port_t*, char* const aliases[2]);
 120
 121 typedef int (JACKSYM_API *jacksym_port_request_monitor)(jack_port_t*, int);
 122 typedef int (JACKSYM_API *jacksym_port_request_monitor_by_name)(jack_client_t*, const char*, int);
 123 typedef int (JACKSYM_API *jacksym_port_ensure_monitor)(jack_port_t*, int);
 124 typedef int (JACKSYM_API *jacksym_port_monitoring_input)(jack_port_t*);
 125
 126 typedef int (JACKSYM_API *jacksym_connect)(jack_client_t*, const char*, const char*);
 127 typedef int (JACKSYM_API *jacksym_disconnect)(jack_client_t*, const char*, const char*);
 128 typedef int (JACKSYM_API *jacksym_port_disconnect)(jack_client_t*, jack_port_t*);
 129
 130 typedef int    (JACKSYM_API *jacksym_port_name_size)(void);
 131 typedef int    (JACKSYM_API *jacksym_port_type_size)(void);
 132 typedef size_t (JACKSYM_API *jacksym_port_type_get_buffer_size)(jack_client_t*, const char*);
 133
 134 typedef void (JACKSYM_API *jacksym_port_get_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);
 135 typedef void (JACKSYM_API *jacksym_port_set_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);
 136 typedef int  (JACKSYM_API *jacksym_recompute_total_latencies)(jack_client_t*);
 137
 138 typedef const char** (JACKSYM_API *jacksym_get_ports)(jack_client_t*, const char*, const char*, ulong);
 139 typedef jack_port_t* (JACKSYM_API *jacksym_port_by_name)(jack_client_t*, const char*);
 140 typedef jack_port_t* (JACKSYM_API *jacksym_port_by_id)(jack_client_t*, jack_port_id_t);
 141
 142 typedef void (JACKSYM_API *jacksym_free)(void*);
 143
 144 typedef uint32_t (JACKSYM_API *jacksym_midi_get_event_count)(void*);
 145 typedef int      (JACKSYM_API *jacksym_midi_event_get)(jack_midi_event_t*, void*, uint32_t);
 146 typedef void     (JACKSYM_API *jacksym_midi_clear_buffer)(void*);
 147 typedef int      (JACKSYM_API *jacksym_midi_event_write)(void*, jack_nframes_t, const jack_midi_data_t*, size_t);
 148 typedef jack_midi_data_t* (JACKSYM_API *jacksym_midi_event_reserve)(void*, jack_nframes_t, size_t);
 149
 150 typedef int (JACKSYM_API *jacksym_release_timebase)(jack_client_t*);
 151 typedef int (JACKSYM_API *jacksym_set_sync_callback)(jack_client_t*, JackSymSyncCallback, void*);
 152 typedef int (JACKSYM_API *jacksym_set_sync_timeout)(jack_client_t*, jack_time_t);
 153 typedef int (JACKSYM_API *jacksym_set_timebase_callback)(jack_client_t*, int, JackSymTimebaseCallback, void*);
 154 typedef int (JACKSYM_API *jacksym_transport_locate)(jack_client_t*, jack_nframes_t);
 155
 156 typedef jack_transport_state_t (JACKSYM_API *jacksym_transport_query)(const jack_client_t*, jack_position_t*);
 157 typedef jack_nframes_t         (JACKSYM_API *jacksym_get_current_transport_frame)(const jack_client_t*);
 158
 159 typedef int  (JACKSYM_API *jacksym_transport_reposition)(jack_client_t*, const jack_position_t*);
 160 typedef void (JACKSYM_API *jacksym_transport_start)(jack_client_t*);
 161 typedef void (JACKSYM_API *jacksym_transport_stop)(jack_client_t*);
 162
 163 typedef int  (JACKSYM_API *jacksym_set_property)(jack_client_t*, jack_uuid_t, const char*, const char*, const char*);
 164 typedef int  (JACKSYM_API *jacksym_get_property)(jack_uuid_t, const char*, char**, char**);
 165 typedef void (JACKSYM_API *jacksym_free_description)(jack_description_t*, int);
 166 typedef int  (JACKSYM_API *jacksym_get_properties)(jack_uuid_t, jack_description_t*);
 167 typedef int  (JACKSYM_API *jacksym_get_all_properties)(jack_description_t**);
 168 typedef int  (JACKSYM_API *jacksym_remove_property)(jack_client_t*, jack_uuid_t, const char*);
 169 typedef int  (JACKSYM_API *jacksym_remove_properties)(jack_client_t*, jack_uuid_t);
 170 typedef int  (JACKSYM_API *jacksym_remove_all_properties)(jack_client_t*);
 171 typedef int  (JACKSYM_API *jacksym_set_property_change_callback)(jack_client_t*, JackSymPropertyChangeCallback, void*);
 172
 173 #ifdef __WINE__
 174 typedef int  (JACKSYM_API *jacksym_thread_creator_t)(pthread_t*, const pthread_attr_t*, void *(*)(void*), void*);
 175 typedef void (JACKSYM_API *jacksym_set_thread_creator)(jacksym_thread_creator_t);
 176 #endif
 177
 178 } // extern "C"
 179
 180 // -----------------------------------------------------------------------------
 181
 182 struct JackBridge {
 183     lib_t lib;
 184
 185     jacksym_get_version get_version_ptr;
 186     jacksym_get_version_string get_version_string_ptr;
 187
 188     jacksym_client_open client_open_ptr;
 189     jacksym_client_close client_close_ptr;
 190
 191     jacksym_client_name_size client_name_size_ptr;
 192     jacksym_get_client_name get_client_name_ptr;
 193
 194     jacksym_client_get_uuid client_get_uuid_ptr;
 195     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;
 196     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;
 197
 198     jacksym_uuid_parse uuid_parse_ptr;
 199     jacksym_uuid_unparse uuid_unparse_ptr;
 200
 201     jacksym_activate activate_ptr;
 202     jacksym_deactivate deactivate_ptr;
 203     jacksym_is_realtime is_realtime_ptr;
 204
 205     jacksym_set_thread_init_callback set_thread_init_callback_ptr;
 206     jacksym_on_shutdown on_shutdown_ptr;
 207     jacksym_on_info_shutdown on_info_shutdown_ptr;
 208     jacksym_set_process_callback set_process_callback_ptr;
 209     jacksym_set_freewheel_callback set_freewheel_callback_ptr;
 210     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;
 211     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;
 212     jacksym_set_client_registration_callback set_client_registration_callback_ptr;
 213     jacksym_set_port_registration_callback set_port_registration_callback_ptr;
 214     jacksym_set_port_rename_callback set_port_rename_callback_ptr;
 215     jacksym_set_port_connect_callback set_port_connect_callback_ptr;
 216     jacksym_set_graph_order_callback set_graph_order_callback_ptr;
 217     jacksym_set_xrun_callback set_xrun_callback_ptr;
 218     jacksym_set_latency_callback set_latency_callback_ptr;
 219
 220     jacksym_set_freewheel set_freewheel_ptr;
 221     jacksym_set_buffer_size set_buffer_size_ptr;
 222
 223     jacksym_get_sample_rate get_sample_rate_ptr;
 224     jacksym_get_buffer_size get_buffer_size_ptr;
 225     jacksym_cpu_load cpu_load_ptr;
 226
 227     jacksym_port_register port_register_ptr;
 228     jacksym_port_unregister port_unregister_ptr;
 229     jacksym_port_get_buffer port_get_buffer_ptr;
 230
 231     jacksym_port_name port_name_ptr;
 232     jacksym_port_uuid port_uuid_ptr;
 233     jacksym_port_short_name port_short_name_ptr;
 234     jacksym_port_flags port_flags_ptr;
 235     jacksym_port_type port_type_ptr;
 236     jacksym_port_is_mine port_is_mine_ptr;
 237     jacksym_port_connected port_connected_ptr;
 238     jacksym_port_connected_to port_connected_to_ptr;
 239     jacksym_port_get_connections port_get_connections_ptr;
 240     jacksym_port_get_all_connections port_get_all_connections_ptr;
 241
 242     jacksym_port_rename port_rename_ptr;
 243     jacksym_port_set_name port_set_name_ptr;
 244     jacksym_port_set_alias port_set_alias_ptr;
 245     jacksym_port_unset_alias port_unset_alias_ptr;
 246     jacksym_port_get_aliases port_get_aliases_ptr;
 247
 248     jacksym_port_request_monitor port_request_monitor_ptr;
 249     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;
 250     jacksym_port_ensure_monitor port_ensure_monitor_ptr;
 251     jacksym_port_monitoring_input port_monitoring_input_ptr;
 252
 253     jacksym_connect connect_ptr;
 254     jacksym_disconnect disconnect_ptr;
 255     jacksym_port_disconnect port_disconnect_ptr;
 256
 257     jacksym_port_name_size port_name_size_ptr;
 258     jacksym_port_type_size port_type_size_ptr;
 259     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;
 260
 261     jacksym_port_get_latency_range port_get_latency_range_ptr;
 262     jacksym_port_set_latency_range port_set_latency_range_ptr;
 263     jacksym_recompute_total_latencies recompute_total_latencies_ptr;
 264
 265     jacksym_get_ports get_ports_ptr;
 266     jacksym_port_by_name port_by_name_ptr;
 267     jacksym_port_by_id port_by_id_ptr;
 268
 269     jacksym_free free_ptr;
 270
 271     jacksym_midi_get_event_count midi_get_event_count_ptr;
 272     jacksym_midi_event_get midi_event_get_ptr;
 273     jacksym_midi_clear_buffer midi_clear_buffer_ptr;
 274     jacksym_midi_event_write midi_event_write_ptr;
 275     jacksym_midi_event_reserve midi_event_reserve_ptr;
 276
 277     jacksym_release_timebase release_timebase_ptr;
 278     jacksym_set_sync_callback set_sync_callback_ptr;
 279     jacksym_set_sync_timeout set_sync_timeout_ptr;
 280     jacksym_set_timebase_callback set_timebase_callback_ptr;
 281     jacksym_transport_locate transport_locate_ptr;
 282
 283     jacksym_transport_query transport_query_ptr;
 284     jacksym_get_current_transport_frame get_current_transport_frame_ptr;
 285
 286     jacksym_transport_reposition transport_reposition_ptr;
 287     jacksym_transport_start transport_start_ptr;
 288     jacksym_transport_stop transport_stop_ptr;
 289
 290     jacksym_set_property set_property_ptr;
 291     jacksym_get_property get_property_ptr;
 292     jacksym_free_description free_description_ptr;
 293     jacksym_get_properties get_properties_ptr;
 294     jacksym_get_all_properties get_all_properties_ptr;
 295     jacksym_remove_property remove_property_ptr;
 296     jacksym_remove_properties remove_properties_ptr;
 297     jacksym_remove_all_properties remove_all_properties_ptr;
 298     jacksym_set_property_change_callback set_property_change_callback_ptr;
 299
 300 #ifdef __WINE__
 301     jacksym_set_thread_creator set_thread_creator_ptr;
 302 #endif
 303
 304     JackBridge()
 305         : lib(nullptr),
 306           get_version_ptr(nullptr),
 307           get_version_string_ptr(nullptr),
 308           client_open_ptr(nullptr),
 309           client_close_ptr(nullptr),
 310           client_name_size_ptr(nullptr),
 311           get_client_name_ptr(nullptr),
 312           client_get_uuid_ptr(nullptr),
 313           get_uuid_for_client_name_ptr(nullptr),
 314           get_client_name_by_uuid_ptr(nullptr),
 315           uuid_parse_ptr(nullptr),
 316           uuid_unparse_ptr(nullptr),
 317           activate_ptr(nullptr),
 318           deactivate_ptr(nullptr),
 319           is_realtime_ptr(nullptr),
 320           set_thread_init_callback_ptr(nullptr),
 321           on_shutdown_ptr(nullptr),
 322           on_info_shutdown_ptr(nullptr),
 323           set_process_callback_ptr(nullptr),
 324           set_freewheel_callback_ptr(nullptr),
 325           set_buffer_size_callback_ptr(nullptr),
 326           set_sample_rate_callback_ptr(nullptr),
 327           set_client_registration_callback_ptr(nullptr),
 328           set_port_registration_callback_ptr(nullptr),
 329           set_port_rename_callback_ptr(nullptr),
 330           set_port_connect_callback_ptr(nullptr),
 331           set_graph_order_callback_ptr(nullptr),
 332           set_xrun_callback_ptr(nullptr),
 333           set_latency_callback_ptr(nullptr),
 334           set_freewheel_ptr(nullptr),
 335           set_buffer_size_ptr(nullptr),
 336           get_sample_rate_ptr(nullptr),
 337           get_buffer_size_ptr(nullptr),
 338           cpu_load_ptr(nullptr),
 339           port_register_ptr(nullptr),
 340           port_unregister_ptr(nullptr),
 341           port_get_buffer_ptr(nullptr),
 342           port_name_ptr(nullptr),
 343           port_uuid_ptr(nullptr),
 344           port_short_name_ptr(nullptr),
 345           port_flags_ptr(nullptr),
 346           port_type_ptr(nullptr),
 347           port_is_mine_ptr(nullptr),
 348           port_connected_ptr(nullptr),
 349           port_connected_to_ptr(nullptr),
 350           port_get_connections_ptr(nullptr),
 351           port_get_all_connections_ptr(nullptr),
 352           port_rename_ptr(nullptr),
 353           port_set_name_ptr(nullptr),
 354           port_set_alias_ptr(nullptr),
 355           port_unset_alias_ptr(nullptr),
 356           port_get_aliases_ptr(nullptr),
 357           port_request_monitor_ptr(nullptr),
 358           port_request_monitor_by_name_ptr(nullptr),
 359           port_ensure_monitor_ptr(nullptr),
 360           port_monitoring_input_ptr(nullptr),
 361           connect_ptr(nullptr),
 362           disconnect_ptr(nullptr),
 363           port_disconnect_ptr(nullptr),
 364           port_name_size_ptr(nullptr),
 365           port_type_size_ptr(nullptr),
 366           port_type_get_buffer_size_ptr(nullptr),
 367           port_get_latency_range_ptr(nullptr),
 368           port_set_latency_range_ptr(nullptr),
 369           recompute_total_latencies_ptr(nullptr),
 370           get_ports_ptr(nullptr),
 371           port_by_name_ptr(nullptr),
 372           port_by_id_ptr(nullptr),
 373           free_ptr(nullptr),
 374           midi_get_event_count_ptr(nullptr),
 375           midi_event_get_ptr(nullptr),
 376           midi_clear_buffer_ptr(nullptr),
 377           midi_event_write_ptr(nullptr),
 378           midi_event_reserve_ptr(nullptr),
 379           release_timebase_ptr(nullptr),
 380           set_sync_callback_ptr(nullptr),
 381           set_sync_timeout_ptr(nullptr),
 382           set_timebase_callback_ptr(nullptr),
 383           transport_locate_ptr(nullptr),
 384           transport_query_ptr(nullptr),
 385           get_current_transport_frame_ptr(nullptr),
 386           transport_reposition_ptr(nullptr),
 387           transport_start_ptr(nullptr),
 388           transport_stop_ptr(nullptr),
 389           set_property_ptr(nullptr),
 390           get_property_ptr(nullptr),
 391           free_description_ptr(nullptr),
 392           get_properties_ptr(nullptr),
 393           get_all_properties_ptr(nullptr),
 394           remove_property_ptr(nullptr),
 395           remove_properties_ptr(nullptr),
 396           remove_all_properties_ptr(nullptr),
 397           set_property_change_callback_ptr(nullptr)
 398 #ifdef __WINE__
 399         , set_thread_creator_ptr(nullptr)
 400 #endif
 401     {
 402 # if defined(CARLA_OS_MAC)
 403         const char* const filename("libjack.dylib");
 404 # elif defined(CARLA_OS_WIN64)
 405         const char* const filename("libjack64.dll");
 406 # elif defined(CARLA_OS_WIN)
 407         const char* const filename("libjack.dll");
 408 # else
 409         const char* const filename("libjack.so.0");
 410 # endif
 411
 412         lib = lib_open(filename);
 413
 414         if (lib == nullptr)
 415         {
 416             fprintf(stderr, "Failed to load JACK DLL, reason:\n%s\n", lib_error(filename));
 417             return;
 418         }
 419         else
 420         {
 421             fprintf(stdout, "%s loaded successfully!\n", filename);
 422         }
 423
 424         #define JOIN(a, b) a ## b
 425         #define LIB_SYMBOL(NAME) JOIN(NAME, _ptr) = lib_symbol<jacksym_##NAME>(lib, "jack_" #NAME);
 426
 427         LIB_SYMBOL(get_version)
 428         LIB_SYMBOL(get_version_string)
 429
 430         LIB_SYMBOL(client_open)
 431         LIB_SYMBOL(client_close)
 432
 433         LIB_SYMBOL(client_name_size)
 434         LIB_SYMBOL(get_client_name)
 435
 436         LIB_SYMBOL(client_get_uuid)
 437         LIB_SYMBOL(get_uuid_for_client_name)
 438         LIB_SYMBOL(get_client_name_by_uuid)
 439
 440         LIB_SYMBOL(uuid_parse)
 441         LIB_SYMBOL(uuid_unparse)
 442
 443         LIB_SYMBOL(activate)
 444         LIB_SYMBOL(deactivate)
 445         LIB_SYMBOL(is_realtime)
 446
 447         LIB_SYMBOL(set_thread_init_callback)
 448         LIB_SYMBOL(on_shutdown)
 449         LIB_SYMBOL(on_info_shutdown)
 450         LIB_SYMBOL(set_process_callback)
 451         LIB_SYMBOL(set_freewheel_callback)
 452         LIB_SYMBOL(set_buffer_size_callback)
 453         LIB_SYMBOL(set_sample_rate_callback)
 454         LIB_SYMBOL(set_client_registration_callback)
 455         LIB_SYMBOL(set_port_registration_callback)
 456         LIB_SYMBOL(set_port_rename_callback)
 457         LIB_SYMBOL(set_port_connect_callback)
 458         LIB_SYMBOL(set_graph_order_callback)
 459         LIB_SYMBOL(set_xrun_callback)
 460         LIB_SYMBOL(set_latency_callback)
 461
 462         LIB_SYMBOL(set_freewheel)
 463         LIB_SYMBOL(set_buffer_size)
 464
 465         LIB_SYMBOL(get_sample_rate)
 466         LIB_SYMBOL(get_buffer_size)
 467         LIB_SYMBOL(cpu_load)
 468
 469         LIB_SYMBOL(port_register)
 470         LIB_SYMBOL(port_unregister)
 471         LIB_SYMBOL(port_get_buffer)
 472
 473         LIB_SYMBOL(port_name)
 474         LIB_SYMBOL(port_uuid)
 475         LIB_SYMBOL(port_short_name)
 476         LIB_SYMBOL(port_flags)
 477         LIB_SYMBOL(port_type)
 478         LIB_SYMBOL(port_is_mine)
 479         LIB_SYMBOL(port_connected)
 480         LIB_SYMBOL(port_connected_to)
 481         LIB_SYMBOL(port_get_connections)
 482         LIB_SYMBOL(port_get_all_connections)
 483
 484         LIB_SYMBOL(port_rename)
 485         LIB_SYMBOL(port_set_name)
 486         LIB_SYMBOL(port_set_alias)
 487         LIB_SYMBOL(port_unset_alias)
 488         LIB_SYMBOL(port_get_aliases)
 489
 490         LIB_SYMBOL(port_request_monitor)
 491         LIB_SYMBOL(port_request_monitor_by_name)
 492         LIB_SYMBOL(port_ensure_monitor)
 493         LIB_SYMBOL(port_monitoring_input)
 494
 495         LIB_SYMBOL(connect)
 496         LIB_SYMBOL(disconnect)
 497         LIB_SYMBOL(port_disconnect)
 498
 499         LIB_SYMBOL(port_name_size)
 500         LIB_SYMBOL(port_type_size)
 501         LIB_SYMBOL(port_type_get_buffer_size)
 502
 503         LIB_SYMBOL(port_get_latency_range)
 504         LIB_SYMBOL(port_set_latency_range)
 505         LIB_SYMBOL(recompute_total_latencies)
 506
 507         LIB_SYMBOL(get_ports)
 508         LIB_SYMBOL(port_by_name)
 509         LIB_SYMBOL(port_by_id)
 510
 511         LIB_SYMBOL(free)
 512
 513         LIB_SYMBOL(midi_get_event_count)
 514         LIB_SYMBOL(midi_event_get)
 515         LIB_SYMBOL(midi_clear_buffer)
 516         LIB_SYMBOL(midi_event_write)
 517         LIB_SYMBOL(midi_event_reserve)
 518
 519         LIB_SYMBOL(release_timebase)
 520         LIB_SYMBOL(set_sync_callback)
 521         LIB_SYMBOL(set_sync_timeout)
 522         LIB_SYMBOL(set_timebase_callback)
 523         LIB_SYMBOL(transport_locate)
 524         LIB_SYMBOL(transport_query)
 525         LIB_SYMBOL(get_current_transport_frame)
 526         LIB_SYMBOL(transport_reposition)
 527         LIB_SYMBOL(transport_start)
 528         LIB_SYMBOL(transport_stop)
 529
 530         LIB_SYMBOL(set_property)
 531         LIB_SYMBOL(get_property)
 532         LIB_SYMBOL(free_description)
 533         LIB_SYMBOL(get_properties)
 534         LIB_SYMBOL(get_all_properties)
 535         LIB_SYMBOL(remove_property)
 536         LIB_SYMBOL(remove_properties)
 537         LIB_SYMBOL(remove_all_properties)
 538         LIB_SYMBOL(set_property_change_callback)
 539
 540 #ifdef __WINE__
 541         LIB_SYMBOL(set_thread_creator)
 542 #endif
 543
 544         #undef JOIN
 545         #undef LIB_SYMBOL
 546     }
 547
 548     ~JackBridge() noexcept
 549     {
 550         if (lib != nullptr)
 551         {
 552             lib_close(lib);
 553             lib = nullptr;
 554         }
 555     }
 556
 557     CARLA_DECLARE_NON_COPYABLE(JackBridge);
 558 };
 559
 560 // -----------------------------------------------------------------------------
 561
 562 static const JackBridge& getBridgeInstance() noexcept
 563 {
 564     static const JackBridge bridge;
 565     return bridge;
 566 }
 567
 568 #endif // ! (defined(JACKBRIDGE_DIRECT) || defined(JACKBRIDGE_DUMMY))
 569
 570 // -----------------------------------------------------------------------------
 571
 572 #if defined(__WINE__) && ! defined(JACKBRIDGE_DIRECT)
 573
 574 struct WineBridge {
 575     void* ptr;
 576     JackLatencyCallback latency_cb;
 577     JackProcessCallback process_cb;
 578     JackThreadInitCallback thread_init_cb;
 579     JackGraphOrderCallback graph_order_cb;
 580     JackXRunCallback xrun_cb;
 581     JackBufferSizeCallback bufsize_cb;
 582     JackSampleRateCallback srate_cb;
 583     JackPortRegistrationCallback port_reg_cb;
 584     JackClientRegistrationCallback client_reg_cb;
 585     JackPortConnectCallback port_conn_cb;
 586     JackPortRenameCallback port_rename_cb;
 587     JackFreewheelCallback freewheel_cb;
 588     JackShutdownCallback shutdown_cb;
 589     JackInfoShutdownCallback info_shutdown_cb;
 590     JackSyncCallback sync_cb;
 591     JackTimebaseCallback timebase_cb;
 592     JackSessionCallback session_cb;
 593     JackPropertyChangeCallback prop_change_cb;
 594
 595     void* (*creator_func)(void*);
 596     void* creator_arg;
 597     HANDLE creator_handle;
 598     pthread_t creator_pthread;
 599
 600     WineBridge() noexcept
 601         : ptr(nullptr),
 602           latency_cb(nullptr),
 603           process_cb(nullptr),
 604           thread_init_cb(nullptr),
 605           graph_order_cb(nullptr),
 606           xrun_cb(nullptr),
 607           bufsize_cb(nullptr),
 608           srate_cb(nullptr),
 609           port_reg_cb(nullptr),
 610           client_reg_cb(nullptr),
 611           port_conn_cb(nullptr),
 612           port_rename_cb(nullptr),
 613           freewheel_cb(nullptr),
 614           shutdown_cb(nullptr),
 615           info_shutdown_cb(nullptr),
 616           sync_cb(nullptr),
 617           timebase_cb(nullptr),
 618           session_cb(nullptr),
 619           prop_change_cb(nullptr),
 620           creator_func(nullptr),
 621           creator_arg(nullptr),
 622           creator_handle(nullptr),
 623           creator_pthread(0) {}
 624
 625     static WineBridge& getInstance() noexcept
 626     {
 627         static WineBridge bridge;
 628         return bridge;
 629     }
 630
 631     void set_latency      (JackLatencyCallback            cb) noexcept { latency_cb       = cb; }
 632     void set_process      (JackProcessCallback            cb) noexcept { process_cb       = cb; }
 633     void set_thread_init  (JackThreadInitCallback         cb) noexcept { thread_init_cb   = cb; }
 634     void set_graph_order  (JackGraphOrderCallback         cb) noexcept { graph_order_cb   = cb; }
 635     void set_xrun         (JackXRunCallback               cb) noexcept { xrun_cb          = cb; }
 636     void set_bufsize      (JackBufferSizeCallback         cb) noexcept { bufsize_cb       = cb; }
 637     void set_srate        (JackSampleRateCallback         cb) noexcept { srate_cb         = cb; }
 638     void set_port_reg     (JackPortRegistrationCallback   cb) noexcept { port_reg_cb      = cb; }
 639     void set_client_reg   (JackClientRegistrationCallback cb) noexcept { client_reg_cb    = cb; }
 640     void set_port_conn    (JackPortConnectCallback        cb) noexcept { port_conn_cb     = cb; }
 641     void set_port_rename  (JackPortRenameCallback         cb) noexcept { port_rename_cb   = cb; }
 642     void set_freewheel    (JackFreewheelCallback          cb) noexcept { freewheel_cb     = cb; }
 643     void set_shutdown     (JackShutdownCallback           cb) noexcept { shutdown_cb      = cb; }
 644     void set_info_shutdown(JackInfoShutdownCallback       cb) noexcept { info_shutdown_cb = cb; }
 645     void set_sync         (JackSyncCallback               cb) noexcept { sync_cb          = cb; }
 646     void set_timebase     (JackTimebaseCallback           cb) noexcept { timebase_cb      = cb; }
 647     void set_session      (JackSessionCallback            cb) noexcept { session_cb       = cb; }
 648     void set_prop_change  (JackPropertyChangeCallback     cb) noexcept { prop_change_cb   = cb; }
 649
 650     static DWORD WINAPI thread_creator_helper(LPVOID)
 651     {
 652         WineBridge& inst(getInstance());
 653
 654         inst.creator_pthread = pthread_self();
 655         SetEvent(inst.creator_handle);
 656         inst.creator_func(inst.creator_arg);
 657         return 0;
 658     }
 659
 660     static int thread_creator(pthread_t* thread_id, const pthread_attr_t*, void *(*function)(void*), void* arg)
 661     {
 662         WineBridge& inst(getInstance());
 663
 664         inst.creator_func   = function;
 665         inst.creator_arg    = arg;
 666         inst.creator_handle = ::CreateEventW(nullptr, false, false, nullptr);
 667
 668 #if 0
 669         ::CreateThread(nullptr, 0, thread_creator_helper, arg, 0, nullptr);
 670 #else
 671         HANDLE handle = ::CreateThread(nullptr, 0, thread_creator_helper, arg, CREATE_SUSPENDED, nullptr);
 672
 673         if (handle == INVALID_HANDLE_VALUE)
 674             return 1;
 675
 676         // TODO read attrs and decide this
 677         ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
 678         ::ResumeThread(handle);
 679 #endif
 680
 681         ::WaitForSingleObject(inst.creator_handle, INFINITE);
 682         *thread_id = inst.creator_pthread;
 683         return 0;
 684     }
 685
 686     static void latency(jack_latency_callback_mode_t mode, void* arg)
 687     {
 688         return getInstance().latency_cb(mode, arg);
 689     }
 690
 691     static int process(jack_nframes_t nframes, void* arg)
 692     {
 693         return getInstance().process_cb(nframes, arg);
 694     }
 695
 696     static void thread_init(void* arg)
 697     {
 698         return getInstance().thread_init_cb(arg);
 699     }
 700
 701     static int graph_order(void* arg)
 702     {
 703         return getInstance().graph_order_cb(arg);
 704     }
 705
 706     static int xrun(void* arg)
 707     {
 708         return getInstance().xrun_cb(arg);
 709     }
 710
 711     static int bufsize(jack_nframes_t nframes, void* arg)
 712     {
 713         return getInstance().bufsize_cb(nframes, arg);
 714     }
 715
 716     static int srate(jack_nframes_t nframes, void* arg)
 717     {
 718         return getInstance().srate_cb(nframes, arg);
 719     }
 720
 721     static void port_reg(jack_port_id_t port, int register_, void* arg)
 722     {
 723         return getInstance().port_reg_cb(port, register_, arg);
 724     }
 725
 726     static void client_reg(const char* name, int register_, void* arg)
 727     {
 728         return getInstance().client_reg_cb(name, register_, arg);
 729     }
 730
 731     static void port_conn(jack_port_id_t a, jack_port_id_t b, int connect, void* arg)
 732     {
 733         return getInstance().port_conn_cb(a, b, connect, arg);
 734     }
 735
 736     static void port_rename(jack_port_id_t port, const char* old_name, const char* new_name, void* arg)
 737     {
 738         getInstance().port_rename_cb(port, old_name, new_name, arg);
 739     }
 740
 741     static void freewheel(int starting, void* arg)
 742     {
 743         return getInstance().freewheel_cb(starting, arg);
 744     }
 745
 746     static void shutdown(void* arg)
 747     {
 748         return getInstance().shutdown_cb(arg);
 749     }
 750
 751     static void info_shutdown(jack_status_t code, const char* reason, void* arg)
 752     {
 753         return getInstance().info_shutdown_cb(code, reason, arg);
 754     }
 755
 756     static int sync(jack_transport_state_t state, jack_position_t* pos, void* arg)
 757     {
 758         return getInstance().sync_cb(state, pos, arg);
 759     }
 760
 761     static void timebase(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg)
 762     {
 763         return getInstance().timebase_cb(state, nframes, pos, new_pos, arg);
 764     }
 765
 766     static void session(jack_session_event_t* event, void* arg)
 767     {
 768         return getInstance().session_cb(event, arg);
 769     }
 770
 771     static void prop_change(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg)
 772     {
 773         return getInstance().prop_change_cb(subject, key, change, arg);
 774     }
 775
 776     CARLA_DECLARE_NON_COPYABLE(WineBridge);
 777 };
 778
 779 #endif // __WINE__ && ! JACKBRIDGE_DIRECT
 780
 781 // -----------------------------------------------------------------------------
 782
 783 bool jackbridge_is_ok() noexcept
 784 {
 785 #if defined(JACKBRIDGE_DUMMY)
 786     return false;
 787 #elif defined(JACKBRIDGE_DIRECT)
 788     return true;
 789 #else
 790     return (getBridgeInstance().lib != nullptr);
 791 #endif
 792 }
 793
 794 void jackbridge_init()
 795 {
 796 #if defined(__WINE__) && ! defined(JACKBRIDGE_DIRECT)
 797     if (getBridgeInstance().set_thread_creator_ptr != nullptr)
 798         getBridgeInstance().set_thread_creator_ptr(WineBridge::thread_creator);
 799 #endif
 800 }
 801
 802 // -----------------------------------------------------------------------------
 803
 804 void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr)
 805 {
 806 #if defined(JACKBRIDGE_DUMMY)
 807 #elif defined(JACKBRIDGE_DIRECT)
 808     return jack_get_version(major_ptr, minor_ptr, micro_ptr, proto_ptr);
 809 #else
 810     if (getBridgeInstance().get_version_ptr != nullptr)
 811         return getBridgeInstance().get_version_ptr(major_ptr, minor_ptr, micro_ptr, proto_ptr);
 812 #endif
 813     if (major_ptr != nullptr)
 814         *major_ptr = 0;
 815     if (minor_ptr != nullptr)
 816         *minor_ptr = 0;
 817     if (micro_ptr != nullptr)
 818         *micro_ptr = 0;
 819     if (proto_ptr != nullptr)
 820         *proto_ptr = 0;
 821 }
 822
 823 const char* jackbridge_get_version_string()
 824 {
 825 #if defined(JACKBRIDGE_DUMMY)
 826 #elif defined(JACKBRIDGE_DIRECT)
 827     return jack_get_version_string();
 828 #else
 829     if (getBridgeInstance().get_version_string_ptr != nullptr)
 830         return getBridgeInstance().get_version_string_ptr();
 831 #endif
 832     return nullptr;
 833 }
 834
 835 // -----------------------------------------------------------------------------
 836
 837 jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status)
 838 {
 839 #if defined(JACKBRIDGE_DUMMY)
 840 #elif defined(JACKBRIDGE_DIRECT)
 841     return jack_client_open(client_name, static_cast<jack_options_t>(options), status);
 842 #else
 843     if (getBridgeInstance().client_open_ptr != nullptr)
 844         return getBridgeInstance().client_open_ptr(client_name, static_cast<jack_options_t>(options), status);
 845 #endif
 846     if (status != nullptr)
 847         *status = JackServerError;
 848     return nullptr;
 849 }
 850
 851 bool jackbridge_client_close(jack_client_t* client)
 852 {
 853 #if defined(JACKBRIDGE_DUMMY)
 854 #elif defined(JACKBRIDGE_DIRECT)
 855     return (jack_client_close(client) == 0);
 856 #else
 857     if (getBridgeInstance().client_close_ptr != nullptr)
 858         return (getBridgeInstance().client_close_ptr(client) == 0);
 859 #endif
 860     return false;
 861 }
 862
 863 // -----------------------------------------------------------------------------
 864
 865 int jackbridge_client_name_size()
 866 {
 867 #if defined(JACKBRIDGE_DUMMY)
 868 #elif defined(JACKBRIDGE_DIRECT)
 869     return jack_client_name_size();
 870 #else
 871     if (getBridgeInstance().client_name_size_ptr != nullptr)
 872         return getBridgeInstance().client_name_size_ptr();
 873 #endif
 874     return 33;
 875 }
 876
 877 char* jackbridge_get_client_name(jack_client_t* client)
 878 {
 879 #if defined(JACKBRIDGE_DUMMY)
 880 #elif defined(JACKBRIDGE_DIRECT)
 881     return jack_get_client_name(client);
 882 #else
 883     if (getBridgeInstance().get_client_name_ptr != nullptr)
 884         return getBridgeInstance().get_client_name_ptr(client);
 885 #endif
 886     return nullptr;
 887 }
 888
 889 // -----------------------------------------------------------------------------
 890
 891 char* jackbridge_client_get_uuid(jack_client_t* client)
 892 {
 893 #if defined(JACKBRIDGE_DUMMY)
 894 #elif defined(JACKBRIDGE_DIRECT)
 895     return jack_client_get_uuid(client);
 896 #else
 897     if (const jacksym_client_get_uuid func = getBridgeInstance().client_get_uuid_ptr)
 898         return func(client);
 899 #endif
 900     return nullptr;
 901 }
 902
 903 char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name)
 904 {
 905 #if defined(JACKBRIDGE_DUMMY)
 906 #elif defined(JACKBRIDGE_DIRECT)
 907     return jack_get_uuid_for_client_name(client, name);
 908 #else
 909     if (getBridgeInstance().get_uuid_for_client_name_ptr != nullptr)
 910         return getBridgeInstance().get_uuid_for_client_name_ptr(client, name);
 911 #endif
 912     return nullptr;
 913 }
 914
 915 char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid)
 916 {
 917 #if defined(JACKBRIDGE_DUMMY)
 918 #elif defined(JACKBRIDGE_DIRECT)
 919     return jack_get_client_name_by_uuid(client, uuid);
 920 #else
 921     if (getBridgeInstance().get_client_name_by_uuid_ptr != nullptr)
 922         return getBridgeInstance().get_client_name_by_uuid_ptr(client, uuid);
 923 #endif
 924     return nullptr;
 925 }
 926
 927 // -----------------------------------------------------------------------------
 928
 929 bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid)
 930 {
 931 #if defined(JACKBRIDGE_DUMMY)
 932 #elif defined(JACKBRIDGE_DIRECT)
 933     return (jack_uuid_parse(buf, uuid) == 0);
 934 #else
 935     if (const jacksym_uuid_parse func = getBridgeInstance().uuid_parse_ptr)
 936         return (func(buf, uuid) == 0);
 937 #endif
 938     return false;
 939 }
 940
 941 void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE])
 942 {
 943 #if defined(JACKBRIDGE_DUMMY)
 944 #elif defined(JACKBRIDGE_DIRECT)
 945     jack_uuid_unparse(uuid, buf);
 946 #else
 947     if (const jacksym_uuid_unparse func = getBridgeInstance().uuid_unparse_ptr)
 948         return func(uuid, buf);
 949 #endif
 950 }
 951
 952 // -----------------------------------------------------------------------------
 953
 954 bool jackbridge_activate(jack_client_t* client)
 955 {
 956 #if defined(JACKBRIDGE_DUMMY)
 957 #elif defined(JACKBRIDGE_DIRECT)
 958     return (jack_activate(client) == 0);
 959 #else
 960     if (getBridgeInstance().activate_ptr != nullptr)
 961         return (getBridgeInstance().activate_ptr(client) == 0);
 962 #endif
 963     return false;
 964 }
 965
 966 bool jackbridge_deactivate(jack_client_t* client)
 967 {
 968 #if defined(JACKBRIDGE_DUMMY)
 969 #elif defined(JACKBRIDGE_DIRECT)
 970     return (jack_deactivate(client) == 0);
 971 #else
 972     if (getBridgeInstance().deactivate_ptr != nullptr)
 973         return (getBridgeInstance().deactivate_ptr(client) == 0);
 974 #endif
 975     return false;
 976 }
 977
 978 bool jackbridge_is_realtime(jack_client_t* client)
 979 {
 980 #if defined(JACKBRIDGE_DUMMY)
 981 #elif defined(JACKBRIDGE_DIRECT)
 982     return jack_is_realtime(client);
 983 #else
 984     if (getBridgeInstance().is_realtime_ptr != nullptr)
 985         return getBridgeInstance().is_realtime_ptr(client);
 986 #endif
 987     return false;
 988 }
 989
 990 // -----------------------------------------------------------------------------
 991
 992 bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg)
 993 {
 994 #if defined(JACKBRIDGE_DUMMY)
 995 #elif defined(JACKBRIDGE_DIRECT)
 996     return (jack_set_thread_init_callback(client, thread_init_callback, arg) == 0);
 997 #else
 998     if (getBridgeInstance().set_thread_init_callback_ptr != nullptr)
 999     {
1000 # ifdef __WINE__
1001         WineBridge::getInstance().set_thread_init(thread_init_callback);
1002         return (getBridgeInstance().set_thread_init_callback_ptr(client, WineBridge::thread_init, arg) == 0);
1003 # else
1004         return (getBridgeInstance().set_thread_init_callback_ptr(client, thread_init_callback, arg) == 0);
1005 # endif
1006     }
1007 #endif
1008     return false;
1009 }
1010
1011 void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg)
1012 {
1013 #if defined(JACKBRIDGE_DUMMY)
1014 #elif defined(JACKBRIDGE_DIRECT)
1015     jack_on_shutdown(client, shutdown_callback, arg);
1016 #else
1017     if (getBridgeInstance().on_shutdown_ptr != nullptr)
1018     {
1019 # ifdef __WINE__
1020         WineBridge::getInstance().set_shutdown(shutdown_callback);
1021         getBridgeInstance().on_shutdown_ptr(client, WineBridge::shutdown, arg);
1022 # else
1023         getBridgeInstance().on_shutdown_ptr(client, shutdown_callback, arg);
1024 # endif
1025     }
1026 #endif
1027 }
1028
1029 void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg)
1030 {
1031 #if defined(JACKBRIDGE_DUMMY)
1032 #elif defined(JACKBRIDGE_DIRECT)
1033     jack_on_info_shutdown(client, shutdown_callback, arg);
1034 #else
1035     if (getBridgeInstance().on_info_shutdown_ptr != nullptr)
1036     {
1037 # ifdef __WINE__
1038         WineBridge::getInstance().set_info_shutdown(shutdown_callback);
1039         getBridgeInstance().on_info_shutdown_ptr(client, WineBridge::info_shutdown, arg);
1040 # else
1041         getBridgeInstance().on_info_shutdown_ptr(client, shutdown_callback, arg);
1042 # endif
1043     }
1044 #endif
1045 }
1046
1047 bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)
1048 {
1049 #if defined(JACKBRIDGE_DUMMY)
1050 #elif defined(JACKBRIDGE_DIRECT)
1051     return (jack_set_process_callback(client, process_callback, arg) == 0);
1052 #else
1053     if (getBridgeInstance().set_process_callback_ptr != nullptr)
1054     {
1055 # ifdef __WINE__
1056         WineBridge::getInstance().set_process(process_callback);
1057         return (getBridgeInstance().set_process_callback_ptr(client, WineBridge::process, arg) == 0);
1058 # else
1059         return (getBridgeInstance().set_process_callback_ptr(client, process_callback, arg) == 0);
1060 # endif
1061     }
1062 #endif
1063     return false;
1064 }
1065
1066 bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)
1067 {
1068 #if defined(JACKBRIDGE_DUMMY)
1069 #elif defined(JACKBRIDGE_DIRECT)
1070     return (jack_set_freewheel_callback(client, freewheel_callback, arg) == 0);
1071 #else
1072     if (getBridgeInstance().set_freewheel_callback_ptr != nullptr)
1073     {
1074 # ifdef __WINE__
1075         WineBridge::getInstance().set_freewheel(freewheel_callback);
1076         return (getBridgeInstance().set_freewheel_callback_ptr(client, WineBridge::freewheel, arg) == 0);
1077 # else
1078         return (getBridgeInstance().set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);
1079 # endif
1080     }
1081 #endif
1082     return false;
1083 }
1084
1085 bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)
1086 {
1087 #if defined(JACKBRIDGE_DUMMY)
1088 #elif defined(JACKBRIDGE_DIRECT)
1089     return (jack_set_buffer_size_callback(client, bufsize_callback, arg) == 0);
1090 #else
1091     if (getBridgeInstance().set_buffer_size_callback_ptr != nullptr)
1092     {
1093 # ifdef __WINE__
1094         WineBridge::getInstance().set_bufsize(bufsize_callback);
1095         return (getBridgeInstance().set_buffer_size_callback_ptr(client, WineBridge::bufsize, arg) == 0);
1096 # else
1097         return (getBridgeInstance().set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);
1098 # endif
1099     }
1100 #endif
1101     return false;
1102 }
1103
1104 bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)
1105 {
1106 #if defined(JACKBRIDGE_DUMMY)
1107 #elif defined(JACKBRIDGE_DIRECT)
1108     return (jack_set_sample_rate_callback(client, srate_callback, arg) == 0);
1109 #else
1110     if (getBridgeInstance().set_sample_rate_callback_ptr != nullptr)
1111     {
1112 # ifdef __WINE__
1113         WineBridge::getInstance().set_srate(srate_callback);
1114         return (getBridgeInstance().set_sample_rate_callback_ptr(client, WineBridge::srate, arg) == 0);
1115 # else
1116         return (getBridgeInstance().set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);
1117 # endif
1118     }
1119 #endif
1120     return false;
1121 }
1122
1123 bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)
1124 {
1125 #if defined(JACKBRIDGE_DUMMY)
1126 #elif defined(JACKBRIDGE_DIRECT)
1127     return (jack_set_client_registration_callback(client, registration_callback, arg) == 0);
1128 #else
1129     if (getBridgeInstance().set_client_registration_callback_ptr != nullptr)
1130     {
1131 # ifdef __WINE__
1132         WineBridge::getInstance().set_client_reg(registration_callback);
1133         return (getBridgeInstance().set_client_registration_callback_ptr(client, WineBridge::client_reg, arg) == 0);
1134 # else
1135         return (getBridgeInstance().set_client_registration_callback_ptr(client, registration_callback, arg) == 0);
1136 # endif
1137     }
1138 #endif
1139     return false;
1140 }
1141
1142 bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)
1143 {
1144 #if defined(JACKBRIDGE_DUMMY)
1145 #elif defined(JACKBRIDGE_DIRECT)
1146     return (jack_set_port_registration_callback(client, registration_callback, arg) == 0);
1147 #else
1148     if (getBridgeInstance().set_port_registration_callback_ptr != nullptr)
1149     {
1150 # ifdef __WINE__
1151         WineBridge::getInstance().set_port_reg(registration_callback);
1152         return (getBridgeInstance().set_port_registration_callback_ptr(client, WineBridge::port_reg, arg) == 0);
1153 # else
1154         return (getBridgeInstance().set_port_registration_callback_ptr(client, registration_callback, arg) == 0);
1155 # endif
1156     }
1157 #endif
1158     return false;
1159 }
1160
1161 bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)
1162 {
1163 #if defined(JACKBRIDGE_DUMMY)
1164 #elif defined(JACKBRIDGE_DIRECT)
1165     return (jack_set_port_rename_callback(client, rename_callback, arg) == 0);
1166 #else
1167     if (getBridgeInstance().set_port_rename_callback_ptr != nullptr)
1168     {
1169 # ifdef __WINE__
1170         WineBridge::getInstance().set_port_rename(rename_callback);
1171         return (getBridgeInstance().set_port_rename_callback_ptr(client, WineBridge::port_rename, arg) == 0);
1172 # else
1173         return (getBridgeInstance().set_port_rename_callback_ptr(client, rename_callback, arg) == 0);
1174 # endif
1175     }
1176 #endif
1177     return false;
1178 }
1179
1180 bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)
1181 {
1182 #if defined(JACKBRIDGE_DUMMY)
1183 #elif defined(JACKBRIDGE_DIRECT)
1184     return (jack_set_port_connect_callback(client, connect_callback, arg) == 0);
1185 #else
1186     if (getBridgeInstance().set_port_connect_callback_ptr != nullptr)
1187     {
1188 # ifdef __WINE__
1189         WineBridge::getInstance().set_port_conn(connect_callback);
1190         return (getBridgeInstance().set_port_connect_callback_ptr(client, WineBridge::port_conn, arg) == 0);
1191 # else
1192         return (getBridgeInstance().set_port_connect_callback_ptr(client, connect_callback, arg) == 0);
1193 # endif
1194     }
1195 #endif
1196     return false;
1197 }
1198
1199 bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg)
1200 {
1201 #if defined(JACKBRIDGE_DUMMY)
1202 #elif defined(JACKBRIDGE_DIRECT)
1203     return (jack_set_graph_order_callback(client, graph_callback, arg) == 0);
1204 #else
1205     if (getBridgeInstance().set_graph_order_callback_ptr != nullptr)
1206     {
1207 # ifdef __WINE__
1208         WineBridge::getInstance().set_graph_order(graph_callback);
1209         return (getBridgeInstance().set_graph_order_callback_ptr(client, WineBridge::graph_order, arg) == 0);
1210 # else
1211         return (getBridgeInstance().set_graph_order_callback_ptr(client, graph_callback, arg) == 0);
1212 # endif
1213     }
1214 #endif
1215     return false;
1216 }
1217
1218 bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg)
1219 {
1220 #if defined(JACKBRIDGE_DUMMY)
1221 #elif defined(JACKBRIDGE_DIRECT)
1222     return (jack_set_xrun_callback(client, xrun_callback, arg) == 0);
1223 #else
1224     if (getBridgeInstance().set_xrun_callback_ptr != nullptr)
1225     {
1226 # ifdef __WINE__
1227         WineBridge::getInstance().set_xrun(xrun_callback);
1228         return (getBridgeInstance().set_xrun_callback_ptr(client, WineBridge::xrun, arg) == 0);
1229 # else
1230         return (getBridgeInstance().set_xrun_callback_ptr(client, xrun_callback, arg) == 0);
1231 # endif
1232     }
1233 #endif
1234     return false;
1235 }
1236
1237 bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)
1238 {
1239 #if defined(JACKBRIDGE_DUMMY)
1240 #elif defined(JACKBRIDGE_DIRECT)
1241     return (jack_set_latency_callback(client, latency_callback, arg) == 0);
1242 #else
1243     if (getBridgeInstance().set_latency_callback_ptr != nullptr)
1244     {
1245 # ifdef __WINE__
1246         WineBridge::getInstance().set_latency(latency_callback);
1247         return (getBridgeInstance().set_latency_callback_ptr(client, WineBridge::latency, arg) == 0);
1248 # else
1249         return (getBridgeInstance().set_latency_callback_ptr(client, latency_callback, arg) == 0);
1250 # endif
1251     }
1252 #endif
1253     return false;
1254 }
1255
1256 // -----------------------------------------------------------------------------
1257
1258 bool jackbridge_set_freewheel(jack_client_t* client, bool onoff)
1259 {
1260 #if defined(JACKBRIDGE_DUMMY)
1261 #elif defined(JACKBRIDGE_DIRECT)
1262     return jack_set_freewheel(client, onoff);
1263 #else
1264     if (getBridgeInstance().set_freewheel_ptr != nullptr)
1265         return getBridgeInstance().set_freewheel_ptr(client, onoff);
1266 #endif
1267     return false;
1268 }
1269
1270 bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes)
1271 {
1272 #if defined(JACKBRIDGE_DUMMY)
1273 #elif defined(JACKBRIDGE_DIRECT)
1274     return jack_set_buffer_size(client, nframes);
1275 #else
1276     if (getBridgeInstance().set_buffer_size_ptr != nullptr)
1277         return getBridgeInstance().set_buffer_size_ptr(client, nframes);
1278 #endif
1279     return false;
1280 }
1281
1282 // -----------------------------------------------------------------------------
1283
1284 jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)
1285 {
1286 #if defined(JACKBRIDGE_DUMMY)
1287 #elif defined(JACKBRIDGE_DIRECT)
1288     return jack_get_sample_rate(client);
1289 #else
1290     if (getBridgeInstance().get_sample_rate_ptr != nullptr)
1291         return getBridgeInstance().get_sample_rate_ptr(client);
1292 #endif
1293     return 0;
1294 }
1295
1296 jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)
1297 {
1298 #if defined(JACKBRIDGE_DUMMY)
1299 #elif defined(JACKBRIDGE_DIRECT)
1300     return jack_get_buffer_size(client);
1301 #else
1302     if (getBridgeInstance().get_buffer_size_ptr != nullptr)
1303         return getBridgeInstance().get_buffer_size_ptr(client);
1304 #endif
1305     return 0;
1306 }
1307
1308 float jackbridge_cpu_load(jack_client_t* client)
1309 {
1310 #if defined(JACKBRIDGE_DUMMY)
1311 #elif defined(JACKBRIDGE_DIRECT)
1312     return jack_cpu_load(client);
1313 #else
1314     if (getBridgeInstance().cpu_load_ptr != nullptr)
1315         return getBridgeInstance().cpu_load_ptr(client);
1316 #endif
1317     return 0.0f;
1318 }
1319
1320 // -----------------------------------------------------------------------------
1321
1322 jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, uint64_t flags, uint64_t buffer_size)
1323 {
1324 #if defined(JACKBRIDGE_DUMMY)
1325 #elif defined(JACKBRIDGE_DIRECT)
1326     return jack_port_register(client, port_name, port_type, flags, buffer_size);
1327 #else
1328     if (getBridgeInstance().port_register_ptr != nullptr)
1329         return getBridgeInstance().port_register_ptr(client, port_name, port_type,
1330                                                      static_cast<ulong>(flags),
1331                                                      static_cast<ulong>(buffer_size));
1332 #endif
1333     return nullptr;
1334 }
1335
1336 bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)
1337 {
1338 #if defined(JACKBRIDGE_DUMMY)
1339 #elif defined(JACKBRIDGE_DIRECT)
1340     return (jack_port_unregister(client, port) == 0);
1341 #else
1342     if (getBridgeInstance().port_unregister_ptr != nullptr)
1343         return (getBridgeInstance().port_unregister_ptr(client, port) == 0);
1344 #endif
1345     return false;
1346 }
1347
1348 void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)
1349 {
1350 #if defined(JACKBRIDGE_DUMMY)
1351 #elif defined(JACKBRIDGE_DIRECT)
1352     return jack_port_get_buffer(port, nframes);
1353 #else
1354     if (getBridgeInstance().port_get_buffer_ptr != nullptr)
1355         return getBridgeInstance().port_get_buffer_ptr(port, nframes);
1356 #endif
1357     return nullptr;
1358 }
1359
1360 // -----------------------------------------------------------------------------
1361
1362 const char* jackbridge_port_name(const jack_port_t* port)
1363 {
1364 #if defined(JACKBRIDGE_DUMMY)
1365 #elif defined(JACKBRIDGE_DIRECT)
1366     return jack_port_name(port);
1367 #else
1368     if (getBridgeInstance().port_name_ptr != nullptr)
1369         return getBridgeInstance().port_name_ptr(port);
1370 #endif
1371     return nullptr;
1372 }
1373
1374 jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)
1375 {
1376 #if defined(JACKBRIDGE_DUMMY)
1377 #elif defined(JACKBRIDGE_DIRECT)
1378     return jack_port_uuid(port);
1379 #else
1380     if (getBridgeInstance().port_uuid_ptr != nullptr)
1381         return getBridgeInstance().port_uuid_ptr(port);
1382 #endif
1383     return 0;
1384 }
1385
1386 const char* jackbridge_port_short_name(const jack_port_t* port)
1387 {
1388 #if defined(JACKBRIDGE_DUMMY)
1389 #elif defined(JACKBRIDGE_DIRECT)
1390     return jack_port_short_name(port);
1391 #else
1392     if (getBridgeInstance().port_short_name_ptr != nullptr)
1393         return getBridgeInstance().port_short_name_ptr(port);
1394 #endif
1395     return nullptr;
1396 }
1397
1398 int jackbridge_port_flags(const jack_port_t* port)
1399 {
1400 #if defined(JACKBRIDGE_DUMMY)
1401 #elif defined(JACKBRIDGE_DIRECT)
1402     return jack_port_flags(port);
1403 #else
1404     if (getBridgeInstance().port_flags_ptr != nullptr)
1405         return getBridgeInstance().port_flags_ptr(port);
1406 #endif
1407     return 0x0;
1408 }
1409
1410 const char* jackbridge_port_type(const jack_port_t* port)
1411 {
1412 #if defined(JACKBRIDGE_DUMMY)
1413 #elif defined(JACKBRIDGE_DIRECT)
1414     return jack_port_type(port);
1415 #else
1416     if (getBridgeInstance().port_type_ptr != nullptr)
1417         return getBridgeInstance().port_type_ptr(port);
1418 #endif
1419     return nullptr;
1420 }
1421
1422 bool jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port)
1423 {
1424 #if defined(JACKBRIDGE_DUMMY)
1425 #elif defined(JACKBRIDGE_DIRECT)
1426     return jack_port_is_mine(client, port);
1427 #else
1428     if (getBridgeInstance().port_is_mine_ptr != nullptr)
1429         return getBridgeInstance().port_is_mine_ptr(client, port);
1430 #endif
1431     return false;
1432 }
1433
1434 int jackbridge_port_connected(const jack_port_t* port)
1435 {
1436 #if defined(JACKBRIDGE_DUMMY)
1437 #elif defined(JACKBRIDGE_DIRECT)
1438     return jack_port_connected(port);
1439 #else
1440     if (getBridgeInstance().port_connected_ptr != nullptr)
1441         return getBridgeInstance().port_connected_ptr(port);
1442 #endif
1443     return 0;
1444 }
1445
1446 bool jackbridge_port_connected_to(const jack_port_t* port, const char* port_name)
1447 {
1448 #if defined(JACKBRIDGE_DUMMY)
1449 #elif defined(JACKBRIDGE_DIRECT)
1450     return jack_port_connected_to(port, port_name);
1451 #else
1452     if (getBridgeInstance().port_connected_to_ptr != nullptr)
1453         return getBridgeInstance().port_connected_to_ptr(port, port_name);
1454 #endif
1455     return false;
1456 }
1457
1458 const char** jackbridge_port_get_connections(const jack_port_t* port)
1459 {
1460 #if defined(JACKBRIDGE_DUMMY)
1461 #elif defined(JACKBRIDGE_DIRECT)
1462     return jack_port_get_connections(port);
1463 #else
1464     if (getBridgeInstance().port_get_connections_ptr != nullptr)
1465         return getBridgeInstance().port_get_connections_ptr(port);
1466 #endif
1467     return nullptr;
1468 }
1469
1470 const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port)
1471 {
1472 #if defined(JACKBRIDGE_DUMMY)
1473 #elif defined(JACKBRIDGE_DIRECT)
1474     return jack_port_get_all_connections(client, port);
1475 #else
1476     if (getBridgeInstance().port_get_all_connections_ptr != nullptr)
1477         return getBridgeInstance().port_get_all_connections_ptr(client, port);
1478 #endif
1479     return nullptr;
1480 }
1481
1482 // -----------------------------------------------------------------------------
1483
1484 bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name)
1485 {
1486 #if defined(JACKBRIDGE_DUMMY)
1487 #elif defined(JACKBRIDGE_DIRECT)
1488     return (jack_port_rename(client, port, port_name) == 0);
1489 #else
1490     // Try new API first
1491     if (getBridgeInstance().port_rename_ptr != nullptr)
1492         return (getBridgeInstance().port_rename_ptr(client, port, port_name) == 0);
1493     // Try old API if using JACK2
1494     if (getBridgeInstance().get_version_string_ptr != nullptr && getBridgeInstance().port_set_name_ptr != nullptr)
1495         return (getBridgeInstance().port_set_name_ptr(port, port_name) == 0);
1496 #endif
1497     return false;
1498 }
1499
1500 bool jackbridge_port_set_alias(jack_port_t* port, const char* alias)
1501 {
1502 #if defined(JACKBRIDGE_DUMMY)
1503 #elif defined(JACKBRIDGE_DIRECT)
1504     return (jack_port_set_alias(port, alias) == 0);
1505 #else
1506     if (getBridgeInstance().port_set_alias_ptr != nullptr)
1507         return (getBridgeInstance().port_set_alias_ptr(port, alias) == 0);
1508 #endif
1509     return false;
1510 }
1511
1512 bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias)
1513 {
1514 #if defined(JACKBRIDGE_DUMMY)
1515 #elif defined(JACKBRIDGE_DIRECT)
1516     return (jack_port_unset_alias(port, alias) == 0);
1517 #else
1518     if (getBridgeInstance().port_unset_alias_ptr != nullptr)
1519         return (getBridgeInstance().port_unset_alias_ptr(port, alias) == 0);
1520 #endif
1521     return false;
1522 }
1523
1524 int jackbridge_port_get_aliases(const jack_port_t* port, char* const aliases[2])
1525 {
1526 #if defined(JACKBRIDGE_DUMMY)
1527 #elif defined(JACKBRIDGE_DIRECT)
1528     return (jack_port_get_aliases(port, aliases) == 0);
1529 #else
1530     if (getBridgeInstance().port_get_aliases_ptr != nullptr)
1531         return getBridgeInstance().port_get_aliases_ptr(port, aliases);
1532 #endif
1533     return 0;
1534 }
1535
1536 // -----------------------------------------------------------------------------
1537
1538 bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff)
1539 {
1540 #if defined(JACKBRIDGE_DUMMY)
1541 #elif defined(JACKBRIDGE_DIRECT)
1542     return (jack_port_request_monitor(port, onoff) == 0);
1543 #else
1544     if (getBridgeInstance().port_request_monitor_ptr != nullptr)
1545         return (getBridgeInstance().port_request_monitor_ptr(port, onoff) == 0);
1546 #endif
1547     return false;
1548 }
1549
1550 bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff)
1551 {
1552 #if defined(JACKBRIDGE_DUMMY)
1553 #elif defined(JACKBRIDGE_DIRECT)
1554     return (jack_port_request_monitor_by_name(client, port_name, onoff) == 0);
1555 #else
1556     if (getBridgeInstance().port_request_monitor_by_name_ptr != nullptr)
1557         return (getBridgeInstance().port_request_monitor_by_name_ptr(client, port_name, onoff) == 0);
1558 #endif
1559     return false;
1560 }
1561
1562 bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff)
1563 {
1564 #if defined(JACKBRIDGE_DUMMY)
1565 #elif defined(JACKBRIDGE_DIRECT)
1566     return (jack_port_ensure_monitor(port, onoff) == 0);
1567 #else
1568     if (getBridgeInstance().port_ensure_monitor_ptr != nullptr)
1569         return (getBridgeInstance().port_ensure_monitor_ptr(port, onoff) == 0);
1570 #endif
1571     return false;
1572 }
1573
1574 bool jackbridge_port_monitoring_input(jack_port_t* port)
1575 {
1576 #if defined(JACKBRIDGE_DUMMY)
1577 #elif defined(JACKBRIDGE_DIRECT)
1578     return jack_port_monitoring_input(port);
1579 #else
1580     if (getBridgeInstance().port_monitoring_input_ptr != nullptr)
1581         return getBridgeInstance().port_monitoring_input_ptr(port);
1582 #endif
1583     return false;
1584 }
1585
1586 // -----------------------------------------------------------------------------
1587
1588 bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port)
1589 {
1590 #if defined(JACKBRIDGE_DUMMY)
1591 #elif defined(JACKBRIDGE_DIRECT)
1592     return (jack_connect(client, source_port, destination_port) == 0);
1593 #else
1594     if (getBridgeInstance().connect_ptr != nullptr)
1595     {
1596         const int ret = getBridgeInstance().connect_ptr(client, source_port, destination_port);
1597         return ret == 0 || ret == EEXIST;
1598     }
1599 #endif
1600     return false;
1601 }
1602
1603 bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port)
1604 {
1605 #if defined(JACKBRIDGE_DUMMY)
1606 #elif defined(JACKBRIDGE_DIRECT)
1607     return (jack_disconnect(client, source_port, destination_port) == 0);
1608 #else
1609     if (getBridgeInstance().disconnect_ptr != nullptr)
1610         return (getBridgeInstance().disconnect_ptr(client, source_port, destination_port) == 0);
1611 #endif
1612     return false;
1613 }
1614
1615 bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port)
1616 {
1617 #if defined(JACKBRIDGE_DUMMY)
1618 #elif defined(JACKBRIDGE_DIRECT)
1619     return (jack_port_disconnect(client, port) == 0);
1620 #else
1621     if (getBridgeInstance().port_disconnect_ptr != nullptr)
1622         return (getBridgeInstance().port_disconnect_ptr(client, port) == 0);
1623 #endif
1624     return false;
1625 }
1626
1627 // -----------------------------------------------------------------------------
1628
1629 int jackbridge_port_name_size()
1630 {
1631 #if defined(JACKBRIDGE_DUMMY)
1632 #elif defined(JACKBRIDGE_DIRECT)
1633     return jack_port_name_size();
1634 #else
1635     if (getBridgeInstance().port_name_size_ptr != nullptr)
1636         return getBridgeInstance().port_name_size_ptr();
1637 #endif
1638     return 256;
1639 }
1640
1641 int jackbridge_port_type_size()
1642 {
1643 #if defined(JACKBRIDGE_DUMMY)
1644 #elif defined(JACKBRIDGE_DIRECT)
1645     return jack_port_type_size();
1646 #else
1647     if (getBridgeInstance().port_type_size_ptr != nullptr)
1648         return getBridgeInstance().port_type_size_ptr();
1649 #endif
1650     return 32;
1651 }
1652
1653 uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type)
1654 {
1655 #if defined(JACKBRIDGE_DUMMY)
1656 #elif defined(JACKBRIDGE_DIRECT)
1657     return static_cast<uint32_t>(jack_port_type_get_buffer_size(client, port_type));
1658 #else
1659     if (getBridgeInstance().port_type_get_buffer_size_ptr != nullptr)
1660         return static_cast<uint32_t>(getBridgeInstance().port_type_get_buffer_size_ptr(client, port_type));
1661 #endif
1662     return 0;
1663 }
1664
1665 // -----------------------------------------------------------------------------
1666
1667 void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)
1668 {
1669 #if defined(JACKBRIDGE_DUMMY)
1670 #elif defined(JACKBRIDGE_DIRECT)
1671     return jack_port_get_latency_range(port, static_cast<jack_latency_callback_mode_t>(mode), range);
1672 #else
1673     if (getBridgeInstance().port_get_latency_range_ptr != nullptr)
1674         return getBridgeInstance().port_get_latency_range_ptr(port,
1675                                                               static_cast<jack_latency_callback_mode_t>(mode),
1676                                                               range);
1677 #endif
1678     range->min = 0;
1679     range->max = 0;
1680 }
1681
1682 void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)
1683 {
1684 #if defined(JACKBRIDGE_DUMMY)
1685 #elif defined(JACKBRIDGE_DIRECT)
1686     jack_port_set_latency_range(port, static_cast<jack_latency_callback_mode_t>(mode), range);
1687 #else
1688     if (getBridgeInstance().port_set_latency_range_ptr != nullptr)
1689         getBridgeInstance().port_set_latency_range_ptr(port,
1690                                                        static_cast<jack_latency_callback_mode_t>(mode),
1691                                                        range);
1692 #endif
1693 }
1694
1695 bool jackbridge_recompute_total_latencies(jack_client_t* client)
1696 {
1697 #if defined(JACKBRIDGE_DUMMY)
1698 #elif defined(JACKBRIDGE_DIRECT)
1699     return (jack_recompute_total_latencies(client) == 0);
1700 #else
1701     if (getBridgeInstance().recompute_total_latencies_ptr != nullptr)
1702         return (getBridgeInstance().recompute_total_latencies_ptr(client) == 0);
1703 #endif
1704     return false;
1705 }
1706
1707 // -----------------------------------------------------------------------------
1708
1709 const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags)
1710 {
1711 #if defined(JACKBRIDGE_DUMMY)
1712 #elif defined(JACKBRIDGE_DIRECT)
1713     return jack_get_ports(client, port_name_pattern, type_name_pattern, flags);
1714 #else
1715     if (getBridgeInstance().get_ports_ptr != nullptr)
1716         return getBridgeInstance().get_ports_ptr(client, port_name_pattern, type_name_pattern,
1717                                                  static_cast<ulong>(flags));
1718 #endif
1719     return nullptr;
1720 }
1721
1722 jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name)
1723 {
1724 #if defined(JACKBRIDGE_DUMMY)
1725 #elif defined(JACKBRIDGE_DIRECT)
1726     return jack_port_by_name(client, port_name);
1727 #else
1728     if (getBridgeInstance().port_by_name_ptr != nullptr)
1729         return getBridgeInstance().port_by_name_ptr(client, port_name);
1730 #endif
1731     return nullptr;
1732 }
1733
1734 jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)
1735 {
1736 #if defined(JACKBRIDGE_DUMMY)
1737 #elif defined(JACKBRIDGE_DIRECT)
1738     return jack_port_by_id(client, port_id);
1739 #else
1740     if (getBridgeInstance().port_by_id_ptr != nullptr)
1741         return getBridgeInstance().port_by_id_ptr(client, port_id);
1742 #endif
1743     return nullptr;
1744 }
1745
1746 // -----------------------------------------------------------------------------
1747
1748 void jackbridge_free(void* ptr)
1749 {
1750 #if defined(JACKBRIDGE_DUMMY)
1751 #elif defined(JACKBRIDGE_DIRECT)
1752     return jack_free(ptr);
1753 #else
1754     if (getBridgeInstance().free_ptr != nullptr)
1755         return getBridgeInstance().free_ptr(ptr);
1756
1757     // just in case
1758     std::free(ptr);
1759 #endif
1760 }
1761
1762 // -----------------------------------------------------------------------------
1763
1764 uint32_t jackbridge_midi_get_event_count(void* port_buffer)
1765 {
1766 #if defined(JACKBRIDGE_DUMMY)
1767 #elif defined(JACKBRIDGE_DIRECT)
1768     return jack_midi_get_event_count(port_buffer);
1769 #else
1770     if (getBridgeInstance().midi_get_event_count_ptr != nullptr)
1771         return getBridgeInstance().midi_get_event_count_ptr(port_buffer);
1772 #endif
1773     return 0;
1774 }
1775
1776 bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)
1777 {
1778 #if defined(JACKBRIDGE_DUMMY)
1779 #elif defined(JACKBRIDGE_DIRECT)
1780     return (jack_midi_event_get(event, port_buffer, event_index) == 0);
1781 #else
1782     if (getBridgeInstance().midi_event_get_ptr != nullptr)
1783         return (getBridgeInstance().midi_event_get_ptr(event, port_buffer, event_index) == 0);
1784 #endif
1785     return false;
1786 }
1787
1788 void jackbridge_midi_clear_buffer(void* port_buffer)
1789 {
1790 #if defined(JACKBRIDGE_DUMMY)
1791 #elif defined(JACKBRIDGE_DIRECT)
1792     jack_midi_clear_buffer(port_buffer);
1793 #else
1794     if (getBridgeInstance().midi_clear_buffer_ptr != nullptr)
1795         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);
1796 #endif
1797 }
1798
1799 bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size)
1800 {
1801 #if defined(JACKBRIDGE_DUMMY)
1802 #elif defined(JACKBRIDGE_DIRECT)
1803     return (jack_midi_event_write(port_buffer, time, data, data_size) == 0);
1804 #else
1805     if (getBridgeInstance().midi_event_write_ptr != nullptr)
1806         return (getBridgeInstance().midi_event_write_ptr(port_buffer, time, data, data_size) == 0);
1807 #endif
1808     return false;
1809 }
1810
1811 jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size)
1812 {
1813 #if defined(JACKBRIDGE_DUMMY)
1814 #elif defined(JACKBRIDGE_DIRECT)
1815     return jack_midi_event_reserve(port_buffer, time, data_size);
1816 #else
1817     if (getBridgeInstance().midi_event_reserve_ptr != nullptr)
1818         return getBridgeInstance().midi_event_reserve_ptr(port_buffer, time, data_size);
1819 #endif
1820     return nullptr;
1821 }
1822
1823 // -----------------------------------------------------------------------------
1824
1825 bool jackbridge_release_timebase(jack_client_t* client)
1826 {
1827 #if defined(JACKBRIDGE_DUMMY)
1828 #elif defined(JACKBRIDGE_DIRECT)
1829     return (jack_release_timebase(client) == 0);
1830 #else
1831     if (getBridgeInstance().release_timebase_ptr != nullptr)
1832         return (getBridgeInstance().release_timebase_ptr(client) == 0);
1833 #endif
1834     return false;
1835 }
1836
1837 bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg)
1838 {
1839 #if defined(JACKBRIDGE_DUMMY)
1840 #elif defined(JACKBRIDGE_DIRECT)
1841     return (jack_set_sync_callback(client, sync_callback, arg) == 0);
1842 #else
1843     if (getBridgeInstance().set_sync_callback_ptr != nullptr)
1844     {
1845 # ifdef __WINE__
1846         WineBridge::getInstance().set_sync(sync_callback);
1847         return (getBridgeInstance().set_sync_callback_ptr(client, WineBridge::sync, arg) == 0);
1848 # else
1849         return (getBridgeInstance().set_sync_callback_ptr(client, sync_callback, arg) == 0);
1850 # endif
1851     }
1852 #endif
1853     return false;
1854 }
1855
1856 bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout)
1857 {
1858 #if defined(JACKBRIDGE_DUMMY)
1859 #elif defined(JACKBRIDGE_DIRECT)
1860     return (jack_set_sync_timeout(client, timeout) == 0);
1861 #else
1862     if (getBridgeInstance().set_sync_timeout_ptr != nullptr)
1863         return (getBridgeInstance().set_sync_timeout_ptr(client, timeout) == 0);
1864 #endif
1865     return false;
1866 }
1867
1868 bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg)
1869 {
1870 #if defined(JACKBRIDGE_DUMMY)
1871 #elif defined(JACKBRIDGE_DIRECT)
1872     return (jack_set_timebase_callback(client, conditional, timebase_callback, arg) == 0);
1873 #else
1874     if (getBridgeInstance().set_timebase_callback_ptr != nullptr)
1875     {
1876 # ifdef __WINE__
1877         WineBridge::getInstance().set_timebase(timebase_callback);
1878         return (getBridgeInstance().set_timebase_callback_ptr(client, conditional, WineBridge::timebase, arg) == 0);
1879 # else
1880         return (getBridgeInstance().set_timebase_callback_ptr(client, conditional, timebase_callback, arg) == 0);
1881 # endif
1882     }
1883 #endif
1884     return false;
1885 }
1886
1887 bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)
1888 {
1889 #if defined(JACKBRIDGE_DUMMY)
1890 #elif defined(JACKBRIDGE_DIRECT)
1891     return (jack_transport_locate(client, frame) == 0);
1892 #else
1893     if (getBridgeInstance().transport_locate_ptr != nullptr)
1894         return (getBridgeInstance().transport_locate_ptr(client, frame) == 0);
1895 #endif
1896     return false;
1897 }
1898
1899 uint32_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)
1900 {
1901 #if defined(JACKBRIDGE_DUMMY)
1902 #elif defined(JACKBRIDGE_DIRECT)
1903     return jack_transport_query(client, pos);
1904 #else
1905     if (getBridgeInstance().transport_query_ptr != nullptr)
1906         return getBridgeInstance().transport_query_ptr(client, pos);
1907 #endif
1908     if (pos != nullptr)
1909     {
1910         // invalidate
1911         pos->unique_1 = 0;
1912         pos->unique_2 = 1;
1913     }
1914     return JackTransportStopped;
1915 }
1916
1917 jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)
1918 {
1919 #if defined(JACKBRIDGE_DUMMY)
1920 #elif defined(JACKBRIDGE_DIRECT)
1921     return jack_get_current_transport_frame(client);
1922 #else
1923     if (getBridgeInstance().get_current_transport_frame_ptr != nullptr)
1924         return getBridgeInstance().get_current_transport_frame_ptr(client);
1925 #endif
1926     return 0;
1927 }
1928
1929 bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos)
1930 {
1931 #if defined(JACKBRIDGE_DUMMY)
1932 #elif defined(JACKBRIDGE_DIRECT)
1933     return (jack_transport_reposition(client, pos) == 0);
1934 #else
1935     if (getBridgeInstance().transport_reposition_ptr != nullptr)
1936         return (getBridgeInstance().transport_reposition_ptr(client, pos) == 0);
1937 #endif
1938     return false;
1939 }
1940
1941 void jackbridge_transport_start(jack_client_t* client)
1942 {
1943 #if defined(JACKBRIDGE_DUMMY)
1944 #elif defined(JACKBRIDGE_DIRECT)
1945     jack_transport_start(client);
1946 #else
1947     if (getBridgeInstance().transport_start_ptr != nullptr)
1948         getBridgeInstance().transport_start_ptr(client);
1949 #endif
1950 }
1951
1952 void jackbridge_transport_stop(jack_client_t* client)
1953 {
1954 #if defined(JACKBRIDGE_DUMMY)
1955 #elif defined(JACKBRIDGE_DIRECT)
1956     jack_transport_stop(client);
1957 #else
1958     if (getBridgeInstance().transport_stop_ptr != nullptr)
1959         getBridgeInstance().transport_stop_ptr(client);
1960 #endif
1961 }
1962
1963 // -----------------------------------------------------------------------------
1964
1965 bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type)
1966 {
1967 #if defined(JACKBRIDGE_DUMMY)
1968 #elif defined(JACKBRIDGE_DIRECT)
1969     return (jack_set_property(client, subject, key, value, type) == 0);
1970 #else
1971     if (getBridgeInstance().set_property_ptr != nullptr)
1972         return (getBridgeInstance().set_property_ptr(client, subject, key, value, type) == 0);
1973 #endif
1974     return false;
1975 }
1976
1977 bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type)
1978 {
1979 #if defined(JACKBRIDGE_DUMMY)
1980 #elif defined(JACKBRIDGE_DIRECT)
1981     return (jack_get_property(subject, key, value, type) == 0);
1982 #else
1983     if (getBridgeInstance().get_property_ptr != nullptr)
1984         return (getBridgeInstance().get_property_ptr(subject, key, value, type) == 0);
1985 #endif
1986     return false;
1987 }
1988
1989 void jackbridge_free_description(jack_description_t* desc, bool free_description_itself)
1990 {
1991 #if defined(JACKBRIDGE_DUMMY)
1992 #elif defined(JACKBRIDGE_DIRECT)
1993     jack_free_description(desc, free_description_itself);
1994 #else
1995     if (getBridgeInstance().free_description_ptr != nullptr)
1996         getBridgeInstance().free_description_ptr(desc, free_description_itself);
1997 #endif
1998 }
1999
2000 bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc)
2001 {
2002 #if defined(JACKBRIDGE_DUMMY)
2003 #elif defined(JACKBRIDGE_DIRECT)
2004     return (jack_get_properties(subject, desc) == 0);
2005 #else
2006     if (getBridgeInstance().get_properties_ptr != nullptr)
2007         return (getBridgeInstance().get_properties_ptr(subject, desc) == 0);
2008 #endif
2009     return false;
2010 }
2011
2012 bool jackbridge_get_all_properties(jack_description_t** descs)
2013 {
2014 #if defined(JACKBRIDGE_DUMMY)
2015 #elif defined(JACKBRIDGE_DIRECT)
2016     return (jack_get_all_properties(descs) == 0);
2017 #else
2018     if (getBridgeInstance().get_all_properties_ptr != nullptr)
2019         return (getBridgeInstance().get_all_properties_ptr(descs) == 0);
2020 #endif
2021     return false;
2022 }
2023
2024 bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key)
2025 {
2026 #if defined(JACKBRIDGE_DUMMY)
2027 #elif defined(JACKBRIDGE_DIRECT)
2028     return (jack_remove_property(client, subject, key) == 0);
2029 #else
2030     if (getBridgeInstance().remove_property_ptr != nullptr)
2031         return (getBridgeInstance().remove_property_ptr(client, subject, key) == 0);
2032 #endif
2033     return false;
2034 }
2035
2036 int jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject)
2037 {
2038 #if defined(JACKBRIDGE_DUMMY)
2039 #elif defined(JACKBRIDGE_DIRECT)
2040     return jack_remove_properties(client, subject);
2041 #else
2042     if (getBridgeInstance().remove_properties_ptr != nullptr)
2043         return getBridgeInstance().remove_properties_ptr(client, subject);
2044 #endif
2045     return 0;
2046 }
2047
2048 bool jackbridge_remove_all_properties(jack_client_t* client)
2049 {
2050 #if defined(JACKBRIDGE_DUMMY)
2051 #elif defined(JACKBRIDGE_DIRECT)
2052     return (jack_remove_all_properties(client) == 0);
2053 #else
2054     if (getBridgeInstance().remove_all_properties_ptr != nullptr)
2055         return (getBridgeInstance().remove_all_properties_ptr(client) == 0);
2056 #endif
2057     return false;
2058 }
2059
2060 bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg)
2061 {
2062 #if defined(JACKBRIDGE_DUMMY)
2063 #elif defined(JACKBRIDGE_DIRECT)
2064     return (jack_set_property_change_callback(client, callback, arg) == 0);
2065 #else
2066     if (getBridgeInstance().set_property_change_callback_ptr != nullptr)
2067     {
2068 # ifdef __WINE__
2069         WineBridge::getInstance().set_prop_change(callback);
2070         return (getBridgeInstance().set_property_change_callback_ptr(client, WineBridge::prop_change, arg) == 0);
2071 # else
2072         return (getBridgeInstance().set_property_change_callback_ptr(client, callback, arg) == 0);
2073 # endif
2074     }
2075 #endif
2076     return false;
2077 }
2078
2079 // -----------------------------------------------------------------------------