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.
2370 Commits
7 Branches
295MB
Tree: 7cd48190cf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7cd48190cf'
${ noResults }
DPF/distrho/src/jackbridge/JackBridge.cpp

2481 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.        #if defined(DISTRHO_OS_MAC)

  471.         const char* const filename = "libjack.dylib";

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

  473.         const char* const filename = "libjack64.dll";

  474.        #elif defined(DISTRHO_OS_WINDOWS)

  475.         const char* const filename = "libjack.dll";

  476.        #else

  477.         const char* const filename = "libjack.so.0";

  478.        #endif

  479. 

  480.         USE_NAMESPACE_DISTRHO

  481. 

  482.         lib = lib_open(filename);

  483. 

  484.         if (lib == nullptr)

  485.         {

  486.             d_stderr("Failed to load JACK DLL, reason:\n%s", lib_error(filename));

  487.             return;

  488.         }

  489.         else

  490.         {

  491.             d_stdout("%s loaded successfully!", filename);

  492.         }

  493. 

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

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

  496. 

  497.         LIB_SYMBOL(get_version)

  498.         LIB_SYMBOL(get_version_string)

  499. 

  500.         LIB_SYMBOL(client_open)

  501.         LIB_SYMBOL(client_close)

  502. 

  503.         LIB_SYMBOL(client_name_size)

  504.         LIB_SYMBOL(get_client_name)

  505. 

  506.         LIB_SYMBOL(client_get_uuid)

  507.         LIB_SYMBOL(get_uuid_for_client_name)

  508.         LIB_SYMBOL(get_client_name_by_uuid)

  509. 

  510.         LIB_SYMBOL(uuid_parse)

  511.         LIB_SYMBOL(uuid_unparse)

  512. 

  513.         LIB_SYMBOL(activate)

  514.         LIB_SYMBOL(deactivate)

  515.         LIB_SYMBOL(is_realtime)

  516. 

  517.         LIB_SYMBOL(set_thread_init_callback)

  518.         LIB_SYMBOL(on_shutdown)

  519.         LIB_SYMBOL(on_info_shutdown)

  520.         LIB_SYMBOL(set_process_callback)

  521.         LIB_SYMBOL(set_freewheel_callback)

  522.         LIB_SYMBOL(set_buffer_size_callback)

  523.         LIB_SYMBOL(set_sample_rate_callback)

  524.         LIB_SYMBOL(set_client_registration_callback)

  525.         LIB_SYMBOL(set_port_registration_callback)

  526.         LIB_SYMBOL(set_port_rename_callback)

  527.         LIB_SYMBOL(set_port_connect_callback)

  528.         LIB_SYMBOL(set_graph_order_callback)

  529.         LIB_SYMBOL(set_xrun_callback)

  530.         LIB_SYMBOL(set_latency_callback)

  531. 

  532.         LIB_SYMBOL(set_freewheel)

  533.         LIB_SYMBOL(set_buffer_size)

  534. 

  535.         LIB_SYMBOL(get_sample_rate)

  536.         LIB_SYMBOL(get_buffer_size)

  537.         LIB_SYMBOL(cpu_load)

  538. 

  539.         LIB_SYMBOL(port_register)

  540.         LIB_SYMBOL(port_unregister)

  541.         LIB_SYMBOL(port_get_buffer)

  542. 

  543.         LIB_SYMBOL(port_name)

  544.         LIB_SYMBOL(port_uuid)

  545.         LIB_SYMBOL(port_short_name)

  546.         LIB_SYMBOL(port_flags)

  547.         LIB_SYMBOL(port_type)

  548.         LIB_SYMBOL(port_is_mine)

  549.         LIB_SYMBOL(port_connected)

  550.         LIB_SYMBOL(port_connected_to)

  551.         LIB_SYMBOL(port_get_connections)

  552.         LIB_SYMBOL(port_get_all_connections)

  553. 

  554.         LIB_SYMBOL(port_rename)

  555.         LIB_SYMBOL(port_set_name)

  556.         LIB_SYMBOL(port_set_alias)

  557.         LIB_SYMBOL(port_unset_alias)

  558.         LIB_SYMBOL(port_get_aliases)

  559. 

  560.         LIB_SYMBOL(port_request_monitor)

  561.         LIB_SYMBOL(port_request_monitor_by_name)

  562.         LIB_SYMBOL(port_ensure_monitor)

  563.         LIB_SYMBOL(port_monitoring_input)

  564. 

  565.         LIB_SYMBOL(connect)

  566.         LIB_SYMBOL(disconnect)

  567.         LIB_SYMBOL(port_disconnect)

  568. 

  569.         LIB_SYMBOL(port_name_size)

  570.         LIB_SYMBOL(port_type_size)

  571.         LIB_SYMBOL(port_type_get_buffer_size)

  572. 

  573.         LIB_SYMBOL(port_get_latency_range)

  574.         LIB_SYMBOL(port_set_latency_range)

  575.         LIB_SYMBOL(recompute_total_latencies)

  576. 

  577.         LIB_SYMBOL(get_ports)

  578.         LIB_SYMBOL(port_by_name)

  579.         LIB_SYMBOL(port_by_id)

  580. 

  581.         LIB_SYMBOL(free)

  582. 

  583.         LIB_SYMBOL(midi_get_event_count)

  584.         LIB_SYMBOL(midi_event_get)

  585.         LIB_SYMBOL(midi_clear_buffer)

  586.         LIB_SYMBOL(midi_event_write)

  587.         LIB_SYMBOL(midi_event_reserve)

  588. 

  589.         LIB_SYMBOL(release_timebase)

  590.         LIB_SYMBOL(set_sync_callback)

  591.         LIB_SYMBOL(set_sync_timeout)

  592.         LIB_SYMBOL(set_timebase_callback)

  593.         LIB_SYMBOL(transport_locate)

  594.         LIB_SYMBOL(transport_query)

  595.         LIB_SYMBOL(get_current_transport_frame)

  596.         LIB_SYMBOL(transport_reposition)

  597.         LIB_SYMBOL(transport_start)

  598.         LIB_SYMBOL(transport_stop)

  599. 

  600.         LIB_SYMBOL(set_property)

  601.         LIB_SYMBOL(get_property)

  602.         LIB_SYMBOL(free_description)

  603.         LIB_SYMBOL(get_properties)

  604.         LIB_SYMBOL(get_all_properties)

  605.         LIB_SYMBOL(remove_property)

  606.         LIB_SYMBOL(remove_properties)

  607.         LIB_SYMBOL(remove_all_properties)

  608.         LIB_SYMBOL(set_property_change_callback)

  609. 

  610.         LIB_SYMBOL(set_process_thread)

  611.         LIB_SYMBOL(cycle_wait)

  612.         LIB_SYMBOL(cycle_signal)

  613. 

  614.        #ifdef __WINE__

  615.         LIB_SYMBOL(set_thread_creator)

  616.        #endif

  617.       #endif

  618. 

  619.         #undef JOIN

  620.         #undef LIB_SYMBOL

  621.     }

  622. 

  623.    #ifdef HAVE_JACK

  624.     ~JackBridge() noexcept

  625.     {

  626.         USE_NAMESPACE_DISTRHO

  627. 

  628.         if (lib != nullptr)

  629.         {

  630.             lib_close(lib);

  631.             lib = nullptr;

  632.         }

  633.     }

  634.    #endif

  635. 

  636.     DISTRHO_DECLARE_NON_COPYABLE(JackBridge);

  637. };

  638. 

  639. static bool usingNativeBridge = false;

  640. static bool usingRealJACK = true;

  641. static NativeBridge* nativeBridge = nullptr;

  642. 

  643. // --------------------------------------------------------------------------------------------------------------------

  644. 

  645. static JackBridge& getBridgeInstance() noexcept

  646. {

  647.     static JackBridge bridge;

  648.     return bridge;

  649. }

  650. 

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

  652. 

  653. // --------------------------------------------------------------------------------------------------------------------

  654. 

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

  656. 

  657. struct WineBridge {

  658.     void* ptr;

  659.     JackLatencyCallback latency_cb;

  660.     JackProcessCallback process_cb;

  661.     JackThreadInitCallback thread_init_cb;

  662.     JackGraphOrderCallback graph_order_cb;

  663.     JackXRunCallback xrun_cb;

  664.     JackBufferSizeCallback bufsize_cb;

  665.     JackSampleRateCallback srate_cb;

  666.     JackPortRegistrationCallback port_reg_cb;

  667.     JackClientRegistrationCallback client_reg_cb;

  668.     JackPortConnectCallback port_conn_cb;

  669.     JackPortRenameCallback port_rename_cb;

  670.     JackFreewheelCallback freewheel_cb;

  671.     JackShutdownCallback shutdown_cb;

  672.     JackInfoShutdownCallback info_shutdown_cb;

  673.     JackSyncCallback sync_cb;

  674.     JackTimebaseCallback timebase_cb;

  675.     JackSessionCallback session_cb;

  676.     JackPropertyChangeCallback prop_change_cb;

  677.     JackThreadCallback proc_thread_cb;

  678. 

  679.     void* (*creator_func)(void*);

  680.     void* creator_arg;

  681.     HANDLE creator_handle;

  682.     pthread_t creator_pthread;

  683. 

  684.     WineBridge() noexcept

  685.         : ptr(nullptr),

  686.           latency_cb(nullptr),

  687.           process_cb(nullptr),

  688.           thread_init_cb(nullptr),

  689.           graph_order_cb(nullptr),

  690.           xrun_cb(nullptr),

  691.           bufsize_cb(nullptr),

  692.           srate_cb(nullptr),

  693.           port_reg_cb(nullptr),

  694.           client_reg_cb(nullptr),

  695.           port_conn_cb(nullptr),

  696.           port_rename_cb(nullptr),

  697.           freewheel_cb(nullptr),

  698.           shutdown_cb(nullptr),

  699.           info_shutdown_cb(nullptr),

  700.           sync_cb(nullptr),

  701.           timebase_cb(nullptr),

  702.           session_cb(nullptr),

  703.           prop_change_cb(nullptr),

  704.           proc_thread_cb(nullptr),

  705.           creator_func(nullptr),

  706.           creator_arg(nullptr),

  707.           creator_handle(nullptr),

  708.           creator_pthread(0) {}

  709. 

  710.     static WineBridge& getInstance() noexcept

  711.     {

  712.         static WineBridge bridge;

  713.         return bridge;

  714.     }

  715. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  735. 

  736.     static DWORD WINAPI thread_creator_helper(LPVOID)

  737.     {

  738.         WineBridge& inst(getInstance());

  739. 

  740.         inst.creator_pthread = pthread_self();

  741.         SetEvent(inst.creator_handle);

  742.         inst.creator_func(inst.creator_arg);

  743.         return 0;

  744.     }

  745. 

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

  747.     {

  748.         WineBridge& inst(getInstance());

  749. 

  750.         inst.creator_func   = function;

  751.         inst.creator_arg    = arg;

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

  753. 

  754. #if 0

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

  756. #else

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

  758. 

  759.         if (handle == INVALID_HANDLE_VALUE)

  760.             return 1;

  761. 

  762.         // TODO read attrs and decide this

  763.         ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);

  764.         ::ResumeThread(handle);

  765. #endif

  766. 

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

  768.         *thread_id = inst.creator_pthread;

  769.         return 0;

  770.     }

  771. 

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

  773.     {

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

  775.     }

  776. 

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

  778.     {

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

  780.     }

  781. 

  782.     static void thread_init(void* arg)

  783.     {

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

  785.     }

  786. 

  787.     static int graph_order(void* arg)

  788.     {

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

  790.     }

  791. 

  792.     static int xrun(void* arg)

  793.     {

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

  795.     }

  796. 

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

  798.     {

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

  800.     }

  801. 

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

  803.     {

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

  805.     }

  806. 

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

  808.     {

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

  810.     }

  811. 

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

  813.     {

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

  815.     }

  816. 

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

  818.     {

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

  820.     }

  821. 

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

  823.     {

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

  825.     }

  826. 

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

  828.     {

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

  830.     }

  831. 

  832.     static void shutdown(void* arg)

  833.     {

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

  835.     }

  836. 

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

  838.     {

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

  840.     }

  841. 

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

  843.     {

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

  845.     }

  846. 

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

  848.     {

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

  850.     }

  851. 

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

  853.     {

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

  855.     }

  856. 

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

  858.     {

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

  860.     }

  861. 

  862.     static void* process_thread(void* arg)

  863.     {

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

  865.     }

  866. 

  867.     DISTRHO_DECLARE_NON_COPYABLE(WineBridge);

  868. };

  869. 

  870. #endif // __WINE__ && ! JACKBRIDGE_DIRECT

  871. 

  872. // --------------------------------------------------------------------------------------------------------------------

  873. 

  874. bool jackbridge_is_ok() noexcept

  875. {

  876. #if defined(JACKBRIDGE_DUMMY)

  877.     return false;

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

  879.     return true;

  880. #else

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

  882. #endif

  883. }

  884. 

  885. void jackbridge_init()

  886. {

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

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

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

  890. #endif

  891. }

  892. 

  893. // --------------------------------------------------------------------------------------------------------------------

  894. 

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

  896. {

  897. #if defined(JACKBRIDGE_DUMMY)

  898. #elif defined(JACKBRIDGE_DIRECT)

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

  900. #else

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

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

  903. #endif

  904.     if (major_ptr != nullptr)

  905.         *major_ptr = 0;

  906.     if (minor_ptr != nullptr)

  907.         *minor_ptr = 0;

  908.     if (micro_ptr != nullptr)

  909.         *micro_ptr = 0;

  910.     if (proto_ptr != nullptr)

  911.         *proto_ptr = 0;

  912. }

  913. 

  914. const char* jackbridge_get_version_string()

  915. {

  916. #if defined(JACKBRIDGE_DUMMY)

  917. #elif defined(JACKBRIDGE_DIRECT)

  918.     return jack_get_version_string();

  919. #else

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

  921.         return getBridgeInstance().get_version_string_ptr();

  922. #endif

  923.     return nullptr;

  924. }

  925. 

  926. // --------------------------------------------------------------------------------------------------------------------

  927. 

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

  929. {

  930. #if defined(JACKBRIDGE_DUMMY)

  931. #elif defined(JACKBRIDGE_DIRECT)

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

  933. #else

  934.    #ifndef DISTRHO_OS_WASM

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

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

  937.             return client;

  938.    #endif

  939. 

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

  941. 

  942.     // maybe unused

  943.     (void)kValidClient;

  944. 

  945.     usingNativeBridge = true;

  946.     usingRealJACK = false;

  947. 

  948.    #ifdef DISTRHO_OS_WASM

  949.     nativeBridge = new WebBridge;

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

  951.         return kValidClient;

  952.     delete nativeBridge;

  953.    #endif

  954.     

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

  956.     nativeBridge = new RtAudioBridge;

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

  958.         return kValidClient;

  959.     delete nativeBridge;

  960.    #endif

  961. 

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

  963.     nativeBridge = new SDL2Bridge;

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

  965.         return kValidClient;

  966.     delete nativeBridge;

  967.    #endif

  968. #endif

  969. 

  970.     if (status != nullptr)

  971.     {

  972.         int err = JackServerError;

  973. 

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

  975.         if (nativeBridge != nullptr)

  976.         {

  977.             err

  978.             #ifdef HAVE_JACK

  979.              |=

  980.             #else

  981.              =

  982.             #endif

  983.             JackBridgeNativeFailed;

  984.         }

  985.        #endif

  986. 

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

  988.     }

  989. 

  990.     return nullptr;

  991. }

  992. 

  993. bool jackbridge_client_close(jack_client_t* client)

  994. {

  995. #if defined(JACKBRIDGE_DUMMY)

  996. #elif defined(JACKBRIDGE_DIRECT)

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

  998. #else

  999.     if (usingNativeBridge)

  1000.     {

  1001.         if (nativeBridge != nullptr)

  1002.         {

  1003.             nativeBridge->close();

  1004.             delete nativeBridge;

  1005.             nativeBridge = nullptr;

  1006.         }

  1007.         usingNativeBridge = false;

  1008.         usingRealJACK = true;

  1009.         return true;

  1010.     }

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

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

  1013. #endif

  1014.     return false;

  1015. }

  1016. 

  1017. // --------------------------------------------------------------------------------------------------------------------

  1018. 

  1019. int jackbridge_client_name_size()

  1020. {

  1021. #if defined(JACKBRIDGE_DUMMY)

  1022. #elif defined(JACKBRIDGE_DIRECT)

  1023.     return jack_client_name_size();

  1024. #else

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

  1026.         return getBridgeInstance().client_name_size_ptr();

  1027. #endif

  1028.     return 33;

  1029. }

  1030. 

  1031. const char* jackbridge_get_client_name(jack_client_t* client)

  1032. {

  1033. #if defined(JACKBRIDGE_DUMMY)

  1034. #elif defined(JACKBRIDGE_DIRECT)

  1035.     return jack_get_client_name(client);

  1036. #else

  1037.     if (usingNativeBridge)

  1038.         return DISTRHO_PLUGIN_NAME;

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

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

  1041. #endif

  1042.     return nullptr;

  1043. }

  1044. 

  1045. // --------------------------------------------------------------------------------------------------------------------

  1046. 

  1047. char* jackbridge_client_get_uuid(jack_client_t* client)

  1048. {

  1049. #if defined(JACKBRIDGE_DUMMY)

  1050. #elif defined(JACKBRIDGE_DIRECT)

  1051.     return jack_client_get_uuid(client);

  1052. #else

  1053.     if (usingRealJACK)

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

  1055.             return func(client);

  1056. #endif

  1057.     return nullptr;

  1058. }

  1059. 

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

  1061. {

  1062. #if defined(JACKBRIDGE_DUMMY)

  1063. #elif defined(JACKBRIDGE_DIRECT)

  1064.     return jack_get_uuid_for_client_name(client, name);

  1065. #else

  1066.     if (usingRealJACK)

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

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

  1069. #endif

  1070.     return nullptr;

  1071. }

  1072. 

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

  1074. {

  1075. #if defined(JACKBRIDGE_DUMMY)

  1076. #elif defined(JACKBRIDGE_DIRECT)

  1077.     return jack_get_client_name_by_uuid(client, uuid);

  1078. #else

  1079.     if (usingRealJACK)

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

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

  1082. #endif

  1083.     return nullptr;

  1084. }

  1085. 

  1086. // --------------------------------------------------------------------------------------------------------------------

  1087. 

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

  1089. {

  1090. #if defined(JACKBRIDGE_DUMMY)

  1091. #elif defined(JACKBRIDGE_DIRECT)

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

  1093. #else

  1094.     if (usingRealJACK)

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

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

  1097. #endif

  1098.     return false;

  1099. }

  1100. 

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

  1102. {

  1103. #if defined(JACKBRIDGE_DUMMY)

  1104. #elif defined(JACKBRIDGE_DIRECT)

  1105.     jack_uuid_unparse(uuid, buf);

  1106. #else

  1107.     if (usingRealJACK)

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

  1109.             return func(uuid, buf);

  1110. #endif

  1111. }

  1112. 

  1113. // --------------------------------------------------------------------------------------------------------------------

  1114. 

  1115. bool jackbridge_activate(jack_client_t* client)

  1116. {

  1117. #if defined(JACKBRIDGE_DUMMY)

  1118. #elif defined(JACKBRIDGE_DIRECT)

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

  1120. #else

  1121.     if (usingNativeBridge)

  1122.         return nativeBridge->activate();

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

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

  1125. #endif

  1126.     return false;

  1127. }

  1128. 

  1129. bool jackbridge_deactivate(jack_client_t* client)

  1130. {

  1131. #if defined(JACKBRIDGE_DUMMY)

  1132. #elif defined(JACKBRIDGE_DIRECT)

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

  1134. #else

  1135.     if (usingNativeBridge)

  1136.         return nativeBridge->deactivate();

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

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

  1139. #endif

  1140.     return false;

  1141. }

  1142. 

  1143. bool jackbridge_is_realtime(jack_client_t* client)

  1144. {

  1145. #if defined(JACKBRIDGE_DUMMY)

  1146. #elif defined(JACKBRIDGE_DIRECT)

  1147.     return jack_is_realtime(client);

  1148. #else

  1149.     if (usingRealJACK)

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

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

  1152. #endif

  1153.     return false;

  1154. }

  1155. 

  1156. // --------------------------------------------------------------------------------------------------------------------

  1157. 

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

  1159. {

  1160. #if defined(JACKBRIDGE_DUMMY)

  1161. #elif defined(JACKBRIDGE_DIRECT)

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

  1163. #else

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

  1165.     {

  1166. # ifdef __WINE__

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

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

  1169. # else

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

  1171. # endif

  1172.     }

  1173. #endif

  1174.     return false;

  1175. }

  1176. 

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

  1178. {

  1179. #if defined(JACKBRIDGE_DUMMY)

  1180. #elif defined(JACKBRIDGE_DIRECT)

  1181.     jack_on_shutdown(client, shutdown_callback, arg);

  1182. #else

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

  1184.     {

  1185. # ifdef __WINE__

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

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

  1188. # else

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

  1190. # endif

  1191.     }

  1192. #endif

  1193. }

  1194. 

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

  1196. {

  1197. #if defined(JACKBRIDGE_DUMMY)

  1198. #elif defined(JACKBRIDGE_DIRECT)

  1199.     jack_on_info_shutdown(client, shutdown_callback, arg);

  1200. #else

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

  1202.     {

  1203. # ifdef __WINE__

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

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

  1206. # else

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

  1208. # endif

  1209.     }

  1210. #endif

  1211. }

  1212. 

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

  1214. {

  1215. #if defined(JACKBRIDGE_DUMMY)

  1216. #elif defined(JACKBRIDGE_DIRECT)

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

  1218. #else

  1219.     if (usingNativeBridge)

  1220.     {

  1221.         nativeBridge->jackProcessCallback = process_callback;

  1222.         nativeBridge->jackProcessArg = arg;

  1223.         return true;

  1224.     }

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

  1226.     {

  1227. # ifdef __WINE__

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

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

  1230. # else

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

  1232. # endif

  1233.     }

  1234. #endif

  1235.     return false;

  1236. }

  1237. 

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

  1239. {

  1240. #if defined(JACKBRIDGE_DUMMY)

  1241. #elif defined(JACKBRIDGE_DIRECT)

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

  1243. #else

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

  1245.     {

  1246. # ifdef __WINE__

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

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

  1249. # else

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

  1251. # endif

  1252.     }

  1253. #endif

  1254.     return false;

  1255. }

  1256. 

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

  1258. {

  1259. #if defined(JACKBRIDGE_DUMMY)

  1260. #elif defined(JACKBRIDGE_DIRECT)

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

  1262. #else

  1263.     if (usingNativeBridge)

  1264.     {

  1265.         nativeBridge->bufferSizeCallback = bufsize_callback;

  1266.         nativeBridge->jackBufferSizeArg = arg;

  1267.         return true;

  1268.     }

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

  1270.     {

  1271. # ifdef __WINE__

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

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

  1274. # else

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

  1276. # endif

  1277.     }

  1278. #endif

  1279.     return false;

  1280. }

  1281. 

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

  1283. {

  1284. #if defined(JACKBRIDGE_DUMMY)

  1285. #elif defined(JACKBRIDGE_DIRECT)

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

  1287. #else

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

  1289.     {

  1290. # ifdef __WINE__

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

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

  1293. # else

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

  1295. # endif

  1296.     }

  1297. #endif

  1298.     return false;

  1299. }

  1300. 

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

  1302. {

  1303. #if defined(JACKBRIDGE_DUMMY)

  1304. #elif defined(JACKBRIDGE_DIRECT)

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

  1306. #else

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

  1308.     {

  1309. # ifdef __WINE__

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

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

  1312. # else

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

  1314. # endif

  1315.     }

  1316. #endif

  1317.     return false;

  1318. }

  1319. 

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

  1321. {

  1322. #if defined(JACKBRIDGE_DUMMY)

  1323. #elif defined(JACKBRIDGE_DIRECT)

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

  1325. #else

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

  1327.     {

  1328. # ifdef __WINE__

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

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

  1331. # else

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

  1333. # endif

  1334.     }

  1335. #endif

  1336.     return false;

  1337. }

  1338. 

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

  1340. {

  1341. #if defined(JACKBRIDGE_DUMMY)

  1342. #elif defined(JACKBRIDGE_DIRECT)

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

  1344. #else

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

  1346.     {

  1347. # ifdef __WINE__

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

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

  1350. # else

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

  1352. # endif

  1353.     }

  1354. #endif

  1355.     return false;

  1356. }

  1357. 

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

  1359. {

  1360. #if defined(JACKBRIDGE_DUMMY)

  1361. #elif defined(JACKBRIDGE_DIRECT)

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

  1363. #else

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

  1365.     {

  1366. # ifdef __WINE__

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

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

  1369. # else

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

  1371. # endif

  1372.     }

  1373. #endif

  1374.     return false;

  1375. }

  1376. 

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

  1378. {

  1379. #if defined(JACKBRIDGE_DUMMY)

  1380. #elif defined(JACKBRIDGE_DIRECT)

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

  1382. #else

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

  1384.     {

  1385. # ifdef __WINE__

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

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

  1388. # else

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

  1390. # endif

  1391.     }

  1392. #endif

  1393.     return false;

  1394. }

  1395. 

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

  1397. {

  1398. #if defined(JACKBRIDGE_DUMMY)

  1399. #elif defined(JACKBRIDGE_DIRECT)

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

  1401. #else

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

  1403.     {

  1404. # ifdef __WINE__

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

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

  1407. # else

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

  1409. # endif

  1410.     }

  1411. #endif

  1412.     return false;

  1413. }

  1414. 

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

  1416. {

  1417. #if defined(JACKBRIDGE_DUMMY)

  1418. #elif defined(JACKBRIDGE_DIRECT)

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

  1420. #else

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

  1422.     {

  1423. # ifdef __WINE__

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

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

  1426. # else

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

  1428. # endif

  1429.     }

  1430. #endif

  1431.     return false;

  1432. }

  1433. 

  1434. // --------------------------------------------------------------------------------------------------------------------

  1435. 

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

  1437. {

  1438. #if defined(JACKBRIDGE_DUMMY)

  1439. #elif defined(JACKBRIDGE_DIRECT)

  1440.     return jack_set_freewheel(client, onoff);

  1441. #else

  1442.     if (usingRealJACK)

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

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

  1445. #endif

  1446.     return false;

  1447. }

  1448. 

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

  1450. {

  1451. #if defined(JACKBRIDGE_DUMMY)

  1452. #elif defined(JACKBRIDGE_DIRECT)

  1453.     return jack_set_buffer_size(client, nframes);

  1454. #else

  1455.     if (usingNativeBridge)

  1456.         return nativeBridge->requestBufferSizeChange(nframes);

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

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

  1459. #endif

  1460.     return false;

  1461. }

  1462. 

  1463. // --------------------------------------------------------------------------------------------------------------------

  1464. 

  1465. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1466. {

  1467. #if defined(JACKBRIDGE_DUMMY)

  1468. #elif defined(JACKBRIDGE_DIRECT)

  1469.     return jack_get_sample_rate(client);

  1470. #else

  1471.     if (usingNativeBridge)

  1472.         return nativeBridge->sampleRate;

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

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

  1475. #endif

  1476.     return 0;

  1477. }

  1478. 

  1479. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1480. {

  1481. #if defined(JACKBRIDGE_DUMMY)

  1482. #elif defined(JACKBRIDGE_DIRECT)

  1483.     return jack_get_buffer_size(client);

  1484. #else

  1485.     if (usingNativeBridge)

  1486.         return nativeBridge->bufferSize;

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

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

  1489. #endif

  1490.     return 0;

  1491. }

  1492. 

  1493. float jackbridge_cpu_load(jack_client_t* client)

  1494. {

  1495. #if defined(JACKBRIDGE_DUMMY)

  1496. #elif defined(JACKBRIDGE_DIRECT)

  1497.     return jack_cpu_load(client);

  1498. #else

  1499.     if (usingRealJACK)

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

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

  1502. #endif

  1503.     return 0.0f;

  1504. }

  1505. 

  1506. // --------------------------------------------------------------------------------------------------------------------

  1507. 

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

  1509. {

  1510. #if defined(JACKBRIDGE_DUMMY)

  1511. #elif defined(JACKBRIDGE_DIRECT)

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

  1513. #else

  1514.     if (usingNativeBridge)

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

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

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

  1518.                                                      static_cast<ulong>(flags),

  1519.                                                      static_cast<ulong>(buffer_size));

  1520. #endif

  1521.     return nullptr;

  1522. }

  1523. 

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

  1525. {

  1526. #if defined(JACKBRIDGE_DUMMY)

  1527. #elif defined(JACKBRIDGE_DIRECT)

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

  1529. #else

  1530.     if (usingRealJACK)

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

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

  1533. #endif

  1534.     return false;

  1535. }

  1536. 

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

  1538. {

  1539. #if defined(JACKBRIDGE_DUMMY)

  1540. #elif defined(JACKBRIDGE_DIRECT)

  1541.     return jack_port_get_buffer(port, nframes);

  1542. #else

  1543.     if (usingNativeBridge)

  1544.         return nativeBridge->getPortBuffer(port);

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

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

  1547. #endif

  1548.     return nullptr;

  1549. }

  1550. 

  1551. // --------------------------------------------------------------------------------------------------------------------

  1552. 

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

  1554. {

  1555. #if defined(JACKBRIDGE_DUMMY)

  1556. #elif defined(JACKBRIDGE_DIRECT)

  1557.     return jack_port_name(port);

  1558. #else

  1559.     if (usingRealJACK)

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

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

  1562. #endif

  1563.     return nullptr;

  1564. }

  1565. 

  1566. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1567. {

  1568. #if defined(JACKBRIDGE_DUMMY)

  1569. #elif defined(JACKBRIDGE_DIRECT)

  1570.     return jack_port_uuid(port);

  1571. #else

  1572.     if (usingRealJACK)

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

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

  1575. #endif

  1576.     return 0;

  1577. }

  1578. 

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

  1580. {

  1581. #if defined(JACKBRIDGE_DUMMY)

  1582. #elif defined(JACKBRIDGE_DIRECT)

  1583.     return jack_port_short_name(port);

  1584. #else

  1585.     if (usingRealJACK)

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

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

  1588. #endif

  1589.     return nullptr;

  1590. }

  1591. 

  1592. int jackbridge_port_flags(const jack_port_t* port)

  1593. {

  1594. #if defined(JACKBRIDGE_DUMMY)

  1595. #elif defined(JACKBRIDGE_DIRECT)

  1596.     return jack_port_flags(port);

  1597. #else

  1598.     if (usingRealJACK)

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

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

  1601. #endif

  1602.     return 0x0;

  1603. }

  1604. 

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

  1606. {

  1607. #if defined(JACKBRIDGE_DUMMY)

  1608. #elif defined(JACKBRIDGE_DIRECT)

  1609.     return jack_port_type(port);

  1610. #else

  1611.     if (usingRealJACK)

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

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

  1614. #endif

  1615.     return nullptr;

  1616. }

  1617. 

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

  1619. {

  1620. #if defined(JACKBRIDGE_DUMMY)

  1621. #elif defined(JACKBRIDGE_DIRECT)

  1622.     return jack_port_is_mine(client, port);

  1623. #else

  1624.     if (usingRealJACK)

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

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

  1627. #endif

  1628.     return false;

  1629. }

  1630. 

  1631. int jackbridge_port_connected(const jack_port_t* port)

  1632. {

  1633. #if defined(JACKBRIDGE_DUMMY)

  1634. #elif defined(JACKBRIDGE_DIRECT)

  1635.     return jack_port_connected(port);

  1636. #else

  1637.     if (usingRealJACK)

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

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

  1640. #endif

  1641.     return 0;

  1642. }

  1643. 

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

  1645. {

  1646. #if defined(JACKBRIDGE_DUMMY)

  1647. #elif defined(JACKBRIDGE_DIRECT)

  1648.     return jack_port_connected_to(port, port_name);

  1649. #else

  1650.     if (usingRealJACK)

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

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

  1653. #endif

  1654.     return false;

  1655. }

  1656. 

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

  1658. {

  1659. #if defined(JACKBRIDGE_DUMMY)

  1660. #elif defined(JACKBRIDGE_DIRECT)

  1661.     return jack_port_get_connections(port);

  1662. #else

  1663.     if (usingRealJACK)

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

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

  1666. #endif

  1667.     return nullptr;

  1668. }

  1669. 

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

  1671. {

  1672. #if defined(JACKBRIDGE_DUMMY)

  1673. #elif defined(JACKBRIDGE_DIRECT)

  1674.     return jack_port_get_all_connections(client, port);

  1675. #else

  1676.     if (usingRealJACK)

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

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

  1679. #endif

  1680.     return nullptr;

  1681. }

  1682. 

  1683. // --------------------------------------------------------------------------------------------------------------------

  1684. 

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

  1686. {

  1687. #if defined(JACKBRIDGE_DUMMY)

  1688. #elif defined(JACKBRIDGE_DIRECT)

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

  1690. #else

  1691.     if (usingNativeBridge)

  1692.         return false;

  1693.     // Try new API first

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

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

  1696.     // Try old API if using JACK2

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

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

  1699. #endif

  1700.     return false;

  1701. }

  1702. 

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

  1704. {

  1705. #if defined(JACKBRIDGE_DUMMY)

  1706. #elif defined(JACKBRIDGE_DIRECT)

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

  1708. #else

  1709.     if (usingRealJACK)

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

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

  1712. #endif

  1713.     return false;

  1714. }

  1715. 

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

  1717. {

  1718. #if defined(JACKBRIDGE_DUMMY)

  1719. #elif defined(JACKBRIDGE_DIRECT)

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

  1721. #else

  1722.     if (usingRealJACK)

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

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

  1725. #endif

  1726.     return false;

  1727. }

  1728. 

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

  1730. {

  1731. #if defined(JACKBRIDGE_DUMMY)

  1732. #elif defined(JACKBRIDGE_DIRECT)

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

  1734. #else

  1735.     if (usingRealJACK)

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

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

  1738. #endif

  1739.     return 0;

  1740. }

  1741. 

  1742. // --------------------------------------------------------------------------------------------------------------------

  1743. 

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

  1745. {

  1746. #if defined(JACKBRIDGE_DUMMY)

  1747. #elif defined(JACKBRIDGE_DIRECT)

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

  1749. #else

  1750.     if (usingRealJACK)

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

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

  1753. #endif

  1754.     return false;

  1755. }

  1756. 

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

  1758. {

  1759. #if defined(JACKBRIDGE_DUMMY)

  1760. #elif defined(JACKBRIDGE_DIRECT)

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

  1762. #else

  1763.     if (usingRealJACK)

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

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

  1766. #endif

  1767.     return false;

  1768. }

  1769. 

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

  1771. {

  1772. #if defined(JACKBRIDGE_DUMMY)

  1773. #elif defined(JACKBRIDGE_DIRECT)

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

  1775. #else

  1776.     if (usingRealJACK)

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

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

  1779. #endif

  1780.     return false;

  1781. }

  1782. 

  1783. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1784. {

  1785. #if defined(JACKBRIDGE_DUMMY)

  1786. #elif defined(JACKBRIDGE_DIRECT)

  1787.     return jack_port_monitoring_input(port);

  1788. #else

  1789.     if (usingRealJACK)

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

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

  1792. #endif

  1793.     return false;

  1794. }

  1795. 

  1796. // --------------------------------------------------------------------------------------------------------------------

  1797. 

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

  1799. {

  1800. #if defined(JACKBRIDGE_DUMMY)

  1801. #elif defined(JACKBRIDGE_DIRECT)

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

  1803. #else

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

  1805.     {

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

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

  1808.     }

  1809. #endif

  1810.     return false;

  1811. }

  1812. 

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

  1814. {

  1815. #if defined(JACKBRIDGE_DUMMY)

  1816. #elif defined(JACKBRIDGE_DIRECT)

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

  1818. #else

  1819.     if (usingRealJACK)

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

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

  1822. #endif

  1823.     return false;

  1824. }

  1825. 

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

  1827. {

  1828. #if defined(JACKBRIDGE_DUMMY)

  1829. #elif defined(JACKBRIDGE_DIRECT)

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

  1831. #else

  1832.     if (usingRealJACK)

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

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

  1835. #endif

  1836.     return false;

  1837. }

  1838. 

  1839. 

  1840. // --------------------------------------------------------------------------------------------------------------------

  1841. 

  1842. int jackbridge_port_name_size()

  1843. {

  1844. #if defined(JACKBRIDGE_DUMMY)

  1845. #elif defined(JACKBRIDGE_DIRECT)

  1846.     return jack_port_name_size();

  1847. #else

  1848.     if (usingRealJACK)

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

  1850.             return getBridgeInstance().port_name_size_ptr();

  1851. #endif

  1852.     return 256;

  1853. }

  1854. 

  1855. int jackbridge_port_type_size()

  1856. {

  1857. #if defined(JACKBRIDGE_DUMMY)

  1858. #elif defined(JACKBRIDGE_DIRECT)

  1859.     return jack_port_type_size();

  1860. #else

  1861.     if (usingRealJACK)

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

  1863.             return getBridgeInstance().port_type_size_ptr();

  1864. #endif

  1865.     return 32;

  1866. }

  1867. 

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

  1869. {

  1870. #if defined(JACKBRIDGE_DUMMY)

  1871. #elif defined(JACKBRIDGE_DIRECT)

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

  1873. #else

  1874.     if (usingRealJACK)

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

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

  1877. #endif

  1878.     return 0;

  1879. }

  1880. 

  1881. 

  1882. // --------------------------------------------------------------------------------------------------------------------

  1883. 

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

  1885. {

  1886. #if defined(JACKBRIDGE_DUMMY)

  1887. #elif defined(JACKBRIDGE_DIRECT)

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

  1889. #else

  1890.     if (usingRealJACK)

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

  1892.             return getBridgeInstance().port_get_latency_range_ptr(port,

  1893.                                                                   static_cast<jack_latency_callback_mode_t>(mode),

  1894.                                                                   range);

  1895. #endif

  1896.     range->min = 0;

  1897.     range->max = 0;

  1898. }

  1899. 

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

  1901. {

  1902. #if defined(JACKBRIDGE_DUMMY)

  1903. #elif defined(JACKBRIDGE_DIRECT)

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

  1905. #else

  1906.     if (usingRealJACK)

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

  1908.             getBridgeInstance().port_set_latency_range_ptr(port,

  1909.                                                            static_cast<jack_latency_callback_mode_t>(mode),

  1910.                                                            range);

  1911. #endif

  1912. }

  1913. 

  1914. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1915. {

  1916. #if defined(JACKBRIDGE_DUMMY)

  1917. #elif defined(JACKBRIDGE_DIRECT)

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

  1919. #else

  1920.     if (usingRealJACK)

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

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

  1923. #endif

  1924.     return false;

  1925. }

  1926. 

  1927. 

  1928. // --------------------------------------------------------------------------------------------------------------------

  1929. 

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

  1931. {

  1932. #if defined(JACKBRIDGE_DUMMY)

  1933. #elif defined(JACKBRIDGE_DIRECT)

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

  1935. #else

  1936.     if (usingRealJACK)

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

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

  1939.                                                      static_cast<ulong>(flags));

  1940. #endif

  1941.     return nullptr;

  1942. }

  1943. 

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

  1945. {

  1946. #if defined(JACKBRIDGE_DUMMY)

  1947. #elif defined(JACKBRIDGE_DIRECT)

  1948.     return jack_port_by_name(client, port_name);

  1949. #else

  1950.     if (usingRealJACK)

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

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

  1953. #endif

  1954.     return nullptr;

  1955. }

  1956. 

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

  1958. {

  1959. #if defined(JACKBRIDGE_DUMMY)

  1960. #elif defined(JACKBRIDGE_DIRECT)

  1961.     return jack_port_by_id(client, port_id);

  1962. #else

  1963.     if (usingRealJACK)

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

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

  1966. #endif

  1967.     return nullptr;

  1968. }

  1969. 

  1970. 

  1971. // --------------------------------------------------------------------------------------------------------------------

  1972. 

  1973. void jackbridge_free(void* ptr)

  1974. {

  1975. #if defined(JACKBRIDGE_DUMMY)

  1976. #elif defined(JACKBRIDGE_DIRECT)

  1977.     return jack_free(ptr);

  1978. #else

  1979.     if (usingRealJACK)

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

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

  1982. 

  1983.     // just in case

  1984.     std::free(ptr);

  1985. #endif

  1986. }

  1987. 

  1988. 

  1989. // --------------------------------------------------------------------------------------------------------------------

  1990. 

  1991. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1992. {

  1993. #if defined(JACKBRIDGE_DUMMY)

  1994. #elif defined(JACKBRIDGE_DIRECT)

  1995.     return jack_midi_get_event_count(port_buffer);

  1996. #else

  1997.     if (usingNativeBridge)

  1998.         return nativeBridge->getEventCount();

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

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

  2001. #endif

  2002.     return 0;

  2003. }

  2004. 

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

  2006. {

  2007. #if defined(JACKBRIDGE_DUMMY)

  2008. #elif defined(JACKBRIDGE_DIRECT)

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

  2010. #else

  2011.     if (usingNativeBridge)

  2012.         return nativeBridge->getEvent(event);

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

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

  2015. #endif

  2016.     return false;

  2017. }

  2018. 

  2019. void jackbridge_midi_clear_buffer(void* port_buffer)

  2020. {

  2021. #if defined(JACKBRIDGE_DUMMY)

  2022. #elif defined(JACKBRIDGE_DIRECT)

  2023.     jack_midi_clear_buffer(port_buffer);

  2024. #else

  2025.     if (usingNativeBridge)

  2026.         return nativeBridge->clearEventBuffer();

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

  2028.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  2029. #endif

  2030. }

  2031. 

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

  2033. {

  2034. #if defined(JACKBRIDGE_DUMMY)

  2035. #elif defined(JACKBRIDGE_DIRECT)

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

  2037. #else

  2038.     if (usingNativeBridge)

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

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

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

  2042. #endif

  2043.     return false;

  2044. }

  2045. 

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

  2047. {

  2048. #if defined(JACKBRIDGE_DUMMY)

  2049. #elif defined(JACKBRIDGE_DIRECT)

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

  2051. #else

  2052.     if (usingRealJACK)

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

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

  2055. #endif

  2056.     return nullptr;

  2057. }

  2058. 

  2059. 

  2060. // --------------------------------------------------------------------------------------------------------------------

  2061. 

  2062. bool jackbridge_release_timebase(jack_client_t* client)

  2063. {

  2064. #if defined(JACKBRIDGE_DUMMY)

  2065. #elif defined(JACKBRIDGE_DIRECT)

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

  2067. #else

  2068.     if (usingRealJACK)

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

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

  2071. #endif

  2072.     return false;

  2073. }

  2074. 

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

  2076. {

  2077. #if defined(JACKBRIDGE_DUMMY)

  2078. #elif defined(JACKBRIDGE_DIRECT)

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

  2080. #else

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

  2082.     {

  2083. # ifdef __WINE__

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

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

  2086. # else

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

  2088. # endif

  2089.     }

  2090. #endif

  2091.     return false;

  2092. }

  2093. 

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

  2095. {

  2096. #if defined(JACKBRIDGE_DUMMY)

  2097. #elif defined(JACKBRIDGE_DIRECT)

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

  2099. #else

  2100.     if (usingRealJACK)

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

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

  2103. #endif

  2104.     return false;

  2105. }

  2106. 

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

  2108. {

  2109. #if defined(JACKBRIDGE_DUMMY)

  2110. #elif defined(JACKBRIDGE_DIRECT)

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

  2112. #else

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

  2114.     {

  2115. # ifdef __WINE__

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

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

  2118. # else

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

  2120. # endif

  2121.     }

  2122. #endif

  2123.     return false;

  2124. }

  2125. 

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

  2127. {

  2128. #if defined(JACKBRIDGE_DUMMY)

  2129. #elif defined(JACKBRIDGE_DIRECT)

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

  2131. #else

  2132.     if (usingRealJACK)

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

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

  2135. #endif

  2136.     return false;

  2137. }

  2138. 

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

  2140. {

  2141. #if defined(JACKBRIDGE_DUMMY)

  2142. #elif defined(JACKBRIDGE_DIRECT)

  2143.     return jack_transport_query(client, pos);

  2144. #else

  2145.     if (usingRealJACK)

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

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

  2148. #endif

  2149.     if (pos != nullptr)

  2150.     {

  2151.         // invalidate

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

  2153.         pos->unique_1 = 0;

  2154.         pos->unique_2 = 1;

  2155.     }

  2156.     return JackTransportStopped;

  2157. }

  2158. 

  2159. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  2160. {

  2161. #if defined(JACKBRIDGE_DUMMY)

  2162. #elif defined(JACKBRIDGE_DIRECT)

  2163.     return jack_get_current_transport_frame(client);

  2164. #else

  2165.     if (usingRealJACK)

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

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

  2168. #endif

  2169.     return 0;

  2170. }

  2171. 

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

  2173. {

  2174. #if defined(JACKBRIDGE_DUMMY)

  2175. #elif defined(JACKBRIDGE_DIRECT)

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

  2177. #else

  2178.     if (usingRealJACK)

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

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

  2181. #endif

  2182.     return false;

  2183. }

  2184. 

  2185. void jackbridge_transport_start(jack_client_t* client)

  2186. {

  2187. #if defined(JACKBRIDGE_DUMMY)

  2188. #elif defined(JACKBRIDGE_DIRECT)

  2189.     jack_transport_start(client);

  2190. #else

  2191.     if (usingRealJACK)

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

  2193.             getBridgeInstance().transport_start_ptr(client);

  2194. #endif

  2195. }

  2196. 

  2197. void jackbridge_transport_stop(jack_client_t* client)

  2198. {

  2199. #if defined(JACKBRIDGE_DUMMY)

  2200. #elif defined(JACKBRIDGE_DIRECT)

  2201.     jack_transport_stop(client);

  2202. #else

  2203.     if (usingRealJACK)

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

  2205.             getBridgeInstance().transport_stop_ptr(client);

  2206. #endif

  2207. }

  2208. 

  2209. 

  2210. // --------------------------------------------------------------------------------------------------------------------

  2211. 

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

  2213. {

  2214. #if defined(JACKBRIDGE_DUMMY)

  2215. #elif defined(JACKBRIDGE_DIRECT)

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

  2217. #else

  2218.     if (usingRealJACK)

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

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

  2221. #endif

  2222.     return false;

  2223. }

  2224. 

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

  2226. {

  2227. #if defined(JACKBRIDGE_DUMMY)

  2228. #elif defined(JACKBRIDGE_DIRECT)

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

  2230. #else

  2231.     if (usingRealJACK)

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

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

  2234. #endif

  2235.     return false;

  2236. }

  2237. 

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

  2239. {

  2240. #if defined(JACKBRIDGE_DUMMY)

  2241. #elif defined(JACKBRIDGE_DIRECT)

  2242.     jack_free_description(desc, free_description_itself);

  2243. #else

  2244.     if (usingRealJACK)

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

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

  2247. #endif

  2248. }

  2249. 

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

  2251. {

  2252. #if defined(JACKBRIDGE_DUMMY)

  2253. #elif defined(JACKBRIDGE_DIRECT)

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

  2255. #else

  2256.     if (usingRealJACK)

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

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

  2259. #endif

  2260.     return false;

  2261. }

  2262. 

  2263. bool jackbridge_get_all_properties(jack_description_t** descs)

  2264. {

  2265. #if defined(JACKBRIDGE_DUMMY)

  2266. #elif defined(JACKBRIDGE_DIRECT)

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

  2268. #else

  2269.     if (usingRealJACK)

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

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

  2272. #endif

  2273.     return false;

  2274. }

  2275. 

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

  2277. {

  2278. #if defined(JACKBRIDGE_DUMMY)

  2279. #elif defined(JACKBRIDGE_DIRECT)

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

  2281. #else

  2282.     if (usingRealJACK)

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

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

  2285. #endif

  2286.     return false;

  2287. }

  2288. 

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

  2290. {

  2291. #if defined(JACKBRIDGE_DUMMY)

  2292. #elif defined(JACKBRIDGE_DIRECT)

  2293.     return jack_remove_properties(client, subject);

  2294. #else

  2295.     if (usingRealJACK)

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

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

  2298. #endif

  2299.     return 0;

  2300. }

  2301. 

  2302. bool jackbridge_remove_all_properties(jack_client_t* client)

  2303. {

  2304. #if defined(JACKBRIDGE_DUMMY)

  2305. #elif defined(JACKBRIDGE_DIRECT)

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

  2307. #else

  2308.     if (usingRealJACK)

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

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

  2311. #endif

  2312.     return false;

  2313. }

  2314. 

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

  2316. {

  2317. #if defined(JACKBRIDGE_DUMMY)

  2318. #elif defined(JACKBRIDGE_DIRECT)

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

  2320. #else

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

  2322.     {

  2323. # ifdef __WINE__

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

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

  2326. # else

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

  2328. # endif

  2329.     }

  2330. #endif

  2331.     return false;

  2332. }

  2333. 

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

  2335. {

  2336. #if defined(JACKBRIDGE_DUMMY)

  2337. #elif defined(JACKBRIDGE_DIRECT)

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

  2339. #else

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

  2341.     {

  2342. # ifdef __WINE__

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

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

  2345. # else

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

  2347. # endif

  2348.     }

  2349. #endif

  2350.     return false;

  2351. }

  2352. 

  2353. jack_nframes_t jackbridge_cycle_wait(jack_client_t* client)

  2354. {

  2355. #if defined(JACKBRIDGE_DUMMY)

  2356. #elif defined(JACKBRIDGE_DIRECT)

  2357.     return jack_cycle_wait(client);

  2358. #else

  2359.     if (usingRealJACK)

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

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

  2362. #endif

  2363.     return 0;

  2364. }

  2365. 

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

  2367. {

  2368. #if defined(JACKBRIDGE_DUMMY)

  2369. #elif defined(JACKBRIDGE_DIRECT)

  2370.     jack_cycle_signal(client, status);

  2371. #else

  2372.     if (usingRealJACK)

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

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

  2375. #endif

  2376. }

  2377. 

  2378. 

  2379. // --------------------------------------------------------------------------------------------------------------------

  2380. 

  2381. #ifndef JACKBRIDGE_SKIP_NATIVE_UTILS

  2382. 

  2383. START_NAMESPACE_DISTRHO

  2384. 

  2385. bool isUsingNativeAudio() noexcept

  2386. {

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

  2388.     return false;

  2389. #else

  2390.     return usingNativeBridge;

  2391. #endif

  2392. }

  2393. 

  2394. bool supportsAudioInput()

  2395. {

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

  2397.     if (usingNativeBridge)

  2398.         return nativeBridge->supportsAudioInput();

  2399. #endif

  2400.     return false;

  2401. }

  2402. 

  2403. bool supportsBufferSizeChanges()

  2404. {

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

  2406.     if (usingNativeBridge)

  2407.         return nativeBridge->supportsBufferSizeChanges();

  2408. #endif

  2409.     return false;

  2410. }

  2411. 

  2412. bool supportsMIDI()

  2413. {

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

  2415.     if (usingNativeBridge)

  2416.         return nativeBridge->supportsMIDI();

  2417. #endif

  2418.     return false;

  2419. }

  2420. 

  2421. bool isAudioInputEnabled()

  2422. {

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

  2424.     if (usingNativeBridge)

  2425.         return nativeBridge->isAudioInputEnabled();

  2426. #endif

  2427.     return false;

  2428. }

  2429. 

  2430. bool isMIDIEnabled()

  2431. {

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

  2433.     if (usingNativeBridge)

  2434.         return nativeBridge->isMIDIEnabled();

  2435. #endif

  2436.     return false;

  2437. }

  2438. 

  2439. uint getBufferSize()

  2440. {

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

  2442.     if (usingNativeBridge)

  2443.         return nativeBridge->getBufferSize();

  2444. #endif

  2445.     return 0;

  2446. }

  2447. 

  2448. bool requestAudioInput()

  2449. {

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

  2451.     if (usingNativeBridge)

  2452.         return nativeBridge->requestAudioInput();

  2453. #endif

  2454.     return false;

  2455. }

  2456. 

  2457. bool requestBufferSizeChange(const uint newBufferSize)

  2458. {

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

  2460.     if (usingNativeBridge)

  2461.         return nativeBridge->requestBufferSizeChange(newBufferSize);

  2462. #endif

  2463.     return false;

  2464. }

  2465. 

  2466. bool requestMIDI()

  2467. {

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

  2469.     if (usingNativeBridge)

  2470.         return nativeBridge->requestMIDI();

  2471. #endif

  2472.     return false;

  2473. }

  2474. 

  2475. END_NAMESPACE_DISTRHO

  2476. 

  2477. #endif // JACKBRIDGE_SKIP_NATIVE_UTILS

  2478. 

  2479. 

  2480. // --------------------------------------------------------------------------------------------------------------------