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

2373 lines
80KB
Raw Blame History 

  1. /*

  2.  * JackBridge for DPF

  3.  * Copyright (C) 2013-2022 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * Permission to use, copy, modify, and/or distribute this software for any purpose with

  6.  * or without fee is hereby granted, provided that the above copyright notice and this

  7.  * permission notice appear in all copies.

  8.  *

  9.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  10.  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  11.  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  12.  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  13.  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  14.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  15.  */

  16. 

  17. #include "JackBridge.hpp"

  18. #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. # include "RtAudioBridge.hpp"

  68. # ifdef RTAUDIO_API_TYPE

  69. #  include "rtaudio/RtAudio.cpp"

  70. # endif

  71. # ifdef RTMIDI_API_TYPE

  72. #  include "rtmidi/RtMidi.cpp"

  73. # endif

  74. # undef Point

  75. # undef Size

  76. #endif

  77. 

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

  79. # include "SDL2Bridge.hpp"

  80. #endif

  81. 

  82. // -----------------------------------------------------------------------------

  83. 

  84. extern "C" {

  85. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  104. 

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

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

  107. 

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

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

  110. 

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

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

  113. 

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

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

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

  117. 

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

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

  120. 

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

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

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

  124. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  139. 

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

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

  142. 

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

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

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

  146. 

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

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

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

  150. 

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

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

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

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

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

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

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

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

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

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

  161. 

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

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

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

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

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

  167. 

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

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

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

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

  172. 

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

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

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

  176. 

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

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

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

  180. 

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

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

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

  184. 

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

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

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

  188. 

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

  190. 

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

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

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

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

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

  196. 

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

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

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

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

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

  202. 

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

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

  205. 

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

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

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

  209. 

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

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

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

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

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

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

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

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

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

  219. 

  220. #ifdef __WINE__

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

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

  223. #endif

  224. 

  225. } // extern "C"

  226. 

  227. // -----------------------------------------------------------------------------

  228. 

  229. struct JackBridge {

  230.     lib_t lib;

  231. 

  232.     jacksym_get_version get_version_ptr;

  233.     jacksym_get_version_string get_version_string_ptr;

  234. 

  235.     jacksym_client_open client_open_ptr;

  236.     jacksym_client_close client_close_ptr;

  237. 

  238.     jacksym_client_name_size client_name_size_ptr;

  239.     jacksym_get_client_name get_client_name_ptr;

  240. 

  241.     jacksym_client_get_uuid client_get_uuid_ptr;

  242.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  243.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  244. 

  245.     jacksym_uuid_parse uuid_parse_ptr;

  246.     jacksym_uuid_unparse uuid_unparse_ptr;

  247. 

  248.     jacksym_activate activate_ptr;

  249.     jacksym_deactivate deactivate_ptr;

  250.     jacksym_is_realtime is_realtime_ptr;

  251. 

  252.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  253.     jacksym_on_shutdown on_shutdown_ptr;

  254.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  255.     jacksym_set_process_callback set_process_callback_ptr;

  256.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  257.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  258.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  259.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  260.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  261.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  262.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  263.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  264.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  265.     jacksym_set_latency_callback set_latency_callback_ptr;

  266. 

  267.     jacksym_set_freewheel set_freewheel_ptr;

  268.     jacksym_set_buffer_size set_buffer_size_ptr;

  269. 

  270.     jacksym_get_sample_rate get_sample_rate_ptr;

  271.     jacksym_get_buffer_size get_buffer_size_ptr;

  272.     jacksym_cpu_load cpu_load_ptr;

  273. 

  274.     jacksym_port_register port_register_ptr;

  275.     jacksym_port_unregister port_unregister_ptr;

  276.     jacksym_port_get_buffer port_get_buffer_ptr;

  277. 

  278.     jacksym_port_name port_name_ptr;

  279.     jacksym_port_uuid port_uuid_ptr;

  280.     jacksym_port_short_name port_short_name_ptr;

  281.     jacksym_port_flags port_flags_ptr;

  282.     jacksym_port_type port_type_ptr;

  283.     jacksym_port_is_mine port_is_mine_ptr;

  284.     jacksym_port_connected port_connected_ptr;

  285.     jacksym_port_connected_to port_connected_to_ptr;

  286.     jacksym_port_get_connections port_get_connections_ptr;

  287.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  288. 

  289.     jacksym_port_rename port_rename_ptr;

  290.     jacksym_port_set_name port_set_name_ptr;

  291.     jacksym_port_set_alias port_set_alias_ptr;

  292.     jacksym_port_unset_alias port_unset_alias_ptr;

  293.     jacksym_port_get_aliases port_get_aliases_ptr;

  294. 

  295.     jacksym_port_request_monitor port_request_monitor_ptr;

  296.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  297.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  298.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  299. 

  300.     jacksym_connect connect_ptr;

  301.     jacksym_disconnect disconnect_ptr;

  302.     jacksym_port_disconnect port_disconnect_ptr;

  303. 

  304.     jacksym_port_name_size port_name_size_ptr;

  305.     jacksym_port_type_size port_type_size_ptr;

  306.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  307. 

  308.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  309.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  310.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  311. 

  312.     jacksym_get_ports get_ports_ptr;

  313.     jacksym_port_by_name port_by_name_ptr;

  314.     jacksym_port_by_id port_by_id_ptr;

  315. 

  316.     jacksym_free free_ptr;

  317. 

  318.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  319.     jacksym_midi_event_get midi_event_get_ptr;

  320.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  321.     jacksym_midi_event_write midi_event_write_ptr;

  322.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  323. 

  324.     jacksym_release_timebase release_timebase_ptr;

  325.     jacksym_set_sync_callback set_sync_callback_ptr;

  326.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  327.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  328.     jacksym_transport_locate transport_locate_ptr;

  329. 

  330.     jacksym_transport_query transport_query_ptr;

  331.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  332. 

  333.     jacksym_transport_reposition transport_reposition_ptr;

  334.     jacksym_transport_start transport_start_ptr;

  335.     jacksym_transport_stop transport_stop_ptr;

  336. 

  337.     jacksym_set_property set_property_ptr;

  338.     jacksym_get_property get_property_ptr;

  339.     jacksym_free_description free_description_ptr;

  340.     jacksym_get_properties get_properties_ptr;

  341.     jacksym_get_all_properties get_all_properties_ptr;

  342.     jacksym_remove_property remove_property_ptr;

  343.     jacksym_remove_properties remove_properties_ptr;

  344.     jacksym_remove_all_properties remove_all_properties_ptr;

  345.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  346. 

  347.    #ifdef __WINE__

  348.     jacksym_set_thread_creator set_thread_creator_ptr;

  349.    #endif

  350. 

  351.     JackBridge()

  352.         : lib(nullptr),

  353.           get_version_ptr(nullptr),

  354.           get_version_string_ptr(nullptr),

  355.           client_open_ptr(nullptr),

  356.           client_close_ptr(nullptr),

  357.           client_name_size_ptr(nullptr),

  358.           get_client_name_ptr(nullptr),

  359.           client_get_uuid_ptr(nullptr),

  360.           get_uuid_for_client_name_ptr(nullptr),

  361.           get_client_name_by_uuid_ptr(nullptr),

  362.           uuid_parse_ptr(nullptr),

  363.           uuid_unparse_ptr(nullptr),

  364.           activate_ptr(nullptr),

  365.           deactivate_ptr(nullptr),

  366.           is_realtime_ptr(nullptr),

  367.           set_thread_init_callback_ptr(nullptr),

  368.           on_shutdown_ptr(nullptr),

  369.           on_info_shutdown_ptr(nullptr),

  370.           set_process_callback_ptr(nullptr),

  371.           set_freewheel_callback_ptr(nullptr),

  372.           set_buffer_size_callback_ptr(nullptr),

  373.           set_sample_rate_callback_ptr(nullptr),

  374.           set_client_registration_callback_ptr(nullptr),

  375.           set_port_registration_callback_ptr(nullptr),

  376.           set_port_rename_callback_ptr(nullptr),

  377.           set_port_connect_callback_ptr(nullptr),

  378.           set_graph_order_callback_ptr(nullptr),

  379.           set_xrun_callback_ptr(nullptr),

  380.           set_latency_callback_ptr(nullptr),

  381.           set_freewheel_ptr(nullptr),

  382.           set_buffer_size_ptr(nullptr),

  383.           get_sample_rate_ptr(nullptr),

  384.           get_buffer_size_ptr(nullptr),

  385.           cpu_load_ptr(nullptr),

  386.           port_register_ptr(nullptr),

  387.           port_unregister_ptr(nullptr),

  388.           port_get_buffer_ptr(nullptr),

  389.           port_name_ptr(nullptr),

  390.           port_uuid_ptr(nullptr),

  391.           port_short_name_ptr(nullptr),

  392.           port_flags_ptr(nullptr),

  393.           port_type_ptr(nullptr),

  394.           port_is_mine_ptr(nullptr),

  395.           port_connected_ptr(nullptr),

  396.           port_connected_to_ptr(nullptr),

  397.           port_get_connections_ptr(nullptr),

  398.           port_get_all_connections_ptr(nullptr),

  399.           port_rename_ptr(nullptr),

  400.           port_set_name_ptr(nullptr),

  401.           port_set_alias_ptr(nullptr),

  402.           port_unset_alias_ptr(nullptr),

  403.           port_get_aliases_ptr(nullptr),

  404.           port_request_monitor_ptr(nullptr),

  405.           port_request_monitor_by_name_ptr(nullptr),

  406.           port_ensure_monitor_ptr(nullptr),

  407.           port_monitoring_input_ptr(nullptr),

  408.           connect_ptr(nullptr),

  409.           disconnect_ptr(nullptr),

  410.           port_disconnect_ptr(nullptr),

  411.           port_name_size_ptr(nullptr),

  412.           port_type_size_ptr(nullptr),

  413.           port_type_get_buffer_size_ptr(nullptr),

  414.           port_get_latency_range_ptr(nullptr),

  415.           port_set_latency_range_ptr(nullptr),

  416.           recompute_total_latencies_ptr(nullptr),

  417.           get_ports_ptr(nullptr),

  418.           port_by_name_ptr(nullptr),

  419.           port_by_id_ptr(nullptr),

  420.           free_ptr(nullptr),

  421.           midi_get_event_count_ptr(nullptr),

  422.           midi_event_get_ptr(nullptr),

  423.           midi_clear_buffer_ptr(nullptr),

  424.           midi_event_write_ptr(nullptr),

  425.           midi_event_reserve_ptr(nullptr),

  426.           release_timebase_ptr(nullptr),

  427.           set_sync_callback_ptr(nullptr),

  428.           set_sync_timeout_ptr(nullptr),

  429.           set_timebase_callback_ptr(nullptr),

  430.           transport_locate_ptr(nullptr),

  431.           transport_query_ptr(nullptr),

  432.           get_current_transport_frame_ptr(nullptr),

  433.           transport_reposition_ptr(nullptr),

  434.           transport_start_ptr(nullptr),

  435.           transport_stop_ptr(nullptr),

  436.           set_property_ptr(nullptr),

  437.           get_property_ptr(nullptr),

  438.           free_description_ptr(nullptr),

  439.           get_properties_ptr(nullptr),

  440.           get_all_properties_ptr(nullptr),

  441.           remove_property_ptr(nullptr),

  442.           remove_properties_ptr(nullptr),

  443.           remove_all_properties_ptr(nullptr),

  444.           set_property_change_callback_ptr(nullptr)

  445.          #ifdef __WINE__

  446.         , set_thread_creator_ptr(nullptr)

  447.          #endif

  448.     {

  449.       #ifdef HAVE_JACK

  450.        #if defined(DISTRHO_OS_MAC)

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

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

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

  454.        #elif defined(DISTRHO_OS_WINDOWS)

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

  456.        #else

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

  458.        #endif

  459. 

  460.         USE_NAMESPACE_DISTRHO

  461. 

  462.         lib = lib_open(filename);

  463. 

  464.         if (lib == nullptr)

  465.         {

  466.             fprintf(stderr, "Failed to load JACK DLL, reason:\n%s\n", lib_error(filename));

  467.             return;

  468.         }

  469.         else

  470.         {

  471.             fprintf(stdout, "%s loaded successfully!\n", filename);

  472.         }

  473. 

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

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

  476. 

  477.         LIB_SYMBOL(get_version)

  478.         LIB_SYMBOL(get_version_string)

  479. 

  480.         LIB_SYMBOL(client_open)

  481.         LIB_SYMBOL(client_close)

  482. 

  483.         LIB_SYMBOL(client_name_size)

  484.         LIB_SYMBOL(get_client_name)

  485. 

  486.         LIB_SYMBOL(client_get_uuid)

  487.         LIB_SYMBOL(get_uuid_for_client_name)

  488.         LIB_SYMBOL(get_client_name_by_uuid)

  489. 

  490.         LIB_SYMBOL(uuid_parse)

  491.         LIB_SYMBOL(uuid_unparse)

  492. 

  493.         LIB_SYMBOL(activate)

  494.         LIB_SYMBOL(deactivate)

  495.         LIB_SYMBOL(is_realtime)

  496. 

  497.         LIB_SYMBOL(set_thread_init_callback)

  498.         LIB_SYMBOL(on_shutdown)

  499.         LIB_SYMBOL(on_info_shutdown)

  500.         LIB_SYMBOL(set_process_callback)

  501.         LIB_SYMBOL(set_freewheel_callback)

  502.         LIB_SYMBOL(set_buffer_size_callback)

  503.         LIB_SYMBOL(set_sample_rate_callback)

  504.         LIB_SYMBOL(set_client_registration_callback)

  505.         LIB_SYMBOL(set_port_registration_callback)

  506.         LIB_SYMBOL(set_port_rename_callback)

  507.         LIB_SYMBOL(set_port_connect_callback)

  508.         LIB_SYMBOL(set_graph_order_callback)

  509.         LIB_SYMBOL(set_xrun_callback)

  510.         LIB_SYMBOL(set_latency_callback)

  511. 

  512.         LIB_SYMBOL(set_freewheel)

  513.         LIB_SYMBOL(set_buffer_size)

  514. 

  515.         LIB_SYMBOL(get_sample_rate)

  516.         LIB_SYMBOL(get_buffer_size)

  517.         LIB_SYMBOL(cpu_load)

  518. 

  519.         LIB_SYMBOL(port_register)

  520.         LIB_SYMBOL(port_unregister)

  521.         LIB_SYMBOL(port_get_buffer)

  522. 

  523.         LIB_SYMBOL(port_name)

  524.         LIB_SYMBOL(port_uuid)

  525.         LIB_SYMBOL(port_short_name)

  526.         LIB_SYMBOL(port_flags)

  527.         LIB_SYMBOL(port_type)

  528.         LIB_SYMBOL(port_is_mine)

  529.         LIB_SYMBOL(port_connected)

  530.         LIB_SYMBOL(port_connected_to)

  531.         LIB_SYMBOL(port_get_connections)

  532.         LIB_SYMBOL(port_get_all_connections)

  533. 

  534.         LIB_SYMBOL(port_rename)

  535.         LIB_SYMBOL(port_set_name)

  536.         LIB_SYMBOL(port_set_alias)

  537.         LIB_SYMBOL(port_unset_alias)

  538.         LIB_SYMBOL(port_get_aliases)

  539. 

  540.         LIB_SYMBOL(port_request_monitor)

  541.         LIB_SYMBOL(port_request_monitor_by_name)

  542.         LIB_SYMBOL(port_ensure_monitor)

  543.         LIB_SYMBOL(port_monitoring_input)

  544. 

  545.         LIB_SYMBOL(connect)

  546.         LIB_SYMBOL(disconnect)

  547.         LIB_SYMBOL(port_disconnect)

  548. 

  549.         LIB_SYMBOL(port_name_size)

  550.         LIB_SYMBOL(port_type_size)

  551.         LIB_SYMBOL(port_type_get_buffer_size)

  552. 

  553.         LIB_SYMBOL(port_get_latency_range)

  554.         LIB_SYMBOL(port_set_latency_range)

  555.         LIB_SYMBOL(recompute_total_latencies)

  556. 

  557.         LIB_SYMBOL(get_ports)

  558.         LIB_SYMBOL(port_by_name)

  559.         LIB_SYMBOL(port_by_id)

  560. 

  561.         LIB_SYMBOL(free)

  562. 

  563.         LIB_SYMBOL(midi_get_event_count)

  564.         LIB_SYMBOL(midi_event_get)

  565.         LIB_SYMBOL(midi_clear_buffer)

  566.         LIB_SYMBOL(midi_event_write)

  567.         LIB_SYMBOL(midi_event_reserve)

  568. 

  569.         LIB_SYMBOL(release_timebase)

  570.         LIB_SYMBOL(set_sync_callback)

  571.         LIB_SYMBOL(set_sync_timeout)

  572.         LIB_SYMBOL(set_timebase_callback)

  573.         LIB_SYMBOL(transport_locate)

  574.         LIB_SYMBOL(transport_query)

  575.         LIB_SYMBOL(get_current_transport_frame)

  576.         LIB_SYMBOL(transport_reposition)

  577.         LIB_SYMBOL(transport_start)

  578.         LIB_SYMBOL(transport_stop)

  579. 

  580.         LIB_SYMBOL(set_property)

  581.         LIB_SYMBOL(get_property)

  582.         LIB_SYMBOL(free_description)

  583.         LIB_SYMBOL(get_properties)

  584.         LIB_SYMBOL(get_all_properties)

  585.         LIB_SYMBOL(remove_property)

  586.         LIB_SYMBOL(remove_properties)

  587.         LIB_SYMBOL(remove_all_properties)

  588.         LIB_SYMBOL(set_property_change_callback)

  589. 

  590.        #ifdef __WINE__

  591.         LIB_SYMBOL(set_thread_creator)

  592.        #endif

  593.       #endif

  594. 

  595.         #undef JOIN

  596.         #undef LIB_SYMBOL

  597.     }

  598. 

  599.    #ifdef HAVE_JACK

  600.     ~JackBridge() noexcept

  601.     {

  602.         USE_NAMESPACE_DISTRHO

  603. 

  604.         if (lib != nullptr)

  605.         {

  606.             lib_close(lib);

  607.             lib = nullptr;

  608.         }

  609.     }

  610.    #endif

  611. 

  612.     DISTRHO_DECLARE_NON_COPYABLE(JackBridge);

  613. };

  614. 

  615. static bool usingNativeBridge = false;

  616. static bool usingRealJACK = true;

  617. static NativeBridge* nativeBridge = nullptr;

  618. 

  619. // -----------------------------------------------------------------------------

  620. 

  621. static JackBridge& getBridgeInstance() noexcept

  622. {

  623.     static JackBridge bridge;

  624.     return bridge;

  625. }

  626. 

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

  628. 

  629. // -----------------------------------------------------------------------------

  630. 

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

  632. 

  633. struct WineBridge {

  634.     void* ptr;

  635.     JackLatencyCallback latency_cb;

  636.     JackProcessCallback process_cb;

  637.     JackThreadInitCallback thread_init_cb;

  638.     JackGraphOrderCallback graph_order_cb;

  639.     JackXRunCallback xrun_cb;

  640.     JackBufferSizeCallback bufsize_cb;

  641.     JackSampleRateCallback srate_cb;

  642.     JackPortRegistrationCallback port_reg_cb;

  643.     JackClientRegistrationCallback client_reg_cb;

  644.     JackPortConnectCallback port_conn_cb;

  645.     JackPortRenameCallback port_rename_cb;

  646.     JackFreewheelCallback freewheel_cb;

  647.     JackShutdownCallback shutdown_cb;

  648.     JackInfoShutdownCallback info_shutdown_cb;

  649.     JackSyncCallback sync_cb;

  650.     JackTimebaseCallback timebase_cb;

  651.     JackSessionCallback session_cb;

  652.     JackPropertyChangeCallback prop_change_cb;

  653. 

  654.     void* (*creator_func)(void*);

  655.     void* creator_arg;

  656.     HANDLE creator_handle;

  657.     pthread_t creator_pthread;

  658. 

  659.     WineBridge() noexcept

  660.         : ptr(nullptr),

  661.           latency_cb(nullptr),

  662.           process_cb(nullptr),

  663.           thread_init_cb(nullptr),

  664.           graph_order_cb(nullptr),

  665.           xrun_cb(nullptr),

  666.           bufsize_cb(nullptr),

  667.           srate_cb(nullptr),

  668.           port_reg_cb(nullptr),

  669.           client_reg_cb(nullptr),

  670.           port_conn_cb(nullptr),

  671.           port_rename_cb(nullptr),

  672.           freewheel_cb(nullptr),

  673.           shutdown_cb(nullptr),

  674.           info_shutdown_cb(nullptr),

  675.           sync_cb(nullptr),

  676.           timebase_cb(nullptr),

  677.           session_cb(nullptr),

  678.           prop_change_cb(nullptr),

  679.           creator_func(nullptr),

  680.           creator_arg(nullptr),

  681.           creator_handle(nullptr),

  682.           creator_pthread(0) {}

  683. 

  684.     static WineBridge& getInstance() noexcept

  685.     {

  686.         static WineBridge bridge;

  687.         return bridge;

  688.     }

  689. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  708. 

  709.     static DWORD WINAPI thread_creator_helper(LPVOID)

  710.     {

  711.         WineBridge& inst(getInstance());

  712. 

  713.         inst.creator_pthread = pthread_self();

  714.         SetEvent(inst.creator_handle);

  715.         inst.creator_func(inst.creator_arg);

  716.         return 0;

  717.     }

  718. 

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

  720.     {

  721.         WineBridge& inst(getInstance());

  722. 

  723.         inst.creator_func   = function;

  724.         inst.creator_arg    = arg;

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

  726. 

  727. #if 0

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

  729. #else

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

  731. 

  732.         if (handle == INVALID_HANDLE_VALUE)

  733.             return 1;

  734. 

  735.         // TODO read attrs and decide this

  736.         ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);

  737.         ::ResumeThread(handle);

  738. #endif

  739. 

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

  741.         *thread_id = inst.creator_pthread;

  742.         return 0;

  743.     }

  744. 

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

  746.     {

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

  748.     }

  749. 

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

  751.     {

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

  753.     }

  754. 

  755.     static void thread_init(void* arg)

  756.     {

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

  758.     }

  759. 

  760.     static int graph_order(void* arg)

  761.     {

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

  763.     }

  764. 

  765.     static int xrun(void* arg)

  766.     {

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

  768.     }

  769. 

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

  771.     {

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

  773.     }

  774. 

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

  776.     {

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

  778.     }

  779. 

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

  781.     {

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

  783.     }

  784. 

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

  786.     {

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

  788.     }

  789. 

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

  791.     {

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

  793.     }

  794. 

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

  796.     {

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

  798.     }

  799. 

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

  801.     {

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

  803.     }

  804. 

  805.     static void shutdown(void* arg)

  806.     {

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

  808.     }

  809. 

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

  811.     {

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

  813.     }

  814. 

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

  816.     {

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

  818.     }

  819. 

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

  821.     {

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

  823.     }

  824. 

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

  826.     {

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

  828.     }

  829. 

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

  831.     {

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

  833.     }

  834. 

  835.     DISTRHO_DECLARE_NON_COPYABLE(WineBridge);

  836. };

  837. 

  838. #endif // __WINE__ && ! JACKBRIDGE_DIRECT

  839. 

  840. // -----------------------------------------------------------------------------

  841. 

  842. bool jackbridge_is_ok() noexcept

  843. {

  844. #if defined(JACKBRIDGE_DUMMY)

  845.     return false;

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

  847.     return true;

  848. #else

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

  850. #endif

  851. }

  852. 

  853. void jackbridge_init()

  854. {

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

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

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

  858. #endif

  859. }

  860. 

  861. // -----------------------------------------------------------------------------

  862. 

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

  864. {

  865. #if defined(JACKBRIDGE_DUMMY)

  866. #elif defined(JACKBRIDGE_DIRECT)

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

  868. #else

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

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

  871. #endif

  872.     if (major_ptr != nullptr)

  873.         *major_ptr = 0;

  874.     if (minor_ptr != nullptr)

  875.         *minor_ptr = 0;

  876.     if (micro_ptr != nullptr)

  877.         *micro_ptr = 0;

  878.     if (proto_ptr != nullptr)

  879.         *proto_ptr = 0;

  880. }

  881. 

  882. const char* jackbridge_get_version_string()

  883. {

  884. #if defined(JACKBRIDGE_DUMMY)

  885. #elif defined(JACKBRIDGE_DIRECT)

  886.     return jack_get_version_string();

  887. #else

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

  889.         return getBridgeInstance().get_version_string_ptr();

  890. #endif

  891.     return nullptr;

  892. }

  893. 

  894. // -----------------------------------------------------------------------------

  895. 

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

  897. {

  898. #if defined(JACKBRIDGE_DUMMY)

  899. #elif defined(JACKBRIDGE_DIRECT)

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

  901. #else

  902.    #ifndef DISTRHO_OS_WASM

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

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

  905.             return client;

  906.    #endif

  907. 

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

  909. 

  910.     // maybe unused

  911.     (void)kValidClient;

  912. 

  913.     usingNativeBridge = true;

  914.     usingRealJACK = false;

  915. 

  916.    #ifdef DISTRHO_OS_WASM

  917.     nativeBridge = new WebBridge;

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

  919.         return kValidClient;

  920.     delete nativeBridge;

  921.    #endif

  922.     

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

  924.     nativeBridge = new RtAudioBridge;

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

  926.         return kValidClient;

  927.     delete nativeBridge;

  928.    #endif

  929. 

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

  931.     nativeBridge = new SDL2Bridge;

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

  933.         return kValidClient;

  934.     delete nativeBridge;

  935.    #endif

  936. #endif

  937.     if (status != nullptr)

  938.         *status = JackServerError;

  939.     return nullptr;

  940. }

  941. 

  942. bool jackbridge_client_close(jack_client_t* client)

  943. {

  944. #if defined(JACKBRIDGE_DUMMY)

  945. #elif defined(JACKBRIDGE_DIRECT)

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

  947. #else

  948.     if (usingNativeBridge)

  949.     {

  950.         if (nativeBridge != nullptr)

  951.         {

  952.             nativeBridge->close();

  953.             delete nativeBridge;

  954.             nativeBridge = nullptr;

  955.         }

  956.         usingNativeBridge = false;

  957.         usingRealJACK = true;

  958.         return true;

  959.     }

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

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

  962. #endif

  963.     return false;

  964. }

  965. 

  966. // -----------------------------------------------------------------------------

  967. 

  968. int jackbridge_client_name_size()

  969. {

  970. #if defined(JACKBRIDGE_DUMMY)

  971. #elif defined(JACKBRIDGE_DIRECT)

  972.     return jack_client_name_size();

  973. #else

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

  975.         return getBridgeInstance().client_name_size_ptr();

  976. #endif

  977.     return 33;

  978. }

  979. 

  980. const char* jackbridge_get_client_name(jack_client_t* client)

  981. {

  982. #if defined(JACKBRIDGE_DUMMY)

  983. #elif defined(JACKBRIDGE_DIRECT)

  984.     return jack_get_client_name(client);

  985. #else

  986.     if (usingNativeBridge)

  987.         return DISTRHO_PLUGIN_NAME;

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

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

  990. #endif

  991.     return nullptr;

  992. }

  993. 

  994. // -----------------------------------------------------------------------------

  995. 

  996. char* jackbridge_client_get_uuid(jack_client_t* client)

  997. {

  998. #if defined(JACKBRIDGE_DUMMY)

  999. #elif defined(JACKBRIDGE_DIRECT)

  1000.     return jack_client_get_uuid(client);

  1001. #else

  1002.     if (usingRealJACK)

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

  1004.             return func(client);

  1005. #endif

  1006.     return nullptr;

  1007. }

  1008. 

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

  1010. {

  1011. #if defined(JACKBRIDGE_DUMMY)

  1012. #elif defined(JACKBRIDGE_DIRECT)

  1013.     return jack_get_uuid_for_client_name(client, name);

  1014. #else

  1015.     if (usingRealJACK)

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

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

  1018. #endif

  1019.     return nullptr;

  1020. }

  1021. 

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

  1023. {

  1024. #if defined(JACKBRIDGE_DUMMY)

  1025. #elif defined(JACKBRIDGE_DIRECT)

  1026.     return jack_get_client_name_by_uuid(client, uuid);

  1027. #else

  1028.     if (usingRealJACK)

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

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

  1031. #endif

  1032.     return nullptr;

  1033. }

  1034. 

  1035. // -----------------------------------------------------------------------------

  1036. 

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

  1038. {

  1039. #if defined(JACKBRIDGE_DUMMY)

  1040. #elif defined(JACKBRIDGE_DIRECT)

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

  1042. #else

  1043.     if (usingRealJACK)

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

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

  1046. #endif

  1047.     return false;

  1048. }

  1049. 

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

  1051. {

  1052. #if defined(JACKBRIDGE_DUMMY)

  1053. #elif defined(JACKBRIDGE_DIRECT)

  1054.     jack_uuid_unparse(uuid, buf);

  1055. #else

  1056.     if (usingRealJACK)

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

  1058.             return func(uuid, buf);

  1059. #endif

  1060. }

  1061. 

  1062. // -----------------------------------------------------------------------------

  1063. 

  1064. bool jackbridge_activate(jack_client_t* client)

  1065. {

  1066. #if defined(JACKBRIDGE_DUMMY)

  1067. #elif defined(JACKBRIDGE_DIRECT)

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

  1069. #else

  1070.     if (usingNativeBridge)

  1071.         return nativeBridge->activate();

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

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

  1074. #endif

  1075.     return false;

  1076. }

  1077. 

  1078. bool jackbridge_deactivate(jack_client_t* client)

  1079. {

  1080. #if defined(JACKBRIDGE_DUMMY)

  1081. #elif defined(JACKBRIDGE_DIRECT)

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

  1083. #else

  1084.     if (usingNativeBridge)

  1085.         return nativeBridge->deactivate();

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

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

  1088. #endif

  1089.     return false;

  1090. }

  1091. 

  1092. bool jackbridge_is_realtime(jack_client_t* client)

  1093. {

  1094. #if defined(JACKBRIDGE_DUMMY)

  1095. #elif defined(JACKBRIDGE_DIRECT)

  1096.     return jack_is_realtime(client);

  1097. #else

  1098.     if (usingRealJACK)

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

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

  1101. #endif

  1102.     return false;

  1103. }

  1104. 

  1105. // -----------------------------------------------------------------------------

  1106. 

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

  1108. {

  1109. #if defined(JACKBRIDGE_DUMMY)

  1110. #elif defined(JACKBRIDGE_DIRECT)

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

  1112. #else

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

  1114.     {

  1115. # ifdef __WINE__

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

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

  1118. # else

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

  1120. # endif

  1121.     }

  1122. #endif

  1123.     return false;

  1124. }

  1125. 

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

  1127. {

  1128. #if defined(JACKBRIDGE_DUMMY)

  1129. #elif defined(JACKBRIDGE_DIRECT)

  1130.     jack_on_shutdown(client, shutdown_callback, arg);

  1131. #else

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

  1133.     {

  1134. # ifdef __WINE__

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

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

  1137. # else

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

  1139. # endif

  1140.     }

  1141. #endif

  1142. }

  1143. 

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

  1145. {

  1146. #if defined(JACKBRIDGE_DUMMY)

  1147. #elif defined(JACKBRIDGE_DIRECT)

  1148.     jack_on_info_shutdown(client, shutdown_callback, arg);

  1149. #else

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

  1151.     {

  1152. # ifdef __WINE__

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

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

  1155. # else

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

  1157. # endif

  1158.     }

  1159. #endif

  1160. }

  1161. 

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

  1163. {

  1164. #if defined(JACKBRIDGE_DUMMY)

  1165. #elif defined(JACKBRIDGE_DIRECT)

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

  1167. #else

  1168.     if (usingNativeBridge)

  1169.     {

  1170.         nativeBridge->jackProcessCallback = process_callback;

  1171.         nativeBridge->jackProcessArg = arg;

  1172.         return true;

  1173.     }

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

  1175.     {

  1176. # ifdef __WINE__

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

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

  1179. # else

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

  1181. # endif

  1182.     }

  1183. #endif

  1184.     return false;

  1185. }

  1186. 

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

  1188. {

  1189. #if defined(JACKBRIDGE_DUMMY)

  1190. #elif defined(JACKBRIDGE_DIRECT)

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

  1192. #else

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

  1194.     {

  1195. # ifdef __WINE__

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

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

  1198. # else

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

  1200. # endif

  1201.     }

  1202. #endif

  1203.     return false;

  1204. }

  1205. 

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

  1207. {

  1208. #if defined(JACKBRIDGE_DUMMY)

  1209. #elif defined(JACKBRIDGE_DIRECT)

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

  1211. #else

  1212.     if (usingNativeBridge)

  1213.     {

  1214.         nativeBridge->bufferSizeCallback = bufsize_callback;

  1215.         nativeBridge->jackBufferSizeArg = arg;

  1216.         return true;

  1217.     }

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

  1219.     {

  1220. # ifdef __WINE__

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

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

  1223. # else

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

  1225. # endif

  1226.     }

  1227. #endif

  1228.     return false;

  1229. }

  1230. 

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

  1232. {

  1233. #if defined(JACKBRIDGE_DUMMY)

  1234. #elif defined(JACKBRIDGE_DIRECT)

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

  1236. #else

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

  1238.     {

  1239. # ifdef __WINE__

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

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

  1242. # else

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

  1244. # endif

  1245.     }

  1246. #endif

  1247.     return false;

  1248. }

  1249. 

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

  1251. {

  1252. #if defined(JACKBRIDGE_DUMMY)

  1253. #elif defined(JACKBRIDGE_DIRECT)

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

  1255. #else

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

  1257.     {

  1258. # ifdef __WINE__

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

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

  1261. # else

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

  1263. # endif

  1264.     }

  1265. #endif

  1266.     return false;

  1267. }

  1268. 

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

  1270. {

  1271. #if defined(JACKBRIDGE_DUMMY)

  1272. #elif defined(JACKBRIDGE_DIRECT)

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

  1274. #else

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

  1276.     {

  1277. # ifdef __WINE__

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

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

  1280. # else

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

  1282. # endif

  1283.     }

  1284. #endif

  1285.     return false;

  1286. }

  1287. 

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

  1289. {

  1290. #if defined(JACKBRIDGE_DUMMY)

  1291. #elif defined(JACKBRIDGE_DIRECT)

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

  1293. #else

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

  1295.     {

  1296. # ifdef __WINE__

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

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

  1299. # else

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

  1301. # endif

  1302.     }

  1303. #endif

  1304.     return false;

  1305. }

  1306. 

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

  1308. {

  1309. #if defined(JACKBRIDGE_DUMMY)

  1310. #elif defined(JACKBRIDGE_DIRECT)

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

  1312. #else

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

  1314.     {

  1315. # ifdef __WINE__

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

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

  1318. # else

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

  1320. # endif

  1321.     }

  1322. #endif

  1323.     return false;

  1324. }

  1325. 

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

  1327. {

  1328. #if defined(JACKBRIDGE_DUMMY)

  1329. #elif defined(JACKBRIDGE_DIRECT)

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

  1331. #else

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

  1333.     {

  1334. # ifdef __WINE__

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

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

  1337. # else

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

  1339. # endif

  1340.     }

  1341. #endif

  1342.     return false;

  1343. }

  1344. 

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

  1346. {

  1347. #if defined(JACKBRIDGE_DUMMY)

  1348. #elif defined(JACKBRIDGE_DIRECT)

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

  1350. #else

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

  1352.     {

  1353. # ifdef __WINE__

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

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

  1356. # else

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

  1358. # endif

  1359.     }

  1360. #endif

  1361.     return false;

  1362. }

  1363. 

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

  1365. {

  1366. #if defined(JACKBRIDGE_DUMMY)

  1367. #elif defined(JACKBRIDGE_DIRECT)

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

  1369. #else

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

  1371.     {

  1372. # ifdef __WINE__

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

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

  1375. # else

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

  1377. # endif

  1378.     }

  1379. #endif

  1380.     return false;

  1381. }

  1382. 

  1383. // -----------------------------------------------------------------------------

  1384. 

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

  1386. {

  1387. #if defined(JACKBRIDGE_DUMMY)

  1388. #elif defined(JACKBRIDGE_DIRECT)

  1389.     return jack_set_freewheel(client, onoff);

  1390. #else

  1391.     if (usingRealJACK)

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

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

  1394. #endif

  1395.     return false;

  1396. }

  1397. 

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

  1399. {

  1400. #if defined(JACKBRIDGE_DUMMY)

  1401. #elif defined(JACKBRIDGE_DIRECT)

  1402.     return jack_set_buffer_size(client, nframes);

  1403. #else

  1404.     if (usingNativeBridge)

  1405.         return nativeBridge->requestBufferSizeChange(nframes);

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

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

  1408. #endif

  1409.     return false;

  1410. }

  1411. 

  1412. // -----------------------------------------------------------------------------

  1413. 

  1414. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1415. {

  1416. #if defined(JACKBRIDGE_DUMMY)

  1417. #elif defined(JACKBRIDGE_DIRECT)

  1418.     return jack_get_sample_rate(client);

  1419. #else

  1420.     if (usingNativeBridge)

  1421.         return nativeBridge->sampleRate;

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

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

  1424. #endif

  1425.     return 0;

  1426. }

  1427. 

  1428. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1429. {

  1430. #if defined(JACKBRIDGE_DUMMY)

  1431. #elif defined(JACKBRIDGE_DIRECT)

  1432.     return jack_get_buffer_size(client);

  1433. #else

  1434.     if (usingNativeBridge)

  1435.         return nativeBridge->bufferSize;

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

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

  1438. #endif

  1439.     return 0;

  1440. }

  1441. 

  1442. float jackbridge_cpu_load(jack_client_t* client)

  1443. {

  1444. #if defined(JACKBRIDGE_DUMMY)

  1445. #elif defined(JACKBRIDGE_DIRECT)

  1446.     return jack_cpu_load(client);

  1447. #else

  1448.     if (usingRealJACK)

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

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

  1451. #endif

  1452.     return 0.0f;

  1453. }

  1454. 

  1455. // -----------------------------------------------------------------------------

  1456. 

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

  1458. {

  1459. #if defined(JACKBRIDGE_DUMMY)

  1460. #elif defined(JACKBRIDGE_DIRECT)

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

  1462. #else

  1463.     if (usingNativeBridge)

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

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

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

  1467.                                                      static_cast<ulong>(flags),

  1468.                                                      static_cast<ulong>(buffer_size));

  1469. #endif

  1470.     return nullptr;

  1471. }

  1472. 

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

  1474. {

  1475. #if defined(JACKBRIDGE_DUMMY)

  1476. #elif defined(JACKBRIDGE_DIRECT)

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

  1478. #else

  1479.     if (usingRealJACK)

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

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

  1482. #endif

  1483.     return false;

  1484. }

  1485. 

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

  1487. {

  1488. #if defined(JACKBRIDGE_DUMMY)

  1489. #elif defined(JACKBRIDGE_DIRECT)

  1490.     return jack_port_get_buffer(port, nframes);

  1491. #else

  1492.     if (usingNativeBridge)

  1493.         return nativeBridge->getPortBuffer(port);

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

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

  1496. #endif

  1497.     return nullptr;

  1498. }

  1499. 

  1500. // -----------------------------------------------------------------------------

  1501. 

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

  1503. {

  1504. #if defined(JACKBRIDGE_DUMMY)

  1505. #elif defined(JACKBRIDGE_DIRECT)

  1506.     return jack_port_name(port);

  1507. #else

  1508.     if (usingRealJACK)

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

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

  1511. #endif

  1512.     return nullptr;

  1513. }

  1514. 

  1515. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1516. {

  1517. #if defined(JACKBRIDGE_DUMMY)

  1518. #elif defined(JACKBRIDGE_DIRECT)

  1519.     return jack_port_uuid(port);

  1520. #else

  1521.     if (usingRealJACK)

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

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

  1524. #endif

  1525.     return 0;

  1526. }

  1527. 

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

  1529. {

  1530. #if defined(JACKBRIDGE_DUMMY)

  1531. #elif defined(JACKBRIDGE_DIRECT)

  1532.     return jack_port_short_name(port);

  1533. #else

  1534.     if (usingRealJACK)

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

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

  1537. #endif

  1538.     return nullptr;

  1539. }

  1540. 

  1541. int jackbridge_port_flags(const jack_port_t* port)

  1542. {

  1543. #if defined(JACKBRIDGE_DUMMY)

  1544. #elif defined(JACKBRIDGE_DIRECT)

  1545.     return jack_port_flags(port);

  1546. #else

  1547.     if (usingRealJACK)

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

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

  1550. #endif

  1551.     return 0x0;

  1552. }

  1553. 

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

  1555. {

  1556. #if defined(JACKBRIDGE_DUMMY)

  1557. #elif defined(JACKBRIDGE_DIRECT)

  1558.     return jack_port_type(port);

  1559. #else

  1560.     if (usingRealJACK)

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

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

  1563. #endif

  1564.     return nullptr;

  1565. }

  1566. 

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

  1568. {

  1569. #if defined(JACKBRIDGE_DUMMY)

  1570. #elif defined(JACKBRIDGE_DIRECT)

  1571.     return jack_port_is_mine(client, port);

  1572. #else

  1573.     if (usingRealJACK)

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

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

  1576. #endif

  1577.     return false;

  1578. }

  1579. 

  1580. int jackbridge_port_connected(const jack_port_t* port)

  1581. {

  1582. #if defined(JACKBRIDGE_DUMMY)

  1583. #elif defined(JACKBRIDGE_DIRECT)

  1584.     return jack_port_connected(port);

  1585. #else

  1586.     if (usingRealJACK)

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

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

  1589. #endif

  1590.     return 0;

  1591. }

  1592. 

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

  1594. {

  1595. #if defined(JACKBRIDGE_DUMMY)

  1596. #elif defined(JACKBRIDGE_DIRECT)

  1597.     return jack_port_connected_to(port, port_name);

  1598. #else

  1599.     if (usingRealJACK)

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

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

  1602. #endif

  1603.     return false;

  1604. }

  1605. 

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

  1607. {

  1608. #if defined(JACKBRIDGE_DUMMY)

  1609. #elif defined(JACKBRIDGE_DIRECT)

  1610.     return jack_port_get_connections(port);

  1611. #else

  1612.     if (usingRealJACK)

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

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

  1615. #endif

  1616.     return nullptr;

  1617. }

  1618. 

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

  1620. {

  1621. #if defined(JACKBRIDGE_DUMMY)

  1622. #elif defined(JACKBRIDGE_DIRECT)

  1623.     return jack_port_get_all_connections(client, port);

  1624. #else

  1625.     if (usingRealJACK)

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

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

  1628. #endif

  1629.     return nullptr;

  1630. }

  1631. 

  1632. // -----------------------------------------------------------------------------

  1633. 

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

  1635. {

  1636. #if defined(JACKBRIDGE_DUMMY)

  1637. #elif defined(JACKBRIDGE_DIRECT)

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

  1639. #else

  1640.     if (usingNativeBridge)

  1641.         return false;

  1642.     // Try new API first

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

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

  1645.     // Try old API if using JACK2

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

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

  1648. #endif

  1649.     return false;

  1650. }

  1651. 

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

  1653. {

  1654. #if defined(JACKBRIDGE_DUMMY)

  1655. #elif defined(JACKBRIDGE_DIRECT)

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

  1657. #else

  1658.     if (usingRealJACK)

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

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

  1661. #endif

  1662.     return false;

  1663. }

  1664. 

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

  1666. {

  1667. #if defined(JACKBRIDGE_DUMMY)

  1668. #elif defined(JACKBRIDGE_DIRECT)

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

  1670. #else

  1671.     if (usingRealJACK)

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

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

  1674. #endif

  1675.     return false;

  1676. }

  1677. 

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

  1679. {

  1680. #if defined(JACKBRIDGE_DUMMY)

  1681. #elif defined(JACKBRIDGE_DIRECT)

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

  1683. #else

  1684.     if (usingRealJACK)

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

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

  1687. #endif

  1688.     return 0;

  1689. }

  1690. 

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

  1692. 

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

  1694. {

  1695. #if defined(JACKBRIDGE_DUMMY)

  1696. #elif defined(JACKBRIDGE_DIRECT)

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

  1698. #else

  1699.     if (usingRealJACK)

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

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

  1702. #endif

  1703.     return false;

  1704. }

  1705. 

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

  1707. {

  1708. #if defined(JACKBRIDGE_DUMMY)

  1709. #elif defined(JACKBRIDGE_DIRECT)

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

  1711. #else

  1712.     if (usingRealJACK)

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

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

  1715. #endif

  1716.     return false;

  1717. }

  1718. 

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

  1720. {

  1721. #if defined(JACKBRIDGE_DUMMY)

  1722. #elif defined(JACKBRIDGE_DIRECT)

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

  1724. #else

  1725.     if (usingRealJACK)

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

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

  1728. #endif

  1729.     return false;

  1730. }

  1731. 

  1732. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1733. {

  1734. #if defined(JACKBRIDGE_DUMMY)

  1735. #elif defined(JACKBRIDGE_DIRECT)

  1736.     return jack_port_monitoring_input(port);

  1737. #else

  1738.     if (usingRealJACK)

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

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

  1741. #endif

  1742.     return false;

  1743. }

  1744. 

  1745. // -----------------------------------------------------------------------------

  1746. 

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

  1748. {

  1749. #if defined(JACKBRIDGE_DUMMY)

  1750. #elif defined(JACKBRIDGE_DIRECT)

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

  1752. #else

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

  1754.     {

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

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

  1757.     }

  1758. #endif

  1759.     return false;

  1760. }

  1761. 

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

  1763. {

  1764. #if defined(JACKBRIDGE_DUMMY)

  1765. #elif defined(JACKBRIDGE_DIRECT)

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

  1767. #else

  1768.     if (usingRealJACK)

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

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

  1771. #endif

  1772.     return false;

  1773. }

  1774. 

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

  1776. {

  1777. #if defined(JACKBRIDGE_DUMMY)

  1778. #elif defined(JACKBRIDGE_DIRECT)

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

  1780. #else

  1781.     if (usingRealJACK)

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

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

  1784. #endif

  1785.     return false;

  1786. }

  1787. 

  1788. // -----------------------------------------------------------------------------

  1789. 

  1790. int jackbridge_port_name_size()

  1791. {

  1792. #if defined(JACKBRIDGE_DUMMY)

  1793. #elif defined(JACKBRIDGE_DIRECT)

  1794.     return jack_port_name_size();

  1795. #else

  1796.     if (usingRealJACK)

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

  1798.             return getBridgeInstance().port_name_size_ptr();

  1799. #endif

  1800.     return 256;

  1801. }

  1802. 

  1803. int jackbridge_port_type_size()

  1804. {

  1805. #if defined(JACKBRIDGE_DUMMY)

  1806. #elif defined(JACKBRIDGE_DIRECT)

  1807.     return jack_port_type_size();

  1808. #else

  1809.     if (usingRealJACK)

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

  1811.             return getBridgeInstance().port_type_size_ptr();

  1812. #endif

  1813.     return 32;

  1814. }

  1815. 

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

  1817. {

  1818. #if defined(JACKBRIDGE_DUMMY)

  1819. #elif defined(JACKBRIDGE_DIRECT)

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

  1821. #else

  1822.     if (usingRealJACK)

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

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

  1825. #endif

  1826.     return 0;

  1827. }

  1828. 

  1829. // -----------------------------------------------------------------------------

  1830. 

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

  1832. {

  1833. #if defined(JACKBRIDGE_DUMMY)

  1834. #elif defined(JACKBRIDGE_DIRECT)

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

  1836. #else

  1837.     if (usingRealJACK)

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

  1839.             return getBridgeInstance().port_get_latency_range_ptr(port,

  1840.                                                                   static_cast<jack_latency_callback_mode_t>(mode),

  1841.                                                                   range);

  1842. #endif

  1843.     range->min = 0;

  1844.     range->max = 0;

  1845. }

  1846. 

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

  1848. {

  1849. #if defined(JACKBRIDGE_DUMMY)

  1850. #elif defined(JACKBRIDGE_DIRECT)

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

  1852. #else

  1853.     if (usingRealJACK)

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

  1855.             getBridgeInstance().port_set_latency_range_ptr(port,

  1856.                                                            static_cast<jack_latency_callback_mode_t>(mode),

  1857.                                                            range);

  1858. #endif

  1859. }

  1860. 

  1861. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1862. {

  1863. #if defined(JACKBRIDGE_DUMMY)

  1864. #elif defined(JACKBRIDGE_DIRECT)

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

  1866. #else

  1867.     if (usingRealJACK)

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

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

  1870. #endif

  1871.     return false;

  1872. }

  1873. 

  1874. // -----------------------------------------------------------------------------

  1875. 

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

  1877. {

  1878. #if defined(JACKBRIDGE_DUMMY)

  1879. #elif defined(JACKBRIDGE_DIRECT)

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

  1881. #else

  1882.     if (usingRealJACK)

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

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

  1885.                                                      static_cast<ulong>(flags));

  1886. #endif

  1887.     return nullptr;

  1888. }

  1889. 

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

  1891. {

  1892. #if defined(JACKBRIDGE_DUMMY)

  1893. #elif defined(JACKBRIDGE_DIRECT)

  1894.     return jack_port_by_name(client, port_name);

  1895. #else

  1896.     if (usingRealJACK)

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

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

  1899. #endif

  1900.     return nullptr;

  1901. }

  1902. 

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

  1904. {

  1905. #if defined(JACKBRIDGE_DUMMY)

  1906. #elif defined(JACKBRIDGE_DIRECT)

  1907.     return jack_port_by_id(client, port_id);

  1908. #else

  1909.     if (usingRealJACK)

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

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

  1912. #endif

  1913.     return nullptr;

  1914. }

  1915. 

  1916. // -----------------------------------------------------------------------------

  1917. 

  1918. void jackbridge_free(void* ptr)

  1919. {

  1920. #if defined(JACKBRIDGE_DUMMY)

  1921. #elif defined(JACKBRIDGE_DIRECT)

  1922.     return jack_free(ptr);

  1923. #else

  1924.     if (usingRealJACK)

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

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

  1927. 

  1928.     // just in case

  1929.     std::free(ptr);

  1930. #endif

  1931. }

  1932. 

  1933. // -----------------------------------------------------------------------------

  1934. 

  1935. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1936. {

  1937. #if defined(JACKBRIDGE_DUMMY)

  1938. #elif defined(JACKBRIDGE_DIRECT)

  1939.     return jack_midi_get_event_count(port_buffer);

  1940. #else

  1941.     if (usingNativeBridge)

  1942.         return nativeBridge->getEventCount();

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

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

  1945. #endif

  1946.     return 0;

  1947. }

  1948. 

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

  1950. {

  1951. #if defined(JACKBRIDGE_DUMMY)

  1952. #elif defined(JACKBRIDGE_DIRECT)

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

  1954. #else

  1955.     if (usingNativeBridge)

  1956.         return nativeBridge->getEvent(event);

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

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

  1959. #endif

  1960.     return false;

  1961. }

  1962. 

  1963. void jackbridge_midi_clear_buffer(void* port_buffer)

  1964. {

  1965. #if defined(JACKBRIDGE_DUMMY)

  1966. #elif defined(JACKBRIDGE_DIRECT)

  1967.     jack_midi_clear_buffer(port_buffer);

  1968. #else

  1969.     if (usingNativeBridge)

  1970.         return nativeBridge->clearEventBuffer();

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

  1972.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  1973. #endif

  1974. }

  1975. 

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

  1977. {

  1978. #if defined(JACKBRIDGE_DUMMY)

  1979. #elif defined(JACKBRIDGE_DIRECT)

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

  1981. #else

  1982.     if (usingNativeBridge)

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

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

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

  1986. #endif

  1987.     return false;

  1988. }

  1989. 

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

  1991. {

  1992. #if defined(JACKBRIDGE_DUMMY)

  1993. #elif defined(JACKBRIDGE_DIRECT)

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

  1995. #else

  1996.     if (usingRealJACK)

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

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

  1999. #endif

  2000.     return nullptr;

  2001. }

  2002. 

  2003. // -----------------------------------------------------------------------------

  2004. 

  2005. bool jackbridge_release_timebase(jack_client_t* client)

  2006. {

  2007. #if defined(JACKBRIDGE_DUMMY)

  2008. #elif defined(JACKBRIDGE_DIRECT)

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

  2010. #else

  2011.     if (usingRealJACK)

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

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

  2014. #endif

  2015.     return false;

  2016. }

  2017. 

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

  2019. {

  2020. #if defined(JACKBRIDGE_DUMMY)

  2021. #elif defined(JACKBRIDGE_DIRECT)

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

  2023. #else

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

  2025.     {

  2026. # ifdef __WINE__

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

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

  2029. # else

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

  2031. # endif

  2032.     }

  2033. #endif

  2034.     return false;

  2035. }

  2036. 

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

  2038. {

  2039. #if defined(JACKBRIDGE_DUMMY)

  2040. #elif defined(JACKBRIDGE_DIRECT)

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

  2042. #else

  2043.     if (usingRealJACK)

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

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

  2046. #endif

  2047.     return false;

  2048. }

  2049. 

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

  2051. {

  2052. #if defined(JACKBRIDGE_DUMMY)

  2053. #elif defined(JACKBRIDGE_DIRECT)

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

  2055. #else

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

  2057.     {

  2058. # ifdef __WINE__

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

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

  2061. # else

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

  2063. # endif

  2064.     }

  2065. #endif

  2066.     return false;

  2067. }

  2068. 

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

  2070. {

  2071. #if defined(JACKBRIDGE_DUMMY)

  2072. #elif defined(JACKBRIDGE_DIRECT)

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

  2074. #else

  2075.     if (usingRealJACK)

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

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

  2078. #endif

  2079.     return false;

  2080. }

  2081. 

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

  2083. {

  2084. #if defined(JACKBRIDGE_DUMMY)

  2085. #elif defined(JACKBRIDGE_DIRECT)

  2086.     return jack_transport_query(client, pos);

  2087. #else

  2088.     if (usingRealJACK)

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

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

  2091. #endif

  2092.     if (pos != nullptr)

  2093.     {

  2094.         // invalidate

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

  2096.         pos->unique_1 = 0;

  2097.         pos->unique_2 = 1;

  2098.     }

  2099.     return JackTransportStopped;

  2100. }

  2101. 

  2102. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  2103. {

  2104. #if defined(JACKBRIDGE_DUMMY)

  2105. #elif defined(JACKBRIDGE_DIRECT)

  2106.     return jack_get_current_transport_frame(client);

  2107. #else

  2108.     if (usingRealJACK)

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

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

  2111. #endif

  2112.     return 0;

  2113. }

  2114. 

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

  2116. {

  2117. #if defined(JACKBRIDGE_DUMMY)

  2118. #elif defined(JACKBRIDGE_DIRECT)

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

  2120. #else

  2121.     if (usingRealJACK)

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

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

  2124. #endif

  2125.     return false;

  2126. }

  2127. 

  2128. void jackbridge_transport_start(jack_client_t* client)

  2129. {

  2130. #if defined(JACKBRIDGE_DUMMY)

  2131. #elif defined(JACKBRIDGE_DIRECT)

  2132.     jack_transport_start(client);

  2133. #else

  2134.     if (usingRealJACK)

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

  2136.             getBridgeInstance().transport_start_ptr(client);

  2137. #endif

  2138. }

  2139. 

  2140. void jackbridge_transport_stop(jack_client_t* client)

  2141. {

  2142. #if defined(JACKBRIDGE_DUMMY)

  2143. #elif defined(JACKBRIDGE_DIRECT)

  2144.     jack_transport_stop(client);

  2145. #else

  2146.     if (usingRealJACK)

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

  2148.             getBridgeInstance().transport_stop_ptr(client);

  2149. #endif

  2150. }

  2151. 

  2152. // -----------------------------------------------------------------------------

  2153. 

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

  2155. {

  2156. #if defined(JACKBRIDGE_DUMMY)

  2157. #elif defined(JACKBRIDGE_DIRECT)

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

  2159. #else

  2160.     if (usingRealJACK)

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

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

  2163. #endif

  2164.     return false;

  2165. }

  2166. 

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

  2168. {

  2169. #if defined(JACKBRIDGE_DUMMY)

  2170. #elif defined(JACKBRIDGE_DIRECT)

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

  2172. #else

  2173.     if (usingRealJACK)

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

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

  2176. #endif

  2177.     return false;

  2178. }

  2179. 

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

  2181. {

  2182. #if defined(JACKBRIDGE_DUMMY)

  2183. #elif defined(JACKBRIDGE_DIRECT)

  2184.     jack_free_description(desc, free_description_itself);

  2185. #else

  2186.     if (usingRealJACK)

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

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

  2189. #endif

  2190. }

  2191. 

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

  2193. {

  2194. #if defined(JACKBRIDGE_DUMMY)

  2195. #elif defined(JACKBRIDGE_DIRECT)

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

  2197. #else

  2198.     if (usingRealJACK)

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

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

  2201. #endif

  2202.     return false;

  2203. }

  2204. 

  2205. bool jackbridge_get_all_properties(jack_description_t** descs)

  2206. {

  2207. #if defined(JACKBRIDGE_DUMMY)

  2208. #elif defined(JACKBRIDGE_DIRECT)

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

  2210. #else

  2211.     if (usingRealJACK)

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

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

  2214. #endif

  2215.     return false;

  2216. }

  2217. 

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

  2219. {

  2220. #if defined(JACKBRIDGE_DUMMY)

  2221. #elif defined(JACKBRIDGE_DIRECT)

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

  2223. #else

  2224.     if (usingRealJACK)

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

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

  2227. #endif

  2228.     return false;

  2229. }

  2230. 

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

  2232. {

  2233. #if defined(JACKBRIDGE_DUMMY)

  2234. #elif defined(JACKBRIDGE_DIRECT)

  2235.     return jack_remove_properties(client, subject);

  2236. #else

  2237.     if (usingRealJACK)

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

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

  2240. #endif

  2241.     return 0;

  2242. }

  2243. 

  2244. bool jackbridge_remove_all_properties(jack_client_t* client)

  2245. {

  2246. #if defined(JACKBRIDGE_DUMMY)

  2247. #elif defined(JACKBRIDGE_DIRECT)

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

  2249. #else

  2250.     if (usingRealJACK)

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

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

  2253. #endif

  2254.     return false;

  2255. }

  2256. 

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

  2258. {

  2259. #if defined(JACKBRIDGE_DUMMY)

  2260. #elif defined(JACKBRIDGE_DIRECT)

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

  2262. #else

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

  2264.     {

  2265. # ifdef __WINE__

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

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

  2268. # else

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

  2270. # endif

  2271.     }

  2272. #endif

  2273.     return false;

  2274. }

  2275. 

  2276. // -----------------------------------------------------------------------------

  2277. 

  2278. START_NAMESPACE_DISTRHO

  2279. 

  2280. bool isUsingNativeAudio() noexcept

  2281. {

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

  2283.     return false;

  2284. #else

  2285.     return usingNativeBridge;

  2286. #endif

  2287. }

  2288. 

  2289. bool supportsAudioInput()

  2290. {

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

  2292.     if (usingNativeBridge)

  2293.         return nativeBridge->supportsAudioInput();

  2294. #endif

  2295.     return false;

  2296. }

  2297. 

  2298. bool supportsBufferSizeChanges()

  2299. {

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

  2301.     if (usingNativeBridge)

  2302.         return nativeBridge->supportsBufferSizeChanges();

  2303. #endif

  2304.     return false;

  2305. }

  2306. 

  2307. bool supportsMIDI()

  2308. {

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

  2310.     if (usingNativeBridge)

  2311.         return nativeBridge->supportsMIDI();

  2312. #endif

  2313.     return false;

  2314. }

  2315. 

  2316. bool isAudioInputEnabled()

  2317. {

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

  2319.     if (usingNativeBridge)

  2320.         return nativeBridge->isAudioInputEnabled();

  2321. #endif

  2322.     return false;

  2323. }

  2324. 

  2325. bool isMIDIEnabled()

  2326. {

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

  2328.     if (usingNativeBridge)

  2329.         return nativeBridge->isMIDIEnabled();

  2330. #endif

  2331.     return false;

  2332. }

  2333. 

  2334. uint getBufferSize()

  2335. {

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

  2337.     if (usingNativeBridge)

  2338.         return nativeBridge->getBufferSize();

  2339. #endif

  2340.     return 0;

  2341. }

  2342. 

  2343. bool requestAudioInput()

  2344. {

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

  2346.     if (usingNativeBridge)

  2347.         return nativeBridge->requestAudioInput();

  2348. #endif

  2349.     return false;

  2350. }

  2351. 

  2352. bool requestBufferSizeChange(const uint newBufferSize)

  2353. {

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

  2355.     if (usingNativeBridge)

  2356.         return nativeBridge->requestBufferSizeChange(newBufferSize);

  2357. #endif

  2358.     return false;

  2359. }

  2360. 

  2361. bool requestMIDI()

  2362. {

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

  2364.     if (usingNativeBridge)

  2365.         return nativeBridge->requestMIDI();

  2366. #endif

  2367.     return false;

  2368. }

  2369. 

  2370. END_NAMESPACE_DISTRHO

  2371. 

  2372. // -----------------------------------------------------------------------------