DISTRHO
/
DPF
mirror of https://github.com/DISTRHO/DPF
1
0
Fork 0
Code Releases 0 Activity
DISTRHO Plugin Framework
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2452 Commits
7 Branches
190MB
Tree: d55da275c2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd55da275c2'
${ noResults }
DPF/distrho/src/jackbridge/JackBridge.cpp

2489 lines
84KB
Raw Blame History 

  1. /*

  2.  * JackBridge for DPF

  3.  * Copyright (C) 2013-2024 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. #include "../../DistrhoStandaloneUtils.hpp"

  19. 

  20. #if ! (defined(JACKBRIDGE_DIRECT) || defined(JACKBRIDGE_DUMMY))

  21. 

  22. #ifdef __WINE__

  23. # ifndef NOMINMAX

  24. #  define NOMINMAX

  25. # endif

  26. # include <windows.h>

  27. # include <pthread.h>

  28. #endif

  29. 

  30. #if defined(DISTRHO_OS_WINDOWS) && ! defined(__WINE__)

  31. # define JACKSYM_API __cdecl

  32. #else

  33. # define JACKSYM_API

  34. #endif

  35. 

  36. #include <cerrno>

  37. 

  38. #ifdef HAVE_JACK

  39. # include "../../extra/LibraryUtils.hpp"

  40. #else

  41. typedef void* lib_t;

  42. #endif

  43. 

  44. // in case JACK fails, we fallback to native bridges simulating JACK API

  45. #include "NativeBridge.hpp"

  46. 

  47. #if defined(DISTRHO_OS_WASM)

  48. # include "WebBridge.hpp"

  49. #endif

  50. 

  51. #ifndef DISTRHO_PROPER_CPP11_SUPPORT

  52. # undef HAVE_RTAUDIO

  53. #endif

  54. 

  55. #ifdef DPF_JACK_STANDALONE_SKIP_RTAUDIO_FALLBACK

  56. # undef HAVE_RTAUDIO

  57. #endif

  58. 

  59. #ifdef DPF_JACK_STANDALONE_SKIP_SDL2_FALLBACK

  60. # undef HAVE_SDL2

  61. #endif

  62. 

  63. #if defined(HAVE_RTAUDIO) && (DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS) > 0

  64. // fix conflict between DGL and macOS names

  65. # define Point CorePoint

  66. # define Size CoreSize

  67. # ifdef __clang__

  68. #  pragma clang diagnostic push

  69. #  pragma clang diagnostic ignored "-Wdeprecated-declarations"

  70. #  pragma clang diagnostic ignored "-Wunused-but-set-variable"

  71. # endif

  72. # include "RtAudioBridge.hpp"

  73. # ifdef RTAUDIO_API_TYPE

  74. #  include "rtaudio/RtAudio.cpp"

  75. # endif

  76. # ifdef RTMIDI_API_TYPE

  77. #  include "rtmidi/RtMidi.cpp"

  78. # endif

  79. # ifdef __clang__

  80. #  pragma clang diagnostic pop

  81. # endif

  82. # undef Point

  83. # undef Size

  84. #endif

  85. 

  86. #if defined(HAVE_SDL2) && (DISTRHO_PLUGIN_NUM_INPUTS + DISTRHO_PLUGIN_NUM_OUTPUTS) > 0

  87. # include "SDL2Bridge.hpp"

  88. #endif

  89. 

  90. // --------------------------------------------------------------------------------------------------------------------

  91. 

  92. extern "C" {

  93. 

  94. typedef void (JACKSYM_API *JackSymLatencyCallback)(jack_latency_callback_mode_t, void*);

  95. typedef int  (JACKSYM_API *JackSymProcessCallback)(jack_nframes_t, void*);

  96. typedef void (JACKSYM_API *JackSymThreadInitCallback)(void*);

  97. typedef int  (JACKSYM_API *JackSymGraphOrderCallback)(void*);

  98. typedef int  (JACKSYM_API *JackSymXRunCallback)(void*);

  99. typedef int  (JACKSYM_API *JackSymBufferSizeCallback)(jack_nframes_t, void*);

  100. typedef int  (JACKSYM_API *JackSymSampleRateCallback)(jack_nframes_t, void*);

  101. typedef void (JACKSYM_API *JackSymPortRegistrationCallback)(jack_port_id_t, int, void*);

  102. typedef void (JACKSYM_API *JackSymClientRegistrationCallback)(const char*, int, void*);

  103. typedef void (JACKSYM_API *JackSymPortConnectCallback)(jack_port_id_t, jack_port_id_t, int, void*);

  104. typedef void (JACKSYM_API *JackSymPortRenameCallback)(jack_port_id_t, const char*, const char*, void*);

  105. typedef void (JACKSYM_API *JackSymFreewheelCallback)(int, void*);

  106. typedef void (JACKSYM_API *JackSymShutdownCallback)(void*);

  107. typedef void (JACKSYM_API *JackSymInfoShutdownCallback)(jack_status_t, const char*, void*);

  108. typedef int  (JACKSYM_API *JackSymSyncCallback)(jack_transport_state_t, jack_position_t*, void*);

  109. typedef void (JACKSYM_API *JackSymTimebaseCallback)(jack_transport_state_t, jack_nframes_t, jack_position_t*, int, void*);

  110. typedef void (JACKSYM_API *JackSymSessionCallback)(jack_session_event_t*, void*);

  111. typedef void (JACKSYM_API *JackSymPropertyChangeCallback)(jack_uuid_t, const char*, jack_property_change_t, void*);

  112. typedef void* (JACKSYM_API *JackSymThreadCallback)(void*);

  113. 

  114. typedef void        (JACKSYM_API *jacksym_get_version)(int*, int*, int*, int*);

  115. typedef const char* (JACKSYM_API *jacksym_get_version_string)(void);

  116. 

  117. typedef jack_client_t* (JACKSYM_API *jacksym_client_open)(const char*, jack_options_t, jack_status_t*, ...);

  118. typedef int            (JACKSYM_API *jacksym_client_close)(jack_client_t*);

  119. 

  120. typedef int   (JACKSYM_API *jacksym_client_name_size)(void);

  121. typedef char* (JACKSYM_API *jacksym_get_client_name)(jack_client_t*);

  122. 

  123. typedef char* (JACKSYM_API *jacksym_client_get_uuid)(jack_client_t*);

  124. typedef char* (JACKSYM_API *jacksym_get_uuid_for_client_name)(jack_client_t*, const char*);

  125. typedef char* (JACKSYM_API *jacksym_get_client_name_by_uuid)(jack_client_t*, const char*);

  126. 

  127. typedef int  (JACKBRIDGE_API *jacksym_uuid_parse)(const char*, jack_uuid_t*);

  128. typedef void (JACKBRIDGE_API *jacksym_uuid_unparse)(jack_uuid_t, char buf[JACK_UUID_STRING_SIZE]);

  129. 

  130. typedef int (JACKSYM_API *jacksym_activate)(jack_client_t*);

  131. typedef int (JACKSYM_API *jacksym_deactivate)(jack_client_t*);

  132. typedef int (JACKSYM_API *jacksym_is_realtime)(jack_client_t*);

  133. 

  134. typedef int  (JACKSYM_API *jacksym_set_thread_init_callback)(jack_client_t*, JackSymThreadInitCallback, void*);

  135. typedef void (JACKSYM_API *jacksym_on_shutdown)(jack_client_t*, JackSymShutdownCallback, void*);

  136. typedef void (JACKSYM_API *jacksym_on_info_shutdown)(jack_client_t*, JackSymInfoShutdownCallback, void*);

  137. typedef int  (JACKSYM_API *jacksym_set_process_callback)(jack_client_t*, JackSymProcessCallback, void*);

  138. typedef int  (JACKSYM_API *jacksym_set_freewheel_callback)(jack_client_t*, JackSymFreewheelCallback, void*);

  139. typedef int  (JACKSYM_API *jacksym_set_buffer_size_callback)(jack_client_t*, JackSymBufferSizeCallback, void*);

  140. typedef int  (JACKSYM_API *jacksym_set_sample_rate_callback)(jack_client_t*, JackSymSampleRateCallback, void*);

  141. typedef int  (JACKSYM_API *jacksym_set_client_registration_callback)(jack_client_t*, JackSymClientRegistrationCallback, void*);

  142. typedef int  (JACKSYM_API *jacksym_set_port_registration_callback)(jack_client_t*, JackSymPortRegistrationCallback, void*);

  143. typedef int  (JACKSYM_API *jacksym_set_port_rename_callback)(jack_client_t*, JackSymPortRenameCallback, void*);

  144. typedef int  (JACKSYM_API *jacksym_set_port_connect_callback)(jack_client_t*, JackSymPortConnectCallback, void*);

  145. typedef int  (JACKSYM_API *jacksym_set_graph_order_callback)(jack_client_t*, JackSymGraphOrderCallback, void*);

  146. typedef int  (JACKSYM_API *jacksym_set_xrun_callback)(jack_client_t*, JackSymXRunCallback, void*);

  147. typedef int  (JACKSYM_API *jacksym_set_latency_callback)(jack_client_t*, JackSymLatencyCallback, void*);

  148. 

  149. typedef int (JACKSYM_API *jacksym_set_freewheel)(jack_client_t*, int);

  150. typedef int (JACKSYM_API *jacksym_set_buffer_size)(jack_client_t*, jack_nframes_t);

  151. 

  152. typedef jack_nframes_t (JACKSYM_API *jacksym_get_sample_rate)(jack_client_t*);

  153. typedef jack_nframes_t (JACKSYM_API *jacksym_get_buffer_size)(jack_client_t*);

  154. typedef float          (JACKSYM_API *jacksym_cpu_load)(jack_client_t*);

  155. 

  156. typedef jack_port_t* (JACKSYM_API *jacksym_port_register)(jack_client_t*, const char*, const char*, ulong, ulong);

  157. typedef int          (JACKSYM_API *jacksym_port_unregister)(jack_client_t*, jack_port_t*);

  158. typedef void*        (JACKSYM_API *jacksym_port_get_buffer)(jack_port_t*, jack_nframes_t);

  159. 

  160. typedef const char*  (JACKSYM_API *jacksym_port_name)(const jack_port_t*);

  161. typedef jack_uuid_t  (JACKSYM_API *jacksym_port_uuid)(const jack_port_t*);

  162. typedef const char*  (JACKSYM_API *jacksym_port_short_name)(const jack_port_t*);

  163. typedef int          (JACKSYM_API *jacksym_port_flags)(const jack_port_t*);

  164. typedef const char*  (JACKSYM_API *jacksym_port_type)(const jack_port_t*);

  165. typedef int          (JACKSYM_API *jacksym_port_is_mine)(const jack_client_t*, const jack_port_t*);

  166. typedef int          (JACKSYM_API *jacksym_port_connected)(const jack_port_t*);

  167. typedef int          (JACKSYM_API *jacksym_port_connected_to)(const jack_port_t*, const char*);

  168. typedef const char** (JACKSYM_API *jacksym_port_get_connections)(const jack_port_t*);

  169. typedef const char** (JACKSYM_API *jacksym_port_get_all_connections)(const jack_client_t*, const jack_port_t*);

  170. 

  171. typedef int (JACKSYM_API *jacksym_port_rename)(jack_client_t*, jack_port_t*, const char*);

  172. typedef int (JACKSYM_API *jacksym_port_set_name)(jack_port_t*, const char*);

  173. typedef int (JACKSYM_API *jacksym_port_set_alias)(jack_port_t*, const char*);

  174. typedef int (JACKSYM_API *jacksym_port_unset_alias)(jack_port_t*, const char*);

  175. typedef int (JACKSYM_API *jacksym_port_get_aliases)(const jack_port_t*, char* const aliases[2]);

  176. 

  177. typedef int (JACKSYM_API *jacksym_port_request_monitor)(jack_port_t*, int);

  178. typedef int (JACKSYM_API *jacksym_port_request_monitor_by_name)(jack_client_t*, const char*, int);

  179. typedef int (JACKSYM_API *jacksym_port_ensure_monitor)(jack_port_t*, int);

  180. typedef int (JACKSYM_API *jacksym_port_monitoring_input)(jack_port_t*);

  181. 

  182. typedef int (JACKSYM_API *jacksym_connect)(jack_client_t*, const char*, const char*);

  183. typedef int (JACKSYM_API *jacksym_disconnect)(jack_client_t*, const char*, const char*);

  184. typedef int (JACKSYM_API *jacksym_port_disconnect)(jack_client_t*, jack_port_t*);

  185. 

  186. typedef int    (JACKSYM_API *jacksym_port_name_size)(void);

  187. typedef int    (JACKSYM_API *jacksym_port_type_size)(void);

  188. typedef size_t (JACKSYM_API *jacksym_port_type_get_buffer_size)(jack_client_t*, const char*);

  189. 

  190. typedef void (JACKSYM_API *jacksym_port_get_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);

  191. typedef void (JACKSYM_API *jacksym_port_set_latency_range)(jack_port_t*, jack_latency_callback_mode_t, jack_latency_range_t*);

  192. typedef int  (JACKSYM_API *jacksym_recompute_total_latencies)(jack_client_t*);

  193. 

  194. typedef const char** (JACKSYM_API *jacksym_get_ports)(jack_client_t*, const char*, const char*, ulong);

  195. typedef jack_port_t* (JACKSYM_API *jacksym_port_by_name)(jack_client_t*, const char*);

  196. typedef jack_port_t* (JACKSYM_API *jacksym_port_by_id)(jack_client_t*, jack_port_id_t);

  197. 

  198. typedef void (JACKSYM_API *jacksym_free)(void*);

  199. 

  200. typedef uint32_t (JACKSYM_API *jacksym_midi_get_event_count)(void*);

  201. typedef int      (JACKSYM_API *jacksym_midi_event_get)(jack_midi_event_t*, void*, uint32_t);

  202. typedef void     (JACKSYM_API *jacksym_midi_clear_buffer)(void*);

  203. typedef int      (JACKSYM_API *jacksym_midi_event_write)(void*, jack_nframes_t, const jack_midi_data_t*, size_t);

  204. typedef jack_midi_data_t* (JACKSYM_API *jacksym_midi_event_reserve)(void*, jack_nframes_t, size_t);

  205. 

  206. typedef int (JACKSYM_API *jacksym_release_timebase)(jack_client_t*);

  207. typedef int (JACKSYM_API *jacksym_set_sync_callback)(jack_client_t*, JackSymSyncCallback, void*);

  208. typedef int (JACKSYM_API *jacksym_set_sync_timeout)(jack_client_t*, jack_time_t);

  209. typedef int (JACKSYM_API *jacksym_set_timebase_callback)(jack_client_t*, int, JackSymTimebaseCallback, void*);

  210. typedef int (JACKSYM_API *jacksym_transport_locate)(jack_client_t*, jack_nframes_t);

  211. 

  212. typedef jack_transport_state_t (JACKSYM_API *jacksym_transport_query)(const jack_client_t*, jack_position_t*);

  213. typedef jack_nframes_t         (JACKSYM_API *jacksym_get_current_transport_frame)(const jack_client_t*);

  214. 

  215. typedef int  (JACKSYM_API *jacksym_transport_reposition)(jack_client_t*, const jack_position_t*);

  216. typedef void (JACKSYM_API *jacksym_transport_start)(jack_client_t*);

  217. typedef void (JACKSYM_API *jacksym_transport_stop)(jack_client_t*);

  218. 

  219. typedef int  (JACKSYM_API *jacksym_set_property)(jack_client_t*, jack_uuid_t, const char*, const char*, const char*);

  220. typedef int  (JACKSYM_API *jacksym_get_property)(jack_uuid_t, const char*, char**, char**);

  221. typedef void (JACKSYM_API *jacksym_free_description)(jack_description_t*, int);

  222. typedef int  (JACKSYM_API *jacksym_get_properties)(jack_uuid_t, jack_description_t*);

  223. typedef int  (JACKSYM_API *jacksym_get_all_properties)(jack_description_t**);

  224. typedef int  (JACKSYM_API *jacksym_remove_property)(jack_client_t*, jack_uuid_t, const char*);

  225. typedef int  (JACKSYM_API *jacksym_remove_properties)(jack_client_t*, jack_uuid_t);

  226. typedef int  (JACKSYM_API *jacksym_remove_all_properties)(jack_client_t*);

  227. typedef int  (JACKSYM_API *jacksym_set_property_change_callback)(jack_client_t*, JackSymPropertyChangeCallback, void*);

  228. 

  229. typedef bool           (JACKSYM_API *jacksym_set_process_thread)(jack_client_t*, JackSymThreadCallback callback, void*);

  230. typedef jack_nframes_t (JACKSYM_API *jacksym_cycle_wait)(jack_client_t*);

  231. typedef void           (JACKSYM_API *jacksym_cycle_signal)(jack_client_t*, int);

  232. 

  233. #ifdef __WINE__

  234. typedef int  (JACKSYM_API *jacksym_thread_creator_t)(pthread_t*, const pthread_attr_t*, void *(*)(void*), void*);

  235. typedef void (JACKSYM_API *jacksym_set_thread_creator)(jacksym_thread_creator_t);

  236. #endif

  237. 

  238. } // extern "C"

  239. 

  240. // --------------------------------------------------------------------------------------------------------------------

  241. 

  242. struct JackBridge {

  243.     lib_t lib;

  244. 

  245.     jacksym_get_version get_version_ptr;

  246.     jacksym_get_version_string get_version_string_ptr;

  247. 

  248.     jacksym_client_open client_open_ptr;

  249.     jacksym_client_close client_close_ptr;

  250. 

  251.     jacksym_client_name_size client_name_size_ptr;

  252.     jacksym_get_client_name get_client_name_ptr;

  253. 

  254.     jacksym_client_get_uuid client_get_uuid_ptr;

  255.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  256.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  257. 

  258.     jacksym_uuid_parse uuid_parse_ptr;

  259.     jacksym_uuid_unparse uuid_unparse_ptr;

  260. 

  261.     jacksym_activate activate_ptr;

  262.     jacksym_deactivate deactivate_ptr;

  263.     jacksym_is_realtime is_realtime_ptr;

  264. 

  265.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  266.     jacksym_on_shutdown on_shutdown_ptr;

  267.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  268.     jacksym_set_process_callback set_process_callback_ptr;

  269.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  270.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  271.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  272.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  273.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  274.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  275.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  276.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  277.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  278.     jacksym_set_latency_callback set_latency_callback_ptr;

  279. 

  280.     jacksym_set_freewheel set_freewheel_ptr;

  281.     jacksym_set_buffer_size set_buffer_size_ptr;

  282. 

  283.     jacksym_get_sample_rate get_sample_rate_ptr;

  284.     jacksym_get_buffer_size get_buffer_size_ptr;

  285.     jacksym_cpu_load cpu_load_ptr;

  286. 

  287.     jacksym_port_register port_register_ptr;

  288.     jacksym_port_unregister port_unregister_ptr;

  289.     jacksym_port_get_buffer port_get_buffer_ptr;

  290. 

  291.     jacksym_port_name port_name_ptr;

  292.     jacksym_port_uuid port_uuid_ptr;

  293.     jacksym_port_short_name port_short_name_ptr;

  294.     jacksym_port_flags port_flags_ptr;

  295.     jacksym_port_type port_type_ptr;

  296.     jacksym_port_is_mine port_is_mine_ptr;

  297.     jacksym_port_connected port_connected_ptr;

  298.     jacksym_port_connected_to port_connected_to_ptr;

  299.     jacksym_port_get_connections port_get_connections_ptr;

  300.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  301. 

  302.     jacksym_port_rename port_rename_ptr;

  303.     jacksym_port_set_name port_set_name_ptr;

  304.     jacksym_port_set_alias port_set_alias_ptr;

  305.     jacksym_port_unset_alias port_unset_alias_ptr;

  306.     jacksym_port_get_aliases port_get_aliases_ptr;

  307. 

  308.     jacksym_port_request_monitor port_request_monitor_ptr;

  309.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  310.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  311.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  312. 

  313.     jacksym_connect connect_ptr;

  314.     jacksym_disconnect disconnect_ptr;

  315.     jacksym_port_disconnect port_disconnect_ptr;

  316. 

  317.     jacksym_port_name_size port_name_size_ptr;

  318.     jacksym_port_type_size port_type_size_ptr;

  319.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  320. 

  321.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  322.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  323.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  324. 

  325.     jacksym_get_ports get_ports_ptr;

  326.     jacksym_port_by_name port_by_name_ptr;

  327.     jacksym_port_by_id port_by_id_ptr;

  328. 

  329.     jacksym_free free_ptr;

  330. 

  331.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  332.     jacksym_midi_event_get midi_event_get_ptr;

  333.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  334.     jacksym_midi_event_write midi_event_write_ptr;

  335.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  336. 

  337.     jacksym_release_timebase release_timebase_ptr;

  338.     jacksym_set_sync_callback set_sync_callback_ptr;

  339.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  340.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  341.     jacksym_transport_locate transport_locate_ptr;

  342. 

  343.     jacksym_transport_query transport_query_ptr;

  344.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  345. 

  346.     jacksym_transport_reposition transport_reposition_ptr;

  347.     jacksym_transport_start transport_start_ptr;

  348.     jacksym_transport_stop transport_stop_ptr;

  349. 

  350.     jacksym_set_property set_property_ptr;

  351.     jacksym_get_property get_property_ptr;

  352.     jacksym_free_description free_description_ptr;

  353.     jacksym_get_properties get_properties_ptr;

  354.     jacksym_get_all_properties get_all_properties_ptr;

  355.     jacksym_remove_property remove_property_ptr;

  356.     jacksym_remove_properties remove_properties_ptr;

  357.     jacksym_remove_all_properties remove_all_properties_ptr;

  358.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  359. 

  360.     jacksym_set_process_thread set_process_thread_ptr;

  361.     jacksym_cycle_wait cycle_wait_ptr;

  362.     jacksym_cycle_signal cycle_signal_ptr;

  363. 

  364.    #ifdef __WINE__

  365.     jacksym_set_thread_creator set_thread_creator_ptr;

  366.    #endif

  367. 

  368.     JackBridge()

  369.         : lib(nullptr),

  370.           get_version_ptr(nullptr),

  371.           get_version_string_ptr(nullptr),

  372.           client_open_ptr(nullptr),

  373.           client_close_ptr(nullptr),

  374.           client_name_size_ptr(nullptr),

  375.           get_client_name_ptr(nullptr),

  376.           client_get_uuid_ptr(nullptr),

  377.           get_uuid_for_client_name_ptr(nullptr),

  378.           get_client_name_by_uuid_ptr(nullptr),

  379.           uuid_parse_ptr(nullptr),

  380.           uuid_unparse_ptr(nullptr),

  381.           activate_ptr(nullptr),

  382.           deactivate_ptr(nullptr),

  383.           is_realtime_ptr(nullptr),

  384.           set_thread_init_callback_ptr(nullptr),

  385.           on_shutdown_ptr(nullptr),

  386.           on_info_shutdown_ptr(nullptr),

  387.           set_process_callback_ptr(nullptr),

  388.           set_freewheel_callback_ptr(nullptr),

  389.           set_buffer_size_callback_ptr(nullptr),

  390.           set_sample_rate_callback_ptr(nullptr),

  391.           set_client_registration_callback_ptr(nullptr),

  392.           set_port_registration_callback_ptr(nullptr),

  393.           set_port_rename_callback_ptr(nullptr),

  394.           set_port_connect_callback_ptr(nullptr),

  395.           set_graph_order_callback_ptr(nullptr),

  396.           set_xrun_callback_ptr(nullptr),

  397.           set_latency_callback_ptr(nullptr),

  398.           set_freewheel_ptr(nullptr),

  399.           set_buffer_size_ptr(nullptr),

  400.           get_sample_rate_ptr(nullptr),

  401.           get_buffer_size_ptr(nullptr),

  402.           cpu_load_ptr(nullptr),

  403.           port_register_ptr(nullptr),

  404.           port_unregister_ptr(nullptr),

  405.           port_get_buffer_ptr(nullptr),

  406.           port_name_ptr(nullptr),

  407.           port_uuid_ptr(nullptr),

  408.           port_short_name_ptr(nullptr),

  409.           port_flags_ptr(nullptr),

  410.           port_type_ptr(nullptr),

  411.           port_is_mine_ptr(nullptr),

  412.           port_connected_ptr(nullptr),

  413.           port_connected_to_ptr(nullptr),

  414.           port_get_connections_ptr(nullptr),

  415.           port_get_all_connections_ptr(nullptr),

  416.           port_rename_ptr(nullptr),

  417.           port_set_name_ptr(nullptr),

  418.           port_set_alias_ptr(nullptr),

  419.           port_unset_alias_ptr(nullptr),

  420.           port_get_aliases_ptr(nullptr),

  421.           port_request_monitor_ptr(nullptr),

  422.           port_request_monitor_by_name_ptr(nullptr),

  423.           port_ensure_monitor_ptr(nullptr),

  424.           port_monitoring_input_ptr(nullptr),

  425.           connect_ptr(nullptr),

  426.           disconnect_ptr(nullptr),

  427.           port_disconnect_ptr(nullptr),

  428.           port_name_size_ptr(nullptr),

  429.           port_type_size_ptr(nullptr),

  430.           port_type_get_buffer_size_ptr(nullptr),

  431.           port_get_latency_range_ptr(nullptr),

  432.           port_set_latency_range_ptr(nullptr),

  433.           recompute_total_latencies_ptr(nullptr),

  434.           get_ports_ptr(nullptr),

  435.           port_by_name_ptr(nullptr),

  436.           port_by_id_ptr(nullptr),

  437.           free_ptr(nullptr),

  438.           midi_get_event_count_ptr(nullptr),

  439.           midi_event_get_ptr(nullptr),

  440.           midi_clear_buffer_ptr(nullptr),

  441.           midi_event_write_ptr(nullptr),

  442.           midi_event_reserve_ptr(nullptr),

  443.           release_timebase_ptr(nullptr),

  444.           set_sync_callback_ptr(nullptr),

  445.           set_sync_timeout_ptr(nullptr),

  446.           set_timebase_callback_ptr(nullptr),

  447.           transport_locate_ptr(nullptr),

  448.           transport_query_ptr(nullptr),

  449.           get_current_transport_frame_ptr(nullptr),

  450.           transport_reposition_ptr(nullptr),

  451.           transport_start_ptr(nullptr),

  452.           transport_stop_ptr(nullptr),

  453.           set_property_ptr(nullptr),

  454.           get_property_ptr(nullptr),

  455.           free_description_ptr(nullptr),

  456.           get_properties_ptr(nullptr),

  457.           get_all_properties_ptr(nullptr),

  458.           remove_property_ptr(nullptr),

  459.           remove_properties_ptr(nullptr),

  460.           remove_all_properties_ptr(nullptr),

  461.           set_property_change_callback_ptr(nullptr),

  462.           set_process_thread_ptr(nullptr),

  463.           cycle_wait_ptr(nullptr),

  464.           cycle_signal_ptr(nullptr)

  465.          #ifdef __WINE__

  466.         , set_thread_creator_ptr(nullptr)

  467.          #endif

  468.     {

  469.       #ifdef HAVE_JACK

  470.         static constexpr const char* const filenames[] = {

  471.            #if defined(DISTRHO_OS_MAC)

  472.             "libjack.0.dylib",

  473.             "/usr/local/lib/libjack.0.dylib",

  474.            #elif defined(DISTRHO_OS_WINDOWS) && defined(_WIN64)

  475.             "libjack64.dll",

  476.            #elif defined(DISTRHO_OS_WINDOWS)

  477.             "libjack.dll",

  478.            #else

  479.             "libjack.so.0",

  480.            #endif

  481.         };

  482. 

  483.         USE_NAMESPACE_DISTRHO

  484. 

  485.         for (uint i = 0; i < ARRAY_SIZE(filenames); ++i)

  486.         {

  487.             lib = lib_open(filenames[i]);

  488. 

  489.             if (lib != nullptr)

  490.             {

  491.                 d_stdout("%s loaded successfully!", filenames[i]);

  492.                 break;

  493.             }

  494.         }

  495. 

  496.         if (lib == nullptr)

  497.         {

  498.             d_stderr("Failed to load JACK DLL, reason:\n%s", lib_error(filenames[0]));

  499.             return;

  500.         }

  501. 

  502.         #define JOIN(a, b) a ## b

  503.         #define LIB_SYMBOL(NAME) JOIN(NAME, _ptr) = lib_symbol<jacksym_##NAME>(lib, "jack_" #NAME);

  504. 

  505.         LIB_SYMBOL(get_version)

  506.         LIB_SYMBOL(get_version_string)

  507. 

  508.         LIB_SYMBOL(client_open)

  509.         LIB_SYMBOL(client_close)

  510. 

  511.         LIB_SYMBOL(client_name_size)

  512.         LIB_SYMBOL(get_client_name)

  513. 

  514.         LIB_SYMBOL(client_get_uuid)

  515.         LIB_SYMBOL(get_uuid_for_client_name)

  516.         LIB_SYMBOL(get_client_name_by_uuid)

  517. 

  518.         LIB_SYMBOL(uuid_parse)

  519.         LIB_SYMBOL(uuid_unparse)

  520. 

  521.         LIB_SYMBOL(activate)

  522.         LIB_SYMBOL(deactivate)

  523.         LIB_SYMBOL(is_realtime)

  524. 

  525.         LIB_SYMBOL(set_thread_init_callback)

  526.         LIB_SYMBOL(on_shutdown)

  527.         LIB_SYMBOL(on_info_shutdown)

  528.         LIB_SYMBOL(set_process_callback)

  529.         LIB_SYMBOL(set_freewheel_callback)

  530.         LIB_SYMBOL(set_buffer_size_callback)

  531.         LIB_SYMBOL(set_sample_rate_callback)

  532.         LIB_SYMBOL(set_client_registration_callback)

  533.         LIB_SYMBOL(set_port_registration_callback)

  534.         LIB_SYMBOL(set_port_rename_callback)

  535.         LIB_SYMBOL(set_port_connect_callback)

  536.         LIB_SYMBOL(set_graph_order_callback)

  537.         LIB_SYMBOL(set_xrun_callback)

  538.         LIB_SYMBOL(set_latency_callback)

  539. 

  540.         LIB_SYMBOL(set_freewheel)

  541.         LIB_SYMBOL(set_buffer_size)

  542. 

  543.         LIB_SYMBOL(get_sample_rate)

  544.         LIB_SYMBOL(get_buffer_size)

  545.         LIB_SYMBOL(cpu_load)

  546. 

  547.         LIB_SYMBOL(port_register)

  548.         LIB_SYMBOL(port_unregister)

  549.         LIB_SYMBOL(port_get_buffer)

  550. 

  551.         LIB_SYMBOL(port_name)

  552.         LIB_SYMBOL(port_uuid)

  553.         LIB_SYMBOL(port_short_name)

  554.         LIB_SYMBOL(port_flags)

  555.         LIB_SYMBOL(port_type)

  556.         LIB_SYMBOL(port_is_mine)

  557.         LIB_SYMBOL(port_connected)

  558.         LIB_SYMBOL(port_connected_to)

  559.         LIB_SYMBOL(port_get_connections)

  560.         LIB_SYMBOL(port_get_all_connections)

  561. 

  562.         LIB_SYMBOL(port_rename)

  563.         LIB_SYMBOL(port_set_name)

  564.         LIB_SYMBOL(port_set_alias)

  565.         LIB_SYMBOL(port_unset_alias)

  566.         LIB_SYMBOL(port_get_aliases)

  567. 

  568.         LIB_SYMBOL(port_request_monitor)

  569.         LIB_SYMBOL(port_request_monitor_by_name)

  570.         LIB_SYMBOL(port_ensure_monitor)

  571.         LIB_SYMBOL(port_monitoring_input)

  572. 

  573.         LIB_SYMBOL(connect)

  574.         LIB_SYMBOL(disconnect)

  575.         LIB_SYMBOL(port_disconnect)

  576. 

  577.         LIB_SYMBOL(port_name_size)

  578.         LIB_SYMBOL(port_type_size)

  579.         LIB_SYMBOL(port_type_get_buffer_size)

  580. 

  581.         LIB_SYMBOL(port_get_latency_range)

  582.         LIB_SYMBOL(port_set_latency_range)

  583.         LIB_SYMBOL(recompute_total_latencies)

  584. 

  585.         LIB_SYMBOL(get_ports)

  586.         LIB_SYMBOL(port_by_name)

  587.         LIB_SYMBOL(port_by_id)

  588. 

  589.         LIB_SYMBOL(free)

  590. 

  591.         LIB_SYMBOL(midi_get_event_count)

  592.         LIB_SYMBOL(midi_event_get)

  593.         LIB_SYMBOL(midi_clear_buffer)

  594.         LIB_SYMBOL(midi_event_write)

  595.         LIB_SYMBOL(midi_event_reserve)

  596. 

  597.         LIB_SYMBOL(release_timebase)

  598.         LIB_SYMBOL(set_sync_callback)

  599.         LIB_SYMBOL(set_sync_timeout)

  600.         LIB_SYMBOL(set_timebase_callback)

  601.         LIB_SYMBOL(transport_locate)

  602.         LIB_SYMBOL(transport_query)

  603.         LIB_SYMBOL(get_current_transport_frame)

  604.         LIB_SYMBOL(transport_reposition)

  605.         LIB_SYMBOL(transport_start)

  606.         LIB_SYMBOL(transport_stop)

  607. 

  608.         LIB_SYMBOL(set_property)

  609.         LIB_SYMBOL(get_property)

  610.         LIB_SYMBOL(free_description)

  611.         LIB_SYMBOL(get_properties)

  612.         LIB_SYMBOL(get_all_properties)

  613.         LIB_SYMBOL(remove_property)

  614.         LIB_SYMBOL(remove_properties)

  615.         LIB_SYMBOL(remove_all_properties)

  616.         LIB_SYMBOL(set_property_change_callback)

  617. 

  618.         LIB_SYMBOL(set_process_thread)

  619.         LIB_SYMBOL(cycle_wait)

  620.         LIB_SYMBOL(cycle_signal)

  621. 

  622.        #ifdef __WINE__

  623.         LIB_SYMBOL(set_thread_creator)

  624.        #endif

  625.       #endif

  626. 

  627.         #undef JOIN

  628.         #undef LIB_SYMBOL

  629.     }

  630. 

  631.    #ifdef HAVE_JACK

  632.     ~JackBridge() noexcept

  633.     {

  634.         USE_NAMESPACE_DISTRHO

  635. 

  636.         if (lib != nullptr)

  637.         {

  638.             lib_close(lib);

  639.             lib = nullptr;

  640.         }

  641.     }

  642.    #endif

  643. 

  644.     DISTRHO_DECLARE_NON_COPYABLE(JackBridge);

  645. };

  646. 

  647. static bool usingNativeBridge = false;

  648. static bool usingRealJACK = true;

  649. static NativeBridge* nativeBridge = nullptr;

  650. 

  651. // --------------------------------------------------------------------------------------------------------------------

  652. 

  653. static JackBridge& getBridgeInstance() noexcept

  654. {

  655.     static JackBridge bridge;

  656.     return bridge;

  657. }

  658. 

  659. #endif // ! (defined(JACKBRIDGE_DIRECT) || defined(JACKBRIDGE_DUMMY))

  660. 

  661. // --------------------------------------------------------------------------------------------------------------------

  662. 

  663. #if defined(__WINE__) && ! defined(JACKBRIDGE_DIRECT)

  664. 

  665. struct WineBridge {

  666.     void* ptr;

  667.     JackLatencyCallback latency_cb;

  668.     JackProcessCallback process_cb;

  669.     JackThreadInitCallback thread_init_cb;

  670.     JackGraphOrderCallback graph_order_cb;

  671.     JackXRunCallback xrun_cb;

  672.     JackBufferSizeCallback bufsize_cb;

  673.     JackSampleRateCallback srate_cb;

  674.     JackPortRegistrationCallback port_reg_cb;

  675.     JackClientRegistrationCallback client_reg_cb;

  676.     JackPortConnectCallback port_conn_cb;

  677.     JackPortRenameCallback port_rename_cb;

  678.     JackFreewheelCallback freewheel_cb;

  679.     JackShutdownCallback shutdown_cb;

  680.     JackInfoShutdownCallback info_shutdown_cb;

  681.     JackSyncCallback sync_cb;

  682.     JackTimebaseCallback timebase_cb;

  683.     JackSessionCallback session_cb;

  684.     JackPropertyChangeCallback prop_change_cb;

  685.     JackThreadCallback proc_thread_cb;

  686. 

  687.     void* (*creator_func)(void*);

  688.     void* creator_arg;

  689.     HANDLE creator_handle;

  690.     pthread_t creator_pthread;

  691. 

  692.     WineBridge() noexcept

  693.         : ptr(nullptr),

  694.           latency_cb(nullptr),

  695.           process_cb(nullptr),

  696.           thread_init_cb(nullptr),

  697.           graph_order_cb(nullptr),

  698.           xrun_cb(nullptr),

  699.           bufsize_cb(nullptr),

  700.           srate_cb(nullptr),

  701.           port_reg_cb(nullptr),

  702.           client_reg_cb(nullptr),

  703.           port_conn_cb(nullptr),

  704.           port_rename_cb(nullptr),

  705.           freewheel_cb(nullptr),

  706.           shutdown_cb(nullptr),

  707.           info_shutdown_cb(nullptr),

  708.           sync_cb(nullptr),

  709.           timebase_cb(nullptr),

  710.           session_cb(nullptr),

  711.           prop_change_cb(nullptr),

  712.           proc_thread_cb(nullptr),

  713.           creator_func(nullptr),

  714.           creator_arg(nullptr),

  715.           creator_handle(nullptr),

  716.           creator_pthread(0) {}

  717. 

  718.     static WineBridge& getInstance() noexcept

  719.     {

  720.         static WineBridge bridge;

  721.         return bridge;

  722.     }

  723. 

  724.     void set_latency       (JackLatencyCallback            cb) noexcept { latency_cb       = cb; }

  725.     void set_process       (JackProcessCallback            cb) noexcept { process_cb       = cb; }

  726.     void set_thread_init   (JackThreadInitCallback         cb) noexcept { thread_init_cb   = cb; }

  727.     void set_graph_order   (JackGraphOrderCallback         cb) noexcept { graph_order_cb   = cb; }

  728.     void set_xrun          (JackXRunCallback               cb) noexcept { xrun_cb          = cb; }

  729.     void set_bufsize       (JackBufferSizeCallback         cb) noexcept { bufsize_cb       = cb; }

  730.     void set_srate         (JackSampleRateCallback         cb) noexcept { srate_cb         = cb; }

  731.     void set_port_reg      (JackPortRegistrationCallback   cb) noexcept { port_reg_cb      = cb; }

  732.     void set_client_reg    (JackClientRegistrationCallback cb) noexcept { client_reg_cb    = cb; }

  733.     void set_port_conn     (JackPortConnectCallback        cb) noexcept { port_conn_cb     = cb; }

  734.     void set_port_rename   (JackPortRenameCallback         cb) noexcept { port_rename_cb   = cb; }

  735.     void set_freewheel     (JackFreewheelCallback          cb) noexcept { freewheel_cb     = cb; }

  736.     void set_shutdown      (JackShutdownCallback           cb) noexcept { shutdown_cb      = cb; }

  737.     void set_info_shutdown (JackInfoShutdownCallback       cb) noexcept { info_shutdown_cb = cb; }

  738.     void set_sync          (JackSyncCallback               cb) noexcept { sync_cb          = cb; }

  739.     void set_timebase      (JackTimebaseCallback           cb) noexcept { timebase_cb      = cb; }

  740.     void set_session       (JackSessionCallback            cb) noexcept { session_cb       = cb; }

  741.     void set_prop_change   (JackPropertyChangeCallback     cb) noexcept { prop_change_cb   = cb; }

  742.     void set_process_thread(JackThreadCallback             cb) noexcept { proc_thread_cb   = cb; }

  743. 

  744.     static DWORD WINAPI thread_creator_helper(LPVOID)

  745.     {

  746.         WineBridge& inst(getInstance());

  747. 

  748.         inst.creator_pthread = pthread_self();

  749.         SetEvent(inst.creator_handle);

  750.         inst.creator_func(inst.creator_arg);

  751.         return 0;

  752.     }

  753. 

  754.     static int thread_creator(pthread_t* thread_id, const pthread_attr_t*, void *(*function)(void*), void* arg)

  755.     {

  756.         WineBridge& inst(getInstance());

  757. 

  758.         inst.creator_func   = function;

  759.         inst.creator_arg    = arg;

  760.         inst.creator_handle = ::CreateEventW(nullptr, false, false, nullptr);

  761. 

  762. #if 0

  763.         ::CreateThread(nullptr, 0, thread_creator_helper, arg, 0, nullptr);

  764. #else

  765.         HANDLE handle = ::CreateThread(nullptr, 0, thread_creator_helper, arg, CREATE_SUSPENDED, nullptr);

  766. 

  767.         if (handle == INVALID_HANDLE_VALUE)

  768.             return 1;

  769. 

  770.         // TODO read attrs and decide this

  771.         ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);

  772.         ::ResumeThread(handle);

  773. #endif

  774. 

  775.         ::WaitForSingleObject(inst.creator_handle, INFINITE);

  776.         *thread_id = inst.creator_pthread;

  777.         return 0;

  778.     }

  779. 

  780.     static void latency(jack_latency_callback_mode_t mode, void* arg)

  781.     {

  782.         return getInstance().latency_cb(mode, arg);

  783.     }

  784. 

  785.     static int process(jack_nframes_t nframes, void* arg)

  786.     {

  787.         return getInstance().process_cb(nframes, arg);

  788.     }

  789. 

  790.     static void thread_init(void* arg)

  791.     {

  792.         return getInstance().thread_init_cb(arg);

  793.     }

  794. 

  795.     static int graph_order(void* arg)

  796.     {

  797.         return getInstance().graph_order_cb(arg);

  798.     }

  799. 

  800.     static int xrun(void* arg)

  801.     {

  802.         return getInstance().xrun_cb(arg);

  803.     }

  804. 

  805.     static int bufsize(jack_nframes_t nframes, void* arg)

  806.     {

  807.         return getInstance().bufsize_cb(nframes, arg);

  808.     }

  809. 

  810.     static int srate(jack_nframes_t nframes, void* arg)

  811.     {

  812.         return getInstance().srate_cb(nframes, arg);

  813.     }

  814. 

  815.     static void port_reg(jack_port_id_t port, int register_, void* arg)

  816.     {

  817.         return getInstance().port_reg_cb(port, register_, arg);

  818.     }

  819. 

  820.     static void client_reg(const char* name, int register_, void* arg)

  821.     {

  822.         return getInstance().client_reg_cb(name, register_, arg);

  823.     }

  824. 

  825.     static void port_conn(jack_port_id_t a, jack_port_id_t b, int connect, void* arg)

  826.     {

  827.         return getInstance().port_conn_cb(a, b, connect, arg);

  828.     }

  829. 

  830.     static void port_rename(jack_port_id_t port, const char* old_name, const char* new_name, void* arg)

  831.     {

  832.         getInstance().port_rename_cb(port, old_name, new_name, arg);

  833.     }

  834. 

  835.     static void freewheel(int starting, void* arg)

  836.     {

  837.         return getInstance().freewheel_cb(starting, arg);

  838.     }

  839. 

  840.     static void shutdown(void* arg)

  841.     {

  842.         return getInstance().shutdown_cb(arg);

  843.     }

  844. 

  845.     static void info_shutdown(jack_status_t code, const char* reason, void* arg)

  846.     {

  847.         return getInstance().info_shutdown_cb(code, reason, arg);

  848.     }

  849. 

  850.     static int sync(jack_transport_state_t state, jack_position_t* pos, void* arg)

  851.     {

  852.         return getInstance().sync_cb(state, pos, arg);

  853.     }

  854. 

  855.     static void timebase(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg)

  856.     {

  857.         return getInstance().timebase_cb(state, nframes, pos, new_pos, arg);

  858.     }

  859. 

  860.     static void session(jack_session_event_t* event, void* arg)

  861.     {

  862.         return getInstance().session_cb(event, arg);

  863.     }

  864. 

  865.     static void prop_change(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg)

  866.     {

  867.         return getInstance().prop_change_cb(subject, key, change, arg);

  868.     }

  869. 

  870.     static void* process_thread(void* arg)

  871.     {

  872.         return getInstance().proc_thread_cb(arg);

  873.     }

  874. 

  875.     DISTRHO_DECLARE_NON_COPYABLE(WineBridge);

  876. };

  877. 

  878. #endif // __WINE__ && ! JACKBRIDGE_DIRECT

  879. 

  880. // --------------------------------------------------------------------------------------------------------------------

  881. 

  882. bool jackbridge_is_ok() noexcept

  883. {

  884. #if defined(JACKBRIDGE_DUMMY)

  885.     return false;

  886. #elif defined(JACKBRIDGE_DIRECT) || defined(DISTRHO_OS_WASM) || defined(RTAUDIO_API_TYPE)

  887.     return true;

  888. #else

  889.     return (getBridgeInstance().lib != nullptr);

  890. #endif

  891. }

  892. 

  893. void jackbridge_init()

  894. {

  895. #if defined(__WINE__) && !defined(JACKBRIDGE_DIRECT)

  896.     if (getBridgeInstance().set_thread_creator_ptr != nullptr)

  897.         getBridgeInstance().set_thread_creator_ptr(WineBridge::thread_creator);

  898. #endif

  899. }

  900. 

  901. // --------------------------------------------------------------------------------------------------------------------

  902. 

  903. void jackbridge_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr)

  904. {

  905. #if defined(JACKBRIDGE_DUMMY)

  906. #elif defined(JACKBRIDGE_DIRECT)

  907.     return jack_get_version(major_ptr, minor_ptr, micro_ptr, proto_ptr);

  908. #else

  909.     if (usingRealJACK && getBridgeInstance().get_version_ptr != nullptr)

  910.         return getBridgeInstance().get_version_ptr(major_ptr, minor_ptr, micro_ptr, proto_ptr);

  911. #endif

  912.     if (major_ptr != nullptr)

  913.         *major_ptr = 0;

  914.     if (minor_ptr != nullptr)

  915.         *minor_ptr = 0;

  916.     if (micro_ptr != nullptr)

  917.         *micro_ptr = 0;

  918.     if (proto_ptr != nullptr)

  919.         *proto_ptr = 0;

  920. }

  921. 

  922. const char* jackbridge_get_version_string()

  923. {

  924. #if defined(JACKBRIDGE_DUMMY)

  925. #elif defined(JACKBRIDGE_DIRECT)

  926.     return jack_get_version_string();

  927. #else

  928.     if (usingRealJACK && getBridgeInstance().get_version_string_ptr != nullptr)

  929.         return getBridgeInstance().get_version_string_ptr();

  930. #endif

  931.     return nullptr;

  932. }

  933. 

  934. // --------------------------------------------------------------------------------------------------------------------

  935. 

  936. jack_client_t* jackbridge_client_open(const char* client_name, uint32_t options, jack_status_t* status)

  937. {

  938. #if defined(JACKBRIDGE_DUMMY)

  939. #elif defined(JACKBRIDGE_DIRECT)

  940.     return jack_client_open(client_name, static_cast<jack_options_t>(options), status);

  941. #else

  942.    #ifndef DISTRHO_OS_WASM

  943.     if (getBridgeInstance().client_open_ptr != nullptr)

  944.         if (jack_client_t* const client = getBridgeInstance().client_open_ptr(client_name, static_cast<jack_options_t>(options), status))

  945.             return client;

  946.    #endif

  947. 

  948.     static jack_client_t* const kValidClient = (jack_client_t*)0x1;

  949. 

  950.     // maybe unused

  951.     (void)kValidClient;

  952. 

  953.     usingNativeBridge = true;

  954.     usingRealJACK = false;

  955. 

  956.    #ifdef DISTRHO_OS_WASM

  957.     nativeBridge = new WebBridge;

  958.     if (nativeBridge->open(client_name))

  959.         return kValidClient;

  960.     delete nativeBridge;

  961.    #endif

  962. 

  963.    #if defined(HAVE_RTAUDIO) && defined(RTAUDIO_API_TYPE)

  964.     nativeBridge = new RtAudioBridge;

  965.     if (nativeBridge->open(client_name))

  966.         return kValidClient;

  967.     delete nativeBridge;

  968.    #endif

  969. 

  970.    #if defined(HAVE_SDL2) && DISTRHO_PLUGIN_NUM_INPUTS+DISTRHO_PLUGIN_NUM_OUTPUTS > 0

  971.     nativeBridge = new SDL2Bridge;

  972.     if (nativeBridge->open(client_name))

  973.         return kValidClient;

  974.     delete nativeBridge;

  975.    #endif

  976. #endif

  977. 

  978.     if (status != nullptr)

  979.     {

  980.         int err = JackServerError;

  981. 

  982.        #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  983.         if (nativeBridge != nullptr)

  984.         {

  985.             err

  986.             #ifdef HAVE_JACK

  987.              |=

  988.             #else

  989.              =

  990.             #endif

  991.             JackBridgeNativeFailed;

  992.         }

  993.        #endif

  994. 

  995.         *status = static_cast<jack_status_t>(err);

  996.     }

  997. 

  998.     return nullptr;

  999. }

  1000. 

  1001. bool jackbridge_client_close(jack_client_t* client)

  1002. {

  1003. #if defined(JACKBRIDGE_DUMMY)

  1004. #elif defined(JACKBRIDGE_DIRECT)

  1005.     return (jack_client_close(client) == 0);

  1006. #else

  1007.     if (usingNativeBridge)

  1008.     {

  1009.         if (nativeBridge != nullptr)

  1010.         {

  1011.             nativeBridge->close();

  1012.             delete nativeBridge;

  1013.             nativeBridge = nullptr;

  1014.         }

  1015.         usingNativeBridge = false;

  1016.         usingRealJACK = true;

  1017.         return true;

  1018.     }

  1019.     if (getBridgeInstance().client_close_ptr != nullptr)

  1020.         return (getBridgeInstance().client_close_ptr(client) == 0);

  1021. #endif

  1022.     return false;

  1023. }

  1024. 

  1025. // --------------------------------------------------------------------------------------------------------------------

  1026. 

  1027. int jackbridge_client_name_size()

  1028. {

  1029. #if defined(JACKBRIDGE_DUMMY)

  1030. #elif defined(JACKBRIDGE_DIRECT)

  1031.     return jack_client_name_size();

  1032. #else

  1033.     if (usingRealJACK && getBridgeInstance().client_name_size_ptr != nullptr)

  1034.         return getBridgeInstance().client_name_size_ptr();

  1035. #endif

  1036.     return 33;

  1037. }

  1038. 

  1039. const char* jackbridge_get_client_name(jack_client_t* client)

  1040. {

  1041. #if defined(JACKBRIDGE_DUMMY)

  1042. #elif defined(JACKBRIDGE_DIRECT)

  1043.     return jack_get_client_name(client);

  1044. #else

  1045.     if (usingNativeBridge)

  1046.         return DISTRHO_PLUGIN_NAME;

  1047.     if (getBridgeInstance().get_client_name_ptr != nullptr)

  1048.         return getBridgeInstance().get_client_name_ptr(client);

  1049. #endif

  1050.     return nullptr;

  1051. }

  1052. 

  1053. // --------------------------------------------------------------------------------------------------------------------

  1054. 

  1055. char* jackbridge_client_get_uuid(jack_client_t* client)

  1056. {

  1057. #if defined(JACKBRIDGE_DUMMY)

  1058. #elif defined(JACKBRIDGE_DIRECT)

  1059.     return jack_client_get_uuid(client);

  1060. #else

  1061.     if (usingRealJACK)

  1062.         if (const jacksym_client_get_uuid func = getBridgeInstance().client_get_uuid_ptr)

  1063.             return func(client);

  1064. #endif

  1065.     return nullptr;

  1066. }

  1067. 

  1068. char* jackbridge_get_uuid_for_client_name(jack_client_t* client, const char* name)

  1069. {

  1070. #if defined(JACKBRIDGE_DUMMY)

  1071. #elif defined(JACKBRIDGE_DIRECT)

  1072.     return jack_get_uuid_for_client_name(client, name);

  1073. #else

  1074.     if (usingRealJACK)

  1075.         if (getBridgeInstance().get_uuid_for_client_name_ptr != nullptr)

  1076.             return getBridgeInstance().get_uuid_for_client_name_ptr(client, name);

  1077. #endif

  1078.     return nullptr;

  1079. }

  1080. 

  1081. char* jackbridge_get_client_name_by_uuid(jack_client_t* client, const char* uuid)

  1082. {

  1083. #if defined(JACKBRIDGE_DUMMY)

  1084. #elif defined(JACKBRIDGE_DIRECT)

  1085.     return jack_get_client_name_by_uuid(client, uuid);

  1086. #else

  1087.     if (usingRealJACK)

  1088.         if (getBridgeInstance().get_client_name_by_uuid_ptr != nullptr)

  1089.             return getBridgeInstance().get_client_name_by_uuid_ptr(client, uuid);

  1090. #endif

  1091.     return nullptr;

  1092. }

  1093. 

  1094. // --------------------------------------------------------------------------------------------------------------------

  1095. 

  1096. bool jackbridge_uuid_parse(const char* buf, jack_uuid_t* uuid)

  1097. {

  1098. #if defined(JACKBRIDGE_DUMMY)

  1099. #elif defined(JACKBRIDGE_DIRECT)

  1100.     return (jack_uuid_parse(buf, uuid) == 0);

  1101. #else

  1102.     if (usingRealJACK)

  1103.         if (const jacksym_uuid_parse func = getBridgeInstance().uuid_parse_ptr)

  1104.             return (func(buf, uuid) == 0);

  1105. #endif

  1106.     return false;

  1107. }

  1108. 

  1109. void jackbridge_uuid_unparse(jack_uuid_t uuid, char buf[JACK_UUID_STRING_SIZE])

  1110. {

  1111. #if defined(JACKBRIDGE_DUMMY)

  1112. #elif defined(JACKBRIDGE_DIRECT)

  1113.     jack_uuid_unparse(uuid, buf);

  1114. #else

  1115.     if (usingRealJACK)

  1116.         if (const jacksym_uuid_unparse func = getBridgeInstance().uuid_unparse_ptr)

  1117.             return func(uuid, buf);

  1118. #endif

  1119. }

  1120. 

  1121. // --------------------------------------------------------------------------------------------------------------------

  1122. 

  1123. bool jackbridge_activate(jack_client_t* client)

  1124. {

  1125. #if defined(JACKBRIDGE_DUMMY)

  1126. #elif defined(JACKBRIDGE_DIRECT)

  1127.     return (jack_activate(client) == 0);

  1128. #else

  1129.     if (usingNativeBridge)

  1130.         return nativeBridge->activate();

  1131.     if (getBridgeInstance().activate_ptr != nullptr)

  1132.         return (getBridgeInstance().activate_ptr(client) == 0);

  1133. #endif

  1134.     return false;

  1135. }

  1136. 

  1137. bool jackbridge_deactivate(jack_client_t* client)

  1138. {

  1139. #if defined(JACKBRIDGE_DUMMY)

  1140. #elif defined(JACKBRIDGE_DIRECT)

  1141.     return (jack_deactivate(client) == 0);

  1142. #else

  1143.     if (usingNativeBridge)

  1144.         return nativeBridge->deactivate();

  1145.     if (getBridgeInstance().deactivate_ptr != nullptr)

  1146.         return (getBridgeInstance().deactivate_ptr(client) == 0);

  1147. #endif

  1148.     return false;

  1149. }

  1150. 

  1151. bool jackbridge_is_realtime(jack_client_t* client)

  1152. {

  1153. #if defined(JACKBRIDGE_DUMMY)

  1154. #elif defined(JACKBRIDGE_DIRECT)

  1155.     return jack_is_realtime(client);

  1156. #else

  1157.     if (usingRealJACK)

  1158.         if (getBridgeInstance().is_realtime_ptr != nullptr)

  1159.             return getBridgeInstance().is_realtime_ptr(client);

  1160. #endif

  1161.     return false;

  1162. }

  1163. 

  1164. // --------------------------------------------------------------------------------------------------------------------

  1165. 

  1166. bool jackbridge_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback thread_init_callback, void* arg)

  1167. {

  1168. #if defined(JACKBRIDGE_DUMMY)

  1169. #elif defined(JACKBRIDGE_DIRECT)

  1170.     return (jack_set_thread_init_callback(client, thread_init_callback, arg) == 0);

  1171. #else

  1172.     if (usingRealJACK && getBridgeInstance().set_thread_init_callback_ptr != nullptr)

  1173.     {

  1174. # ifdef __WINE__

  1175.         WineBridge::getInstance().set_thread_init(thread_init_callback);

  1176.         return (getBridgeInstance().set_thread_init_callback_ptr(client, WineBridge::thread_init, arg) == 0);

  1177. # else

  1178.         return (getBridgeInstance().set_thread_init_callback_ptr(client, thread_init_callback, arg) == 0);

  1179. # endif

  1180.     }

  1181. #endif

  1182.     return false;

  1183. }

  1184. 

  1185. void jackbridge_on_shutdown(jack_client_t* client, JackShutdownCallback shutdown_callback, void* arg)

  1186. {

  1187. #if defined(JACKBRIDGE_DUMMY)

  1188. #elif defined(JACKBRIDGE_DIRECT)

  1189.     jack_on_shutdown(client, shutdown_callback, arg);

  1190. #else

  1191.     if (usingRealJACK && getBridgeInstance().on_shutdown_ptr != nullptr)

  1192.     {

  1193. # ifdef __WINE__

  1194.         WineBridge::getInstance().set_shutdown(shutdown_callback);

  1195.         getBridgeInstance().on_shutdown_ptr(client, WineBridge::shutdown, arg);

  1196. # else

  1197.         getBridgeInstance().on_shutdown_ptr(client, shutdown_callback, arg);

  1198. # endif

  1199.     }

  1200. #endif

  1201. }

  1202. 

  1203. void jackbridge_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback shutdown_callback, void* arg)

  1204. {

  1205. #if defined(JACKBRIDGE_DUMMY)

  1206. #elif defined(JACKBRIDGE_DIRECT)

  1207.     jack_on_info_shutdown(client, shutdown_callback, arg);

  1208. #else

  1209.     if (usingRealJACK && getBridgeInstance().on_info_shutdown_ptr != nullptr)

  1210.     {

  1211. # ifdef __WINE__

  1212.         WineBridge::getInstance().set_info_shutdown(shutdown_callback);

  1213.         getBridgeInstance().on_info_shutdown_ptr(client, WineBridge::info_shutdown, arg);

  1214. # else

  1215.         getBridgeInstance().on_info_shutdown_ptr(client, shutdown_callback, arg);

  1216. # endif

  1217.     }

  1218. #endif

  1219. }

  1220. 

  1221. bool jackbridge_set_process_callback(jack_client_t* client, JackProcessCallback process_callback, void* arg)

  1222. {

  1223. #if defined(JACKBRIDGE_DUMMY)

  1224. #elif defined(JACKBRIDGE_DIRECT)

  1225.     return (jack_set_process_callback(client, process_callback, arg) == 0);

  1226. #else

  1227.     if (usingNativeBridge)

  1228.     {

  1229.         nativeBridge->jackProcessCallback = process_callback;

  1230.         nativeBridge->jackProcessArg = arg;

  1231.         return true;

  1232.     }

  1233.     if (getBridgeInstance().set_process_callback_ptr != nullptr)

  1234.     {

  1235. # ifdef __WINE__

  1236.         WineBridge::getInstance().set_process(process_callback);

  1237.         return (getBridgeInstance().set_process_callback_ptr(client, WineBridge::process, arg) == 0);

  1238. # else

  1239.         return (getBridgeInstance().set_process_callback_ptr(client, process_callback, arg) == 0);

  1240. # endif

  1241.     }

  1242. #endif

  1243.     return false;

  1244. }

  1245. 

  1246. bool jackbridge_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback freewheel_callback, void* arg)

  1247. {

  1248. #if defined(JACKBRIDGE_DUMMY)

  1249. #elif defined(JACKBRIDGE_DIRECT)

  1250.     return (jack_set_freewheel_callback(client, freewheel_callback, arg) == 0);

  1251. #else

  1252.     if (usingRealJACK && getBridgeInstance().set_freewheel_callback_ptr != nullptr)

  1253.     {

  1254. # ifdef __WINE__

  1255.         WineBridge::getInstance().set_freewheel(freewheel_callback);

  1256.         return (getBridgeInstance().set_freewheel_callback_ptr(client, WineBridge::freewheel, arg) == 0);

  1257. # else

  1258.         return (getBridgeInstance().set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);

  1259. # endif

  1260.     }

  1261. #endif

  1262.     return false;

  1263. }

  1264. 

  1265. bool jackbridge_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback bufsize_callback, void* arg)

  1266. {

  1267. #if defined(JACKBRIDGE_DUMMY)

  1268. #elif defined(JACKBRIDGE_DIRECT)

  1269.     return (jack_set_buffer_size_callback(client, bufsize_callback, arg) == 0);

  1270. #else

  1271.     if (usingNativeBridge)

  1272.     {

  1273.         nativeBridge->bufferSizeCallback = bufsize_callback;

  1274.         nativeBridge->jackBufferSizeArg = arg;

  1275.         return true;

  1276.     }

  1277.     if (getBridgeInstance().set_buffer_size_callback_ptr != nullptr)

  1278.     {

  1279. # ifdef __WINE__

  1280.         WineBridge::getInstance().set_bufsize(bufsize_callback);

  1281.         return (getBridgeInstance().set_buffer_size_callback_ptr(client, WineBridge::bufsize, arg) == 0);

  1282. # else

  1283.         return (getBridgeInstance().set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);

  1284. # endif

  1285.     }

  1286. #endif

  1287.     return false;

  1288. }

  1289. 

  1290. bool jackbridge_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback srate_callback, void* arg)

  1291. {

  1292. #if defined(JACKBRIDGE_DUMMY)

  1293. #elif defined(JACKBRIDGE_DIRECT)

  1294.     return (jack_set_sample_rate_callback(client, srate_callback, arg) == 0);

  1295. #else

  1296.     if (usingRealJACK && getBridgeInstance().set_sample_rate_callback_ptr != nullptr)

  1297.     {

  1298. # ifdef __WINE__

  1299.         WineBridge::getInstance().set_srate(srate_callback);

  1300.         return (getBridgeInstance().set_sample_rate_callback_ptr(client, WineBridge::srate, arg) == 0);

  1301. # else

  1302.         return (getBridgeInstance().set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);

  1303. # endif

  1304.     }

  1305. #endif

  1306.     return false;

  1307. }

  1308. 

  1309. bool jackbridge_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback registration_callback, void* arg)

  1310. {

  1311. #if defined(JACKBRIDGE_DUMMY)

  1312. #elif defined(JACKBRIDGE_DIRECT)

  1313.     return (jack_set_client_registration_callback(client, registration_callback, arg) == 0);

  1314. #else

  1315.     if (usingRealJACK && getBridgeInstance().set_client_registration_callback_ptr != nullptr)

  1316.     {

  1317. # ifdef __WINE__

  1318.         WineBridge::getInstance().set_client_reg(registration_callback);

  1319.         return (getBridgeInstance().set_client_registration_callback_ptr(client, WineBridge::client_reg, arg) == 0);

  1320. # else

  1321.         return (getBridgeInstance().set_client_registration_callback_ptr(client, registration_callback, arg) == 0);

  1322. # endif

  1323.     }

  1324. #endif

  1325.     return false;

  1326. }

  1327. 

  1328. bool jackbridge_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback registration_callback, void *arg)

  1329. {

  1330. #if defined(JACKBRIDGE_DUMMY)

  1331. #elif defined(JACKBRIDGE_DIRECT)

  1332.     return (jack_set_port_registration_callback(client, registration_callback, arg) == 0);

  1333. #else

  1334.     if (usingRealJACK && getBridgeInstance().set_port_registration_callback_ptr != nullptr)

  1335.     {

  1336. # ifdef __WINE__

  1337.         WineBridge::getInstance().set_port_reg(registration_callback);

  1338.         return (getBridgeInstance().set_port_registration_callback_ptr(client, WineBridge::port_reg, arg) == 0);

  1339. # else

  1340.         return (getBridgeInstance().set_port_registration_callback_ptr(client, registration_callback, arg) == 0);

  1341. # endif

  1342.     }

  1343. #endif

  1344.     return false;

  1345. }

  1346. 

  1347. bool jackbridge_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback rename_callback, void* arg)

  1348. {

  1349. #if defined(JACKBRIDGE_DUMMY)

  1350. #elif defined(JACKBRIDGE_DIRECT)

  1351.     return (jack_set_port_rename_callback(client, rename_callback, arg) == 0);

  1352. #else

  1353.     if (usingRealJACK && getBridgeInstance().set_port_rename_callback_ptr != nullptr)

  1354.     {

  1355. # ifdef __WINE__

  1356.         WineBridge::getInstance().set_port_rename(rename_callback);

  1357.         return (getBridgeInstance().set_port_rename_callback_ptr(client, WineBridge::port_rename, arg) == 0);

  1358. # else

  1359.         return (getBridgeInstance().set_port_rename_callback_ptr(client, rename_callback, arg) == 0);

  1360. # endif

  1361.     }

  1362. #endif

  1363.     return false;

  1364. }

  1365. 

  1366. bool jackbridge_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback connect_callback, void* arg)

  1367. {

  1368. #if defined(JACKBRIDGE_DUMMY)

  1369. #elif defined(JACKBRIDGE_DIRECT)

  1370.     return (jack_set_port_connect_callback(client, connect_callback, arg) == 0);

  1371. #else

  1372.     if (usingRealJACK && getBridgeInstance().set_port_connect_callback_ptr != nullptr)

  1373.     {

  1374. # ifdef __WINE__

  1375.         WineBridge::getInstance().set_port_conn(connect_callback);

  1376.         return (getBridgeInstance().set_port_connect_callback_ptr(client, WineBridge::port_conn, arg) == 0);

  1377. # else

  1378.         return (getBridgeInstance().set_port_connect_callback_ptr(client, connect_callback, arg) == 0);

  1379. # endif

  1380.     }

  1381. #endif

  1382.     return false;

  1383. }

  1384. 

  1385. bool jackbridge_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback graph_callback, void* arg)

  1386. {

  1387. #if defined(JACKBRIDGE_DUMMY)

  1388. #elif defined(JACKBRIDGE_DIRECT)

  1389.     return (jack_set_graph_order_callback(client, graph_callback, arg) == 0);

  1390. #else

  1391.     if (usingRealJACK && getBridgeInstance().set_graph_order_callback_ptr != nullptr)

  1392.     {

  1393. # ifdef __WINE__

  1394.         WineBridge::getInstance().set_graph_order(graph_callback);

  1395.         return (getBridgeInstance().set_graph_order_callback_ptr(client, WineBridge::graph_order, arg) == 0);

  1396. # else

  1397.         return (getBridgeInstance().set_graph_order_callback_ptr(client, graph_callback, arg) == 0);

  1398. # endif

  1399.     }

  1400. #endif

  1401.     return false;

  1402. }

  1403. 

  1404. bool jackbridge_set_xrun_callback(jack_client_t* client, JackXRunCallback xrun_callback, void* arg)

  1405. {

  1406. #if defined(JACKBRIDGE_DUMMY)

  1407. #elif defined(JACKBRIDGE_DIRECT)

  1408.     return (jack_set_xrun_callback(client, xrun_callback, arg) == 0);

  1409. #else

  1410.     if (usingRealJACK && getBridgeInstance().set_xrun_callback_ptr != nullptr)

  1411.     {

  1412. # ifdef __WINE__

  1413.         WineBridge::getInstance().set_xrun(xrun_callback);

  1414.         return (getBridgeInstance().set_xrun_callback_ptr(client, WineBridge::xrun, arg) == 0);

  1415. # else

  1416.         return (getBridgeInstance().set_xrun_callback_ptr(client, xrun_callback, arg) == 0);

  1417. # endif

  1418.     }

  1419. #endif

  1420.     return false;

  1421. }

  1422. 

  1423. bool jackbridge_set_latency_callback(jack_client_t* client, JackLatencyCallback latency_callback, void* arg)

  1424. {

  1425. #if defined(JACKBRIDGE_DUMMY)

  1426. #elif defined(JACKBRIDGE_DIRECT)

  1427.     return (jack_set_latency_callback(client, latency_callback, arg) == 0);

  1428. #else

  1429.     if (usingRealJACK && getBridgeInstance().set_latency_callback_ptr != nullptr)

  1430.     {

  1431. # ifdef __WINE__

  1432.         WineBridge::getInstance().set_latency(latency_callback);

  1433.         return (getBridgeInstance().set_latency_callback_ptr(client, WineBridge::latency, arg) == 0);

  1434. # else

  1435.         return (getBridgeInstance().set_latency_callback_ptr(client, latency_callback, arg) == 0);

  1436. # endif

  1437.     }

  1438. #endif

  1439.     return false;

  1440. }

  1441. 

  1442. // --------------------------------------------------------------------------------------------------------------------

  1443. 

  1444. bool jackbridge_set_freewheel(jack_client_t* client, bool onoff)

  1445. {

  1446. #if defined(JACKBRIDGE_DUMMY)

  1447. #elif defined(JACKBRIDGE_DIRECT)

  1448.     return jack_set_freewheel(client, onoff);

  1449. #else

  1450.     if (usingRealJACK)

  1451.         if (getBridgeInstance().set_freewheel_ptr != nullptr)

  1452.             return getBridgeInstance().set_freewheel_ptr(client, onoff);

  1453. #endif

  1454.     return false;

  1455. }

  1456. 

  1457. bool jackbridge_set_buffer_size(jack_client_t* client, jack_nframes_t nframes)

  1458. {

  1459. #if defined(JACKBRIDGE_DUMMY)

  1460. #elif defined(JACKBRIDGE_DIRECT)

  1461.     return jack_set_buffer_size(client, nframes);

  1462. #else

  1463.     if (usingNativeBridge)

  1464.         return nativeBridge->requestBufferSizeChange(nframes);

  1465.     if (getBridgeInstance().set_buffer_size_ptr != nullptr)

  1466.         return getBridgeInstance().set_buffer_size_ptr(client, nframes);

  1467. #endif

  1468.     return false;

  1469. }

  1470. 

  1471. // --------------------------------------------------------------------------------------------------------------------

  1472. 

  1473. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1474. {

  1475. #if defined(JACKBRIDGE_DUMMY)

  1476. #elif defined(JACKBRIDGE_DIRECT)

  1477.     return jack_get_sample_rate(client);

  1478. #else

  1479.     if (usingNativeBridge)

  1480.         return nativeBridge->sampleRate;

  1481.     if (getBridgeInstance().get_sample_rate_ptr != nullptr)

  1482.         return getBridgeInstance().get_sample_rate_ptr(client);

  1483. #endif

  1484.     return 0;

  1485. }

  1486. 

  1487. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1488. {

  1489. #if defined(JACKBRIDGE_DUMMY)

  1490. #elif defined(JACKBRIDGE_DIRECT)

  1491.     return jack_get_buffer_size(client);

  1492. #else

  1493.     if (usingNativeBridge)

  1494.         return nativeBridge->bufferSize;

  1495.     if (getBridgeInstance().get_buffer_size_ptr != nullptr)

  1496.         return getBridgeInstance().get_buffer_size_ptr(client);

  1497. #endif

  1498.     return 0;

  1499. }

  1500. 

  1501. float jackbridge_cpu_load(jack_client_t* client)

  1502. {

  1503. #if defined(JACKBRIDGE_DUMMY)

  1504. #elif defined(JACKBRIDGE_DIRECT)

  1505.     return jack_cpu_load(client);

  1506. #else

  1507.     if (usingRealJACK)

  1508.         if (getBridgeInstance().cpu_load_ptr != nullptr)

  1509.             return getBridgeInstance().cpu_load_ptr(client);

  1510. #endif

  1511.     return 0.0f;

  1512. }

  1513. 

  1514. // --------------------------------------------------------------------------------------------------------------------

  1515. 

  1516. jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* type, uint64_t flags, uint64_t buffer_size)

  1517. {

  1518. #if defined(JACKBRIDGE_DUMMY)

  1519. #elif defined(JACKBRIDGE_DIRECT)

  1520.     return jack_port_register(client, port_name, type, flags, buffer_size);

  1521. #else

  1522.     if (usingNativeBridge)

  1523.         return nativeBridge->registerPort(type, flags);

  1524.     if (getBridgeInstance().port_register_ptr != nullptr)

  1525.         return getBridgeInstance().port_register_ptr(client, port_name, type,

  1526.                                                      static_cast<ulong>(flags),

  1527.                                                      static_cast<ulong>(buffer_size));

  1528. #endif

  1529.     return nullptr;

  1530. }

  1531. 

  1532. bool jackbridge_port_unregister(jack_client_t* client, jack_port_t* port)

  1533. {

  1534. #if defined(JACKBRIDGE_DUMMY)

  1535. #elif defined(JACKBRIDGE_DIRECT)

  1536.     return (jack_port_unregister(client, port) == 0);

  1537. #else

  1538.     if (usingRealJACK)

  1539.         if (getBridgeInstance().port_unregister_ptr != nullptr)

  1540.             return (getBridgeInstance().port_unregister_ptr(client, port) == 0);

  1541. #endif

  1542.     return false;

  1543. }

  1544. 

  1545. void* jackbridge_port_get_buffer(jack_port_t* port, jack_nframes_t nframes)

  1546. {

  1547. #if defined(JACKBRIDGE_DUMMY)

  1548. #elif defined(JACKBRIDGE_DIRECT)

  1549.     return jack_port_get_buffer(port, nframes);

  1550. #else

  1551.     if (usingNativeBridge)

  1552.         return nativeBridge->getPortBuffer(port);

  1553.     if (getBridgeInstance().port_get_buffer_ptr != nullptr)

  1554.         return getBridgeInstance().port_get_buffer_ptr(port, nframes);

  1555. #endif

  1556.     return nullptr;

  1557. }

  1558. 

  1559. // --------------------------------------------------------------------------------------------------------------------

  1560. 

  1561. const char* jackbridge_port_name(const jack_port_t* port)

  1562. {

  1563. #if defined(JACKBRIDGE_DUMMY)

  1564. #elif defined(JACKBRIDGE_DIRECT)

  1565.     return jack_port_name(port);

  1566. #else

  1567.     if (usingRealJACK)

  1568.         if (getBridgeInstance().port_name_ptr != nullptr)

  1569.             return getBridgeInstance().port_name_ptr(port);

  1570. #endif

  1571.     return nullptr;

  1572. }

  1573. 

  1574. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1575. {

  1576. #if defined(JACKBRIDGE_DUMMY)

  1577. #elif defined(JACKBRIDGE_DIRECT)

  1578.     return jack_port_uuid(port);

  1579. #else

  1580.     if (usingRealJACK)

  1581.         if (getBridgeInstance().port_uuid_ptr != nullptr)

  1582.             return getBridgeInstance().port_uuid_ptr(port);

  1583. #endif

  1584.     return 0;

  1585. }

  1586. 

  1587. const char* jackbridge_port_short_name(const jack_port_t* port)

  1588. {

  1589. #if defined(JACKBRIDGE_DUMMY)

  1590. #elif defined(JACKBRIDGE_DIRECT)

  1591.     return jack_port_short_name(port);

  1592. #else

  1593.     if (usingRealJACK)

  1594.         if (getBridgeInstance().port_short_name_ptr != nullptr)

  1595.             return getBridgeInstance().port_short_name_ptr(port);

  1596. #endif

  1597.     return nullptr;

  1598. }

  1599. 

  1600. int jackbridge_port_flags(const jack_port_t* port)

  1601. {

  1602. #if defined(JACKBRIDGE_DUMMY)

  1603. #elif defined(JACKBRIDGE_DIRECT)

  1604.     return jack_port_flags(port);

  1605. #else

  1606.     if (usingRealJACK)

  1607.         if (getBridgeInstance().port_flags_ptr != nullptr)

  1608.             return getBridgeInstance().port_flags_ptr(port);

  1609. #endif

  1610.     return 0x0;

  1611. }

  1612. 

  1613. const char* jackbridge_port_type(const jack_port_t* port)

  1614. {

  1615. #if defined(JACKBRIDGE_DUMMY)

  1616. #elif defined(JACKBRIDGE_DIRECT)

  1617.     return jack_port_type(port);

  1618. #else

  1619.     if (usingRealJACK)

  1620.         if (getBridgeInstance().port_type_ptr != nullptr)

  1621.             return getBridgeInstance().port_type_ptr(port);

  1622. #endif

  1623.     return nullptr;

  1624. }

  1625. 

  1626. bool jackbridge_port_is_mine(const jack_client_t* client, const jack_port_t* port)

  1627. {

  1628. #if defined(JACKBRIDGE_DUMMY)

  1629. #elif defined(JACKBRIDGE_DIRECT)

  1630.     return jack_port_is_mine(client, port);

  1631. #else

  1632.     if (usingRealJACK)

  1633.         if (getBridgeInstance().port_is_mine_ptr != nullptr)

  1634.             return getBridgeInstance().port_is_mine_ptr(client, port);

  1635. #endif

  1636.     return false;

  1637. }

  1638. 

  1639. int jackbridge_port_connected(const jack_port_t* port)

  1640. {

  1641. #if defined(JACKBRIDGE_DUMMY)

  1642. #elif defined(JACKBRIDGE_DIRECT)

  1643.     return jack_port_connected(port);

  1644. #else

  1645.     if (usingRealJACK)

  1646.         if (getBridgeInstance().port_connected_ptr != nullptr)

  1647.             return getBridgeInstance().port_connected_ptr(port);

  1648. #endif

  1649.     return 0;

  1650. }

  1651. 

  1652. bool jackbridge_port_connected_to(const jack_port_t* port, const char* port_name)

  1653. {

  1654. #if defined(JACKBRIDGE_DUMMY)

  1655. #elif defined(JACKBRIDGE_DIRECT)

  1656.     return jack_port_connected_to(port, port_name);

  1657. #else

  1658.     if (usingRealJACK)

  1659.         if (getBridgeInstance().port_connected_to_ptr != nullptr)

  1660.             return getBridgeInstance().port_connected_to_ptr(port, port_name);

  1661. #endif

  1662.     return false;

  1663. }

  1664. 

  1665. const char** jackbridge_port_get_connections(const jack_port_t* port)

  1666. {

  1667. #if defined(JACKBRIDGE_DUMMY)

  1668. #elif defined(JACKBRIDGE_DIRECT)

  1669.     return jack_port_get_connections(port);

  1670. #else

  1671.     if (usingRealJACK)

  1672.         if (getBridgeInstance().port_get_connections_ptr != nullptr)

  1673.             return getBridgeInstance().port_get_connections_ptr(port);

  1674. #endif

  1675.     return nullptr;

  1676. }

  1677. 

  1678. const char** jackbridge_port_get_all_connections(const jack_client_t* client, const jack_port_t* port)

  1679. {

  1680. #if defined(JACKBRIDGE_DUMMY)

  1681. #elif defined(JACKBRIDGE_DIRECT)

  1682.     return jack_port_get_all_connections(client, port);

  1683. #else

  1684.     if (usingRealJACK)

  1685.         if (getBridgeInstance().port_get_all_connections_ptr != nullptr)

  1686.             return getBridgeInstance().port_get_all_connections_ptr(client, port);

  1687. #endif

  1688.     return nullptr;

  1689. }

  1690. 

  1691. // --------------------------------------------------------------------------------------------------------------------

  1692. 

  1693. bool jackbridge_port_rename(jack_client_t* client, jack_port_t* port, const char* port_name)

  1694. {

  1695. #if defined(JACKBRIDGE_DUMMY)

  1696. #elif defined(JACKBRIDGE_DIRECT)

  1697.     return (jack_port_rename(client, port, port_name) == 0);

  1698. #else

  1699.     if (usingNativeBridge)

  1700.         return false;

  1701.     // Try new API first

  1702.     if (getBridgeInstance().port_rename_ptr != nullptr)

  1703.         return (getBridgeInstance().port_rename_ptr(client, port, port_name) == 0);

  1704.     // Try old API if using JACK2

  1705.     if (getBridgeInstance().get_version_string_ptr != nullptr && getBridgeInstance().port_set_name_ptr != nullptr)

  1706.         return (getBridgeInstance().port_set_name_ptr(port, port_name) == 0);

  1707. #endif

  1708.     return false;

  1709. }

  1710. 

  1711. bool jackbridge_port_set_alias(jack_port_t* port, const char* alias)

  1712. {

  1713. #if defined(JACKBRIDGE_DUMMY)

  1714. #elif defined(JACKBRIDGE_DIRECT)

  1715.     return (jack_port_set_alias(port, alias) == 0);

  1716. #else

  1717.     if (usingRealJACK)

  1718.         if (getBridgeInstance().port_set_alias_ptr != nullptr)

  1719.             return (getBridgeInstance().port_set_alias_ptr(port, alias) == 0);

  1720. #endif

  1721.     return false;

  1722. }

  1723. 

  1724. bool jackbridge_port_unset_alias(jack_port_t* port, const char* alias)

  1725. {

  1726. #if defined(JACKBRIDGE_DUMMY)

  1727. #elif defined(JACKBRIDGE_DIRECT)

  1728.     return (jack_port_unset_alias(port, alias) == 0);

  1729. #else

  1730.     if (usingRealJACK)

  1731.         if (getBridgeInstance().port_unset_alias_ptr != nullptr)

  1732.             return (getBridgeInstance().port_unset_alias_ptr(port, alias) == 0);

  1733. #endif

  1734.     return false;

  1735. }

  1736. 

  1737. int jackbridge_port_get_aliases(const jack_port_t* port, char* const aliases[2])

  1738. {

  1739. #if defined(JACKBRIDGE_DUMMY)

  1740. #elif defined(JACKBRIDGE_DIRECT)

  1741.     return (jack_port_get_aliases(port, aliases) == 0);

  1742. #else

  1743.     if (usingRealJACK)

  1744.         if (getBridgeInstance().port_get_aliases_ptr != nullptr)

  1745.             return getBridgeInstance().port_get_aliases_ptr(port, aliases);

  1746. #endif

  1747.     return 0;

  1748. }

  1749. 

  1750. // --------------------------------------------------------------------------------------------------------------------

  1751. 

  1752. bool jackbridge_port_request_monitor(jack_port_t* port, bool onoff)

  1753. {

  1754. #if defined(JACKBRIDGE_DUMMY)

  1755. #elif defined(JACKBRIDGE_DIRECT)

  1756.     return (jack_port_request_monitor(port, onoff) == 0);

  1757. #else

  1758.     if (usingRealJACK)

  1759.         if (getBridgeInstance().port_request_monitor_ptr != nullptr)

  1760.             return (getBridgeInstance().port_request_monitor_ptr(port, onoff) == 0);

  1761. #endif

  1762.     return false;

  1763. }

  1764. 

  1765. bool jackbridge_port_request_monitor_by_name(jack_client_t* client, const char* port_name, bool onoff)

  1766. {

  1767. #if defined(JACKBRIDGE_DUMMY)

  1768. #elif defined(JACKBRIDGE_DIRECT)

  1769.     return (jack_port_request_monitor_by_name(client, port_name, onoff) == 0);

  1770. #else

  1771.     if (usingRealJACK)

  1772.         if (getBridgeInstance().port_request_monitor_by_name_ptr != nullptr)

  1773.             return (getBridgeInstance().port_request_monitor_by_name_ptr(client, port_name, onoff) == 0);

  1774. #endif

  1775.     return false;

  1776. }

  1777. 

  1778. bool jackbridge_port_ensure_monitor(jack_port_t* port, bool onoff)

  1779. {

  1780. #if defined(JACKBRIDGE_DUMMY)

  1781. #elif defined(JACKBRIDGE_DIRECT)

  1782.     return (jack_port_ensure_monitor(port, onoff) == 0);

  1783. #else

  1784.     if (usingRealJACK)

  1785.         if (getBridgeInstance().port_ensure_monitor_ptr != nullptr)

  1786.             return (getBridgeInstance().port_ensure_monitor_ptr(port, onoff) == 0);

  1787. #endif

  1788.     return false;

  1789. }

  1790. 

  1791. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1792. {

  1793. #if defined(JACKBRIDGE_DUMMY)

  1794. #elif defined(JACKBRIDGE_DIRECT)

  1795.     return jack_port_monitoring_input(port);

  1796. #else

  1797.     if (usingRealJACK)

  1798.         if (getBridgeInstance().port_monitoring_input_ptr != nullptr)

  1799.             return getBridgeInstance().port_monitoring_input_ptr(port);

  1800. #endif

  1801.     return false;

  1802. }

  1803. 

  1804. // --------------------------------------------------------------------------------------------------------------------

  1805. 

  1806. bool jackbridge_connect(jack_client_t* client, const char* source_port, const char* destination_port)

  1807. {

  1808. #if defined(JACKBRIDGE_DUMMY)

  1809. #elif defined(JACKBRIDGE_DIRECT)

  1810.     return (jack_connect(client, source_port, destination_port) == 0);

  1811. #else

  1812.     if (usingRealJACK && getBridgeInstance().connect_ptr != nullptr)

  1813.     {

  1814.         const int ret = getBridgeInstance().connect_ptr(client, source_port, destination_port);

  1815.         return ret == 0 || ret == EEXIST;

  1816.     }

  1817. #endif

  1818.     return false;

  1819. }

  1820. 

  1821. bool jackbridge_disconnect(jack_client_t* client, const char* source_port, const char* destination_port)

  1822. {

  1823. #if defined(JACKBRIDGE_DUMMY)

  1824. #elif defined(JACKBRIDGE_DIRECT)

  1825.     return (jack_disconnect(client, source_port, destination_port) == 0);

  1826. #else

  1827.     if (usingRealJACK)

  1828.         if (getBridgeInstance().disconnect_ptr != nullptr)

  1829.             return (getBridgeInstance().disconnect_ptr(client, source_port, destination_port) == 0);

  1830. #endif

  1831.     return false;

  1832. }

  1833. 

  1834. bool jackbridge_port_disconnect(jack_client_t* client, jack_port_t* port)

  1835. {

  1836. #if defined(JACKBRIDGE_DUMMY)

  1837. #elif defined(JACKBRIDGE_DIRECT)

  1838.     return (jack_port_disconnect(client, port) == 0);

  1839. #else

  1840.     if (usingRealJACK)

  1841.         if (getBridgeInstance().port_disconnect_ptr != nullptr)

  1842.             return (getBridgeInstance().port_disconnect_ptr(client, port) == 0);

  1843. #endif

  1844.     return false;

  1845. }

  1846. 

  1847. 

  1848. // --------------------------------------------------------------------------------------------------------------------

  1849. 

  1850. int jackbridge_port_name_size()

  1851. {

  1852. #if defined(JACKBRIDGE_DUMMY)

  1853. #elif defined(JACKBRIDGE_DIRECT)

  1854.     return jack_port_name_size();

  1855. #else

  1856.     if (usingRealJACK)

  1857.         if (getBridgeInstance().port_name_size_ptr != nullptr)

  1858.             return getBridgeInstance().port_name_size_ptr();

  1859. #endif

  1860.     return 256;

  1861. }

  1862. 

  1863. int jackbridge_port_type_size()

  1864. {

  1865. #if defined(JACKBRIDGE_DUMMY)

  1866. #elif defined(JACKBRIDGE_DIRECT)

  1867.     return jack_port_type_size();

  1868. #else

  1869.     if (usingRealJACK)

  1870.         if (getBridgeInstance().port_type_size_ptr != nullptr)

  1871.             return getBridgeInstance().port_type_size_ptr();

  1872. #endif

  1873.     return 32;

  1874. }

  1875. 

  1876. uint32_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type)

  1877. {

  1878. #if defined(JACKBRIDGE_DUMMY)

  1879. #elif defined(JACKBRIDGE_DIRECT)

  1880.     return static_cast<uint32_t>(jack_port_type_get_buffer_size(client, port_type));

  1881. #else

  1882.     if (usingRealJACK)

  1883.         if (getBridgeInstance().port_type_get_buffer_size_ptr != nullptr)

  1884.             return static_cast<uint32_t>(getBridgeInstance().port_type_get_buffer_size_ptr(client, port_type));

  1885. #endif

  1886.     return 0;

  1887. }

  1888. 

  1889. 

  1890. // --------------------------------------------------------------------------------------------------------------------

  1891. 

  1892. void jackbridge_port_get_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)

  1893. {

  1894. #if defined(JACKBRIDGE_DUMMY)

  1895. #elif defined(JACKBRIDGE_DIRECT)

  1896.     return jack_port_get_latency_range(port, static_cast<jack_latency_callback_mode_t>(mode), range);

  1897. #else

  1898.     if (usingRealJACK)

  1899.         if (getBridgeInstance().port_get_latency_range_ptr != nullptr)

  1900.             return getBridgeInstance().port_get_latency_range_ptr(port,

  1901.                                                                   static_cast<jack_latency_callback_mode_t>(mode),

  1902.                                                                   range);

  1903. #endif

  1904.     range->min = 0;

  1905.     range->max = 0;

  1906. }

  1907. 

  1908. void jackbridge_port_set_latency_range(jack_port_t* port, uint32_t mode, jack_latency_range_t* range)

  1909. {

  1910. #if defined(JACKBRIDGE_DUMMY)

  1911. #elif defined(JACKBRIDGE_DIRECT)

  1912.     jack_port_set_latency_range(port, static_cast<jack_latency_callback_mode_t>(mode), range);

  1913. #else

  1914.     if (usingRealJACK)

  1915.         if (getBridgeInstance().port_set_latency_range_ptr != nullptr)

  1916.             getBridgeInstance().port_set_latency_range_ptr(port,

  1917.                                                            static_cast<jack_latency_callback_mode_t>(mode),

  1918.                                                            range);

  1919. #endif

  1920. }

  1921. 

  1922. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1923. {

  1924. #if defined(JACKBRIDGE_DUMMY)

  1925. #elif defined(JACKBRIDGE_DIRECT)

  1926.     return (jack_recompute_total_latencies(client) == 0);

  1927. #else

  1928.     if (usingRealJACK)

  1929.         if (getBridgeInstance().recompute_total_latencies_ptr != nullptr)

  1930.             return (getBridgeInstance().recompute_total_latencies_ptr(client) == 0);

  1931. #endif

  1932.     return false;

  1933. }

  1934. 

  1935. 

  1936. // --------------------------------------------------------------------------------------------------------------------

  1937. 

  1938. const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, uint64_t flags)

  1939. {

  1940. #if defined(JACKBRIDGE_DUMMY)

  1941. #elif defined(JACKBRIDGE_DIRECT)

  1942.     return jack_get_ports(client, port_name_pattern, type_name_pattern, flags);

  1943. #else

  1944.     if (usingRealJACK)

  1945.         if (getBridgeInstance().get_ports_ptr != nullptr)

  1946.             return getBridgeInstance().get_ports_ptr(client, port_name_pattern, type_name_pattern,

  1947.                                                      static_cast<ulong>(flags));

  1948. #endif

  1949.     return nullptr;

  1950. }

  1951. 

  1952. jack_port_t* jackbridge_port_by_name(jack_client_t* client, const char* port_name)

  1953. {

  1954. #if defined(JACKBRIDGE_DUMMY)

  1955. #elif defined(JACKBRIDGE_DIRECT)

  1956.     return jack_port_by_name(client, port_name);

  1957. #else

  1958.     if (usingRealJACK)

  1959.         if (getBridgeInstance().port_by_name_ptr != nullptr)

  1960.             return getBridgeInstance().port_by_name_ptr(client, port_name);

  1961. #endif

  1962.     return nullptr;

  1963. }

  1964. 

  1965. jack_port_t* jackbridge_port_by_id(jack_client_t* client, jack_port_id_t port_id)

  1966. {

  1967. #if defined(JACKBRIDGE_DUMMY)

  1968. #elif defined(JACKBRIDGE_DIRECT)

  1969.     return jack_port_by_id(client, port_id);

  1970. #else

  1971.     if (usingRealJACK)

  1972.         if (getBridgeInstance().port_by_id_ptr != nullptr)

  1973.             return getBridgeInstance().port_by_id_ptr(client, port_id);

  1974. #endif

  1975.     return nullptr;

  1976. }

  1977. 

  1978. 

  1979. // --------------------------------------------------------------------------------------------------------------------

  1980. 

  1981. void jackbridge_free(void* ptr)

  1982. {

  1983. #if defined(JACKBRIDGE_DUMMY)

  1984. #elif defined(JACKBRIDGE_DIRECT)

  1985.     return jack_free(ptr);

  1986. #else

  1987.     if (usingRealJACK)

  1988.         if (getBridgeInstance().free_ptr != nullptr)

  1989.             return getBridgeInstance().free_ptr(ptr);

  1990. 

  1991.     // just in case

  1992.     std::free(ptr);

  1993. #endif

  1994. }

  1995. 

  1996. 

  1997. // --------------------------------------------------------------------------------------------------------------------

  1998. 

  1999. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  2000. {

  2001. #if defined(JACKBRIDGE_DUMMY)

  2002. #elif defined(JACKBRIDGE_DIRECT)

  2003.     return jack_midi_get_event_count(port_buffer);

  2004. #else

  2005.     if (usingNativeBridge)

  2006.         return nativeBridge->getEventCount();

  2007.     if (getBridgeInstance().midi_get_event_count_ptr != nullptr)

  2008.         return getBridgeInstance().midi_get_event_count_ptr(port_buffer);

  2009. #endif

  2010.     return 0;

  2011. }

  2012. 

  2013. bool jackbridge_midi_event_get(jack_midi_event_t* event, void* port_buffer, uint32_t event_index)

  2014. {

  2015. #if defined(JACKBRIDGE_DUMMY)

  2016. #elif defined(JACKBRIDGE_DIRECT)

  2017.     return (jack_midi_event_get(event, port_buffer, event_index) == 0);

  2018. #else

  2019.     if (usingNativeBridge)

  2020.         return nativeBridge->getEvent(event);

  2021.     if (getBridgeInstance().midi_event_get_ptr != nullptr)

  2022.         return (getBridgeInstance().midi_event_get_ptr(event, port_buffer, event_index) == 0);

  2023. #endif

  2024.     return false;

  2025. }

  2026. 

  2027. void jackbridge_midi_clear_buffer(void* port_buffer)

  2028. {

  2029. #if defined(JACKBRIDGE_DUMMY)

  2030. #elif defined(JACKBRIDGE_DIRECT)

  2031.     jack_midi_clear_buffer(port_buffer);

  2032. #else

  2033.     if (usingNativeBridge)

  2034.         return nativeBridge->clearEventBuffer();

  2035.     if (getBridgeInstance().midi_clear_buffer_ptr != nullptr)

  2036.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  2037. #endif

  2038. }

  2039. 

  2040. bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, uint32_t data_size)

  2041. {

  2042. #if defined(JACKBRIDGE_DUMMY)

  2043. #elif defined(JACKBRIDGE_DIRECT)

  2044.     return (jack_midi_event_write(port_buffer, time, data, data_size) == 0);

  2045. #else

  2046.     if (usingNativeBridge)

  2047.         return nativeBridge->writeEvent(time, data, data_size);

  2048.     if (getBridgeInstance().midi_event_write_ptr != nullptr)

  2049.         return (getBridgeInstance().midi_event_write_ptr(port_buffer, time, data, data_size) == 0);

  2050. #endif

  2051.     return false;

  2052. }

  2053. 

  2054. jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, uint32_t data_size)

  2055. {

  2056. #if defined(JACKBRIDGE_DUMMY)

  2057. #elif defined(JACKBRIDGE_DIRECT)

  2058.     return jack_midi_event_reserve(port_buffer, time, data_size);

  2059. #else

  2060.     if (usingRealJACK)

  2061.         if (getBridgeInstance().midi_event_reserve_ptr != nullptr)

  2062.             return getBridgeInstance().midi_event_reserve_ptr(port_buffer, time, data_size);

  2063. #endif

  2064.     return nullptr;

  2065. }

  2066. 

  2067. 

  2068. // --------------------------------------------------------------------------------------------------------------------

  2069. 

  2070. bool jackbridge_release_timebase(jack_client_t* client)

  2071. {

  2072. #if defined(JACKBRIDGE_DUMMY)

  2073. #elif defined(JACKBRIDGE_DIRECT)

  2074.     return (jack_release_timebase(client) == 0);

  2075. #else

  2076.     if (usingRealJACK)

  2077.         if (getBridgeInstance().release_timebase_ptr != nullptr)

  2078.             return (getBridgeInstance().release_timebase_ptr(client) == 0);

  2079. #endif

  2080.     return false;

  2081. }

  2082. 

  2083. bool jackbridge_set_sync_callback(jack_client_t* client, JackSyncCallback sync_callback, void* arg)

  2084. {

  2085. #if defined(JACKBRIDGE_DUMMY)

  2086. #elif defined(JACKBRIDGE_DIRECT)

  2087.     return (jack_set_sync_callback(client, sync_callback, arg) == 0);

  2088. #else

  2089.     if (usingRealJACK && getBridgeInstance().set_sync_callback_ptr != nullptr)

  2090.     {

  2091. # ifdef __WINE__

  2092.         WineBridge::getInstance().set_sync(sync_callback);

  2093.         return (getBridgeInstance().set_sync_callback_ptr(client, WineBridge::sync, arg) == 0);

  2094. # else

  2095.         return (getBridgeInstance().set_sync_callback_ptr(client, sync_callback, arg) == 0);

  2096. # endif

  2097.     }

  2098. #endif

  2099.     return false;

  2100. }

  2101. 

  2102. bool jackbridge_set_sync_timeout(jack_client_t* client, jack_time_t timeout)

  2103. {

  2104. #if defined(JACKBRIDGE_DUMMY)

  2105. #elif defined(JACKBRIDGE_DIRECT)

  2106.     return (jack_set_sync_timeout(client, timeout) == 0);

  2107. #else

  2108.     if (usingRealJACK)

  2109.         if (getBridgeInstance().set_sync_timeout_ptr != nullptr)

  2110.             return (getBridgeInstance().set_sync_timeout_ptr(client, timeout) == 0);

  2111. #endif

  2112.     return false;

  2113. }

  2114. 

  2115. bool jackbridge_set_timebase_callback(jack_client_t* client, bool conditional, JackTimebaseCallback timebase_callback, void* arg)

  2116. {

  2117. #if defined(JACKBRIDGE_DUMMY)

  2118. #elif defined(JACKBRIDGE_DIRECT)

  2119.     return (jack_set_timebase_callback(client, conditional, timebase_callback, arg) == 0);

  2120. #else

  2121.     if (usingRealJACK && getBridgeInstance().set_timebase_callback_ptr != nullptr)

  2122.     {

  2123. # ifdef __WINE__

  2124.         WineBridge::getInstance().set_timebase(timebase_callback);

  2125.         return (getBridgeInstance().set_timebase_callback_ptr(client, conditional, WineBridge::timebase, arg) == 0);

  2126. # else

  2127.         return (getBridgeInstance().set_timebase_callback_ptr(client, conditional, timebase_callback, arg) == 0);

  2128. # endif

  2129.     }

  2130. #endif

  2131.     return false;

  2132. }

  2133. 

  2134. bool jackbridge_transport_locate(jack_client_t* client, jack_nframes_t frame)

  2135. {

  2136. #if defined(JACKBRIDGE_DUMMY)

  2137. #elif defined(JACKBRIDGE_DIRECT)

  2138.     return (jack_transport_locate(client, frame) == 0);

  2139. #else

  2140.     if (usingRealJACK)

  2141.         if (getBridgeInstance().transport_locate_ptr != nullptr)

  2142.             return (getBridgeInstance().transport_locate_ptr(client, frame) == 0);

  2143. #endif

  2144.     return false;

  2145. }

  2146. 

  2147. uint32_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)

  2148. {

  2149. #if defined(JACKBRIDGE_DUMMY)

  2150. #elif defined(JACKBRIDGE_DIRECT)

  2151.     return jack_transport_query(client, pos);

  2152. #else

  2153.     if (usingRealJACK)

  2154.         if (getBridgeInstance().transport_query_ptr != nullptr)

  2155.             return getBridgeInstance().transport_query_ptr(client, pos);

  2156. #endif

  2157.     if (pos != nullptr)

  2158.     {

  2159.         // invalidate

  2160.         std::memset(pos, 0, sizeof(*pos));

  2161.         pos->unique_1 = 0;

  2162.         pos->unique_2 = 1;

  2163.     }

  2164.     return JackTransportStopped;

  2165. }

  2166. 

  2167. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  2168. {

  2169. #if defined(JACKBRIDGE_DUMMY)

  2170. #elif defined(JACKBRIDGE_DIRECT)

  2171.     return jack_get_current_transport_frame(client);

  2172. #else

  2173.     if (usingRealJACK)

  2174.         if (getBridgeInstance().get_current_transport_frame_ptr != nullptr)

  2175.             return getBridgeInstance().get_current_transport_frame_ptr(client);

  2176. #endif

  2177.     return 0;

  2178. }

  2179. 

  2180. bool jackbridge_transport_reposition(jack_client_t* client, const jack_position_t* pos)

  2181. {

  2182. #if defined(JACKBRIDGE_DUMMY)

  2183. #elif defined(JACKBRIDGE_DIRECT)

  2184.     return (jack_transport_reposition(client, pos) == 0);

  2185. #else

  2186.     if (usingRealJACK)

  2187.         if (getBridgeInstance().transport_reposition_ptr != nullptr)

  2188.             return (getBridgeInstance().transport_reposition_ptr(client, pos) == 0);

  2189. #endif

  2190.     return false;

  2191. }

  2192. 

  2193. void jackbridge_transport_start(jack_client_t* client)

  2194. {

  2195. #if defined(JACKBRIDGE_DUMMY)

  2196. #elif defined(JACKBRIDGE_DIRECT)

  2197.     jack_transport_start(client);

  2198. #else

  2199.     if (usingRealJACK)

  2200.         if (getBridgeInstance().transport_start_ptr != nullptr)

  2201.             getBridgeInstance().transport_start_ptr(client);

  2202. #endif

  2203. }

  2204. 

  2205. void jackbridge_transport_stop(jack_client_t* client)

  2206. {

  2207. #if defined(JACKBRIDGE_DUMMY)

  2208. #elif defined(JACKBRIDGE_DIRECT)

  2209.     jack_transport_stop(client);

  2210. #else

  2211.     if (usingRealJACK)

  2212.         if (getBridgeInstance().transport_stop_ptr != nullptr)

  2213.             getBridgeInstance().transport_stop_ptr(client);

  2214. #endif

  2215. }

  2216. 

  2217. 

  2218. // --------------------------------------------------------------------------------------------------------------------

  2219. 

  2220. bool jackbridge_set_property(jack_client_t* client, jack_uuid_t subject, const char* key, const char* value, const char* type)

  2221. {

  2222. #if defined(JACKBRIDGE_DUMMY)

  2223. #elif defined(JACKBRIDGE_DIRECT)

  2224.     return (jack_set_property(client, subject, key, value, type) == 0);

  2225. #else

  2226.     if (usingRealJACK)

  2227.         if (getBridgeInstance().set_property_ptr != nullptr)

  2228.             return (getBridgeInstance().set_property_ptr(client, subject, key, value, type) == 0);

  2229. #endif

  2230.     return false;

  2231. }

  2232. 

  2233. bool jackbridge_get_property(jack_uuid_t subject, const char* key, char** value, char** type)

  2234. {

  2235. #if defined(JACKBRIDGE_DUMMY)

  2236. #elif defined(JACKBRIDGE_DIRECT)

  2237.     return (jack_get_property(subject, key, value, type) == 0);

  2238. #else

  2239.     if (usingRealJACK)

  2240.         if (getBridgeInstance().get_property_ptr != nullptr)

  2241.             return (getBridgeInstance().get_property_ptr(subject, key, value, type) == 0);

  2242. #endif

  2243.     return false;

  2244. }

  2245. 

  2246. void jackbridge_free_description(jack_description_t* desc, bool free_description_itself)

  2247. {

  2248. #if defined(JACKBRIDGE_DUMMY)

  2249. #elif defined(JACKBRIDGE_DIRECT)

  2250.     jack_free_description(desc, free_description_itself);

  2251. #else

  2252.     if (usingRealJACK)

  2253.         if (getBridgeInstance().free_description_ptr != nullptr)

  2254.             getBridgeInstance().free_description_ptr(desc, free_description_itself);

  2255. #endif

  2256. }

  2257. 

  2258. bool jackbridge_get_properties(jack_uuid_t subject, jack_description_t* desc)

  2259. {

  2260. #if defined(JACKBRIDGE_DUMMY)

  2261. #elif defined(JACKBRIDGE_DIRECT)

  2262.     return (jack_get_properties(subject, desc) == 0);

  2263. #else

  2264.     if (usingRealJACK)

  2265.         if (getBridgeInstance().get_properties_ptr != nullptr)

  2266.             return (getBridgeInstance().get_properties_ptr(subject, desc) == 0);

  2267. #endif

  2268.     return false;

  2269. }

  2270. 

  2271. bool jackbridge_get_all_properties(jack_description_t** descs)

  2272. {

  2273. #if defined(JACKBRIDGE_DUMMY)

  2274. #elif defined(JACKBRIDGE_DIRECT)

  2275.     return (jack_get_all_properties(descs) == 0);

  2276. #else

  2277.     if (usingRealJACK)

  2278.         if (getBridgeInstance().get_all_properties_ptr != nullptr)

  2279.             return (getBridgeInstance().get_all_properties_ptr(descs) == 0);

  2280. #endif

  2281.     return false;

  2282. }

  2283. 

  2284. bool jackbridge_remove_property(jack_client_t* client, jack_uuid_t subject, const char* key)

  2285. {

  2286. #if defined(JACKBRIDGE_DUMMY)

  2287. #elif defined(JACKBRIDGE_DIRECT)

  2288.     return (jack_remove_property(client, subject, key) == 0);

  2289. #else

  2290.     if (usingRealJACK)

  2291.         if (getBridgeInstance().remove_property_ptr != nullptr)

  2292.             return (getBridgeInstance().remove_property_ptr(client, subject, key) == 0);

  2293. #endif

  2294.     return false;

  2295. }

  2296. 

  2297. int jackbridge_remove_properties(jack_client_t* client, jack_uuid_t subject)

  2298. {

  2299. #if defined(JACKBRIDGE_DUMMY)

  2300. #elif defined(JACKBRIDGE_DIRECT)

  2301.     return jack_remove_properties(client, subject);

  2302. #else

  2303.     if (usingRealJACK)

  2304.         if (getBridgeInstance().remove_properties_ptr != nullptr)

  2305.             return getBridgeInstance().remove_properties_ptr(client, subject);

  2306. #endif

  2307.     return 0;

  2308. }

  2309. 

  2310. bool jackbridge_remove_all_properties(jack_client_t* client)

  2311. {

  2312. #if defined(JACKBRIDGE_DUMMY)

  2313. #elif defined(JACKBRIDGE_DIRECT)

  2314.     return (jack_remove_all_properties(client) == 0);

  2315. #else

  2316.     if (usingRealJACK)

  2317.         if (getBridgeInstance().remove_all_properties_ptr != nullptr)

  2318.             return (getBridgeInstance().remove_all_properties_ptr(client) == 0);

  2319. #endif

  2320.     return false;

  2321. }

  2322. 

  2323. bool jackbridge_set_property_change_callback(jack_client_t* client, JackPropertyChangeCallback callback, void* arg)

  2324. {

  2325. #if defined(JACKBRIDGE_DUMMY)

  2326. #elif defined(JACKBRIDGE_DIRECT)

  2327.     return (jack_set_property_change_callback(client, callback, arg) == 0);

  2328. #else

  2329.     if (usingRealJACK && getBridgeInstance().set_property_change_callback_ptr != nullptr)

  2330.     {

  2331. # ifdef __WINE__

  2332.         WineBridge::getInstance().set_prop_change(callback);

  2333.         return (getBridgeInstance().set_property_change_callback_ptr(client, WineBridge::prop_change, arg) == 0);

  2334. # else

  2335.         return (getBridgeInstance().set_property_change_callback_ptr(client, callback, arg) == 0);

  2336. # endif

  2337.     }

  2338. #endif

  2339.     return false;

  2340. }

  2341. 

  2342. bool jackbridge_set_process_thread(jack_client_t* client, JackThreadCallback callback, void* arg)

  2343. {

  2344. #if defined(JACKBRIDGE_DUMMY)

  2345. #elif defined(JACKBRIDGE_DIRECT)

  2346.     return (jack_set_process_thread(client, callback, arg) == 0);

  2347. #else

  2348.     if (usingRealJACK && getBridgeInstance().set_process_thread_ptr != nullptr)

  2349.     {

  2350. # ifdef __WINE__

  2351.         WineBridge::getInstance().set_process_thread(callback);

  2352.         return (getBridgeInstance().set_process_thread_ptr(client, WineBridge::process_thread, arg) == 0);

  2353. # else

  2354.         return (getBridgeInstance().set_process_thread_ptr(client, callback, arg) == 0);

  2355. # endif

  2356.     }

  2357. #endif

  2358.     return false;

  2359. }

  2360. 

  2361. jack_nframes_t jackbridge_cycle_wait(jack_client_t* client)

  2362. {

  2363. #if defined(JACKBRIDGE_DUMMY)

  2364. #elif defined(JACKBRIDGE_DIRECT)

  2365.     return jack_cycle_wait(client);

  2366. #else

  2367.     if (usingRealJACK)

  2368.         if (getBridgeInstance().cycle_wait_ptr != nullptr)

  2369.             return getBridgeInstance().cycle_wait_ptr(client);

  2370. #endif

  2371.     return 0;

  2372. }

  2373. 

  2374. void jackbridge_cycle_signal(jack_client_t* client, int status)

  2375. {

  2376. #if defined(JACKBRIDGE_DUMMY)

  2377. #elif defined(JACKBRIDGE_DIRECT)

  2378.     jack_cycle_signal(client, status);

  2379. #else

  2380.     if (usingRealJACK)

  2381.         if (getBridgeInstance().cycle_signal_ptr != nullptr)

  2382.             getBridgeInstance().cycle_signal_ptr(client, status);

  2383. #endif

  2384. }

  2385. 

  2386. 

  2387. // --------------------------------------------------------------------------------------------------------------------

  2388. 

  2389. #ifndef JACKBRIDGE_SKIP_NATIVE_UTILS

  2390. 

  2391. START_NAMESPACE_DISTRHO

  2392. 

  2393. bool isUsingNativeAudio() noexcept

  2394. {

  2395. #if defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT)

  2396.     return false;

  2397. #else

  2398.     return usingNativeBridge;

  2399. #endif

  2400. }

  2401. 

  2402. bool supportsAudioInput()

  2403. {

  2404. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2405.     if (usingNativeBridge)

  2406.         return nativeBridge->supportsAudioInput();

  2407. #endif

  2408.     return false;

  2409. }

  2410. 

  2411. bool supportsBufferSizeChanges()

  2412. {

  2413. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2414.     if (usingNativeBridge)

  2415.         return nativeBridge->supportsBufferSizeChanges();

  2416. #endif

  2417.     return false;

  2418. }

  2419. 

  2420. bool supportsMIDI()

  2421. {

  2422. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2423.     if (usingNativeBridge)

  2424.         return nativeBridge->supportsMIDI();

  2425. #endif

  2426.     return false;

  2427. }

  2428. 

  2429. bool isAudioInputEnabled()

  2430. {

  2431. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2432.     if (usingNativeBridge)

  2433.         return nativeBridge->isAudioInputEnabled();

  2434. #endif

  2435.     return false;

  2436. }

  2437. 

  2438. bool isMIDIEnabled()

  2439. {

  2440. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2441.     if (usingNativeBridge)

  2442.         return nativeBridge->isMIDIEnabled();

  2443. #endif

  2444.     return false;

  2445. }

  2446. 

  2447. uint getBufferSize()

  2448. {

  2449. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2450.     if (usingNativeBridge)

  2451.         return nativeBridge->getBufferSize();

  2452. #endif

  2453.     return 0;

  2454. }

  2455. 

  2456. bool requestAudioInput()

  2457. {

  2458. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2459.     if (usingNativeBridge)

  2460.         return nativeBridge->requestAudioInput();

  2461. #endif

  2462.     return false;

  2463. }

  2464. 

  2465. bool requestBufferSizeChange(const uint newBufferSize)

  2466. {

  2467. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2468.     if (usingNativeBridge)

  2469.         return nativeBridge->requestBufferSizeChange(newBufferSize);

  2470. #endif

  2471.     return false;

  2472. }

  2473. 

  2474. bool requestMIDI()

  2475. {

  2476. #if !(defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT))

  2477.     if (usingNativeBridge)

  2478.         return nativeBridge->requestMIDI();

  2479. #endif

  2480.     return false;

  2481. }

  2482. 

  2483. END_NAMESPACE_DISTRHO

  2484. 

  2485. #endif // JACKBRIDGE_SKIP_NATIVE_UTILS

  2486. 

  2487. 

  2488. // --------------------------------------------------------------------------------------------------------------------