falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
5002 Commits
16 Branches
14GB
Tree: 30b817649e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '30b817649e'
${ noResults }
Carla/source/jackbridge/JackBridge1.cpp

2065 lines
72KB
Raw Blame History 

  1. /*

  2.  * JackBridge (Part 1, JACK functions)

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

  4.  *

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

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

  7.  * permission notice appear in all copies.

  8.  *

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

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

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

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

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

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

  15.  */

  16. 

  17. #include "JackBridge.hpp"

  18. 

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

  20. 

  21. #ifdef __WINE__

  22. # include <windows.h>

  23. # include <pthread.h>

  24. #endif

  25. 

  26. #if defined(CARLA_OS_WIN) && ! defined(__WINE__)

  27. # define JACKSYM_API __cdecl

  28. #else

  29. # define JACKSYM_API

  30. #endif

  31. 

  32. #include <cerrno>

  33. #include "CarlaLibUtils.hpp"

  34. 

  35. // -----------------------------------------------------------------------------

  36. 

  37. extern "C" {

  38. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  57. 

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

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

  60. 

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

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

  63. 

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

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

  66. 

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

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

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

  70. 

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

  72. 

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

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

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

  76. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  91. 

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

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

  94. 

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

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

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

  98. 

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

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

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

  102. 

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

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

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

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

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

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

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

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

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

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

  113. 

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

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

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

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

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

  119. 

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

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

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

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

  124. 

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

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

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

  128. 

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

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

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

  132. 

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

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

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

  136. 

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

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

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

  140. 

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

  142. 

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

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

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

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

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

  148. 

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

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

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

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

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

  154. 

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

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

  157. 

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

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

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

  161. 

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

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

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

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

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

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

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

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

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

  171. 

  172. #ifdef __WINE__

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

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

  175. #endif

  176. 

  177. } // extern "C"

  178. 

  179. // -----------------------------------------------------------------------------

  180. 

  181. struct JackBridge {

  182.     lib_t lib;

  183. 

  184.     jacksym_get_version get_version_ptr;

  185.     jacksym_get_version_string get_version_string_ptr;

  186. 

  187.     jacksym_client_open client_open_ptr;

  188.     jacksym_client_close client_close_ptr;

  189. 

  190.     jacksym_client_name_size client_name_size_ptr;

  191.     jacksym_get_client_name get_client_name_ptr;

  192. 

  193.     jacksym_client_get_uuid client_get_uuid_ptr;

  194.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  195.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  196. 

  197.     jacksym_uuid_parse uuid_parse_ptr;

  198. 

  199.     jacksym_activate activate_ptr;

  200.     jacksym_deactivate deactivate_ptr;

  201.     jacksym_is_realtime is_realtime_ptr;

  202. 

  203.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  204.     jacksym_on_shutdown on_shutdown_ptr;

  205.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  206.     jacksym_set_process_callback set_process_callback_ptr;

  207.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  208.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  209.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  210.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  211.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  212.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  213.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  214.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  215.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  216.     jacksym_set_latency_callback set_latency_callback_ptr;

  217. 

  218.     jacksym_set_freewheel set_freewheel_ptr;

  219.     jacksym_set_buffer_size set_buffer_size_ptr;

  220. 

  221.     jacksym_get_sample_rate get_sample_rate_ptr;

  222.     jacksym_get_buffer_size get_buffer_size_ptr;

  223.     jacksym_cpu_load cpu_load_ptr;

  224. 

  225.     jacksym_port_register port_register_ptr;

  226.     jacksym_port_unregister port_unregister_ptr;

  227.     jacksym_port_get_buffer port_get_buffer_ptr;

  228. 

  229.     jacksym_port_name port_name_ptr;

  230.     jacksym_port_uuid port_uuid_ptr;

  231.     jacksym_port_short_name port_short_name_ptr;

  232.     jacksym_port_flags port_flags_ptr;

  233.     jacksym_port_type port_type_ptr;

  234.     jacksym_port_is_mine port_is_mine_ptr;

  235.     jacksym_port_connected port_connected_ptr;

  236.     jacksym_port_connected_to port_connected_to_ptr;

  237.     jacksym_port_get_connections port_get_connections_ptr;

  238.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  239. 

  240.     jacksym_port_rename port_rename_ptr;

  241.     jacksym_port_set_name port_set_name_ptr;

  242.     jacksym_port_set_alias port_set_alias_ptr;

  243.     jacksym_port_unset_alias port_unset_alias_ptr;

  244.     jacksym_port_get_aliases port_get_aliases_ptr;

  245. 

  246.     jacksym_port_request_monitor port_request_monitor_ptr;

  247.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  248.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  249.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  250. 

  251.     jacksym_connect connect_ptr;

  252.     jacksym_disconnect disconnect_ptr;

  253.     jacksym_port_disconnect port_disconnect_ptr;

  254. 

  255.     jacksym_port_name_size port_name_size_ptr;

  256.     jacksym_port_type_size port_type_size_ptr;

  257.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  258. 

  259.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  260.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  261.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  262. 

  263.     jacksym_get_ports get_ports_ptr;

  264.     jacksym_port_by_name port_by_name_ptr;

  265.     jacksym_port_by_id port_by_id_ptr;

  266. 

  267.     jacksym_free free_ptr;

  268. 

  269.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  270.     jacksym_midi_event_get midi_event_get_ptr;

  271.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  272.     jacksym_midi_event_write midi_event_write_ptr;

  273.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  274. 

  275.     jacksym_release_timebase release_timebase_ptr;

  276.     jacksym_set_sync_callback set_sync_callback_ptr;

  277.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  278.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  279.     jacksym_transport_locate transport_locate_ptr;

  280. 

  281.     jacksym_transport_query transport_query_ptr;

  282.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  283. 

  284.     jacksym_transport_reposition transport_reposition_ptr;

  285.     jacksym_transport_start transport_start_ptr;

  286.     jacksym_transport_stop transport_stop_ptr;

  287. 

  288.     jacksym_set_property set_property_ptr;

  289.     jacksym_get_property get_property_ptr;

  290.     jacksym_free_description free_description_ptr;

  291.     jacksym_get_properties get_properties_ptr;

  292.     jacksym_get_all_properties get_all_properties_ptr;

  293.     jacksym_remove_property remove_property_ptr;

  294.     jacksym_remove_properties remove_properties_ptr;

  295.     jacksym_remove_all_properties remove_all_properties_ptr;

  296.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  297. 

  298. #ifdef __WINE__

  299.     jacksym_set_thread_creator set_thread_creator_ptr;

  300. #endif

  301. 

  302.     JackBridge()

  303.         : lib(nullptr),

  304.           get_version_ptr(nullptr),

  305.           get_version_string_ptr(nullptr),

  306.           client_open_ptr(nullptr),

  307.           client_close_ptr(nullptr),

  308.           client_name_size_ptr(nullptr),

  309.           get_client_name_ptr(nullptr),

  310.           client_get_uuid_ptr(nullptr),

  311.           get_uuid_for_client_name_ptr(nullptr),

  312.           get_client_name_by_uuid_ptr(nullptr),

  313.           uuid_parse_ptr(nullptr),

  314.           activate_ptr(nullptr),

  315.           deactivate_ptr(nullptr),

  316.           is_realtime_ptr(nullptr),

  317.           set_thread_init_callback_ptr(nullptr),

  318.           on_shutdown_ptr(nullptr),

  319.           on_info_shutdown_ptr(nullptr),

  320.           set_process_callback_ptr(nullptr),

  321.           set_freewheel_callback_ptr(nullptr),

  322.           set_buffer_size_callback_ptr(nullptr),

  323.           set_sample_rate_callback_ptr(nullptr),

  324.           set_client_registration_callback_ptr(nullptr),

  325.           set_port_registration_callback_ptr(nullptr),

  326.           set_port_rename_callback_ptr(nullptr),

  327.           set_port_connect_callback_ptr(nullptr),

  328.           set_graph_order_callback_ptr(nullptr),

  329.           set_xrun_callback_ptr(nullptr),

  330.           set_latency_callback_ptr(nullptr),

  331.           set_freewheel_ptr(nullptr),

  332.           set_buffer_size_ptr(nullptr),

  333.           get_sample_rate_ptr(nullptr),

  334.           get_buffer_size_ptr(nullptr),

  335.           cpu_load_ptr(nullptr),

  336.           port_register_ptr(nullptr),

  337.           port_unregister_ptr(nullptr),

  338.           port_get_buffer_ptr(nullptr),

  339.           port_name_ptr(nullptr),

  340.           port_uuid_ptr(nullptr),

  341.           port_short_name_ptr(nullptr),

  342.           port_flags_ptr(nullptr),

  343.           port_type_ptr(nullptr),

  344.           port_is_mine_ptr(nullptr),

  345.           port_connected_ptr(nullptr),

  346.           port_connected_to_ptr(nullptr),

  347.           port_get_connections_ptr(nullptr),

  348.           port_get_all_connections_ptr(nullptr),

  349.           port_rename_ptr(nullptr),

  350.           port_set_name_ptr(nullptr),

  351.           port_set_alias_ptr(nullptr),

  352.           port_unset_alias_ptr(nullptr),

  353.           port_get_aliases_ptr(nullptr),

  354.           port_request_monitor_ptr(nullptr),

  355.           port_request_monitor_by_name_ptr(nullptr),

  356.           port_ensure_monitor_ptr(nullptr),

  357.           port_monitoring_input_ptr(nullptr),

  358.           connect_ptr(nullptr),

  359.           disconnect_ptr(nullptr),

  360.           port_disconnect_ptr(nullptr),

  361.           port_name_size_ptr(nullptr),

  362.           port_type_size_ptr(nullptr),

  363.           port_type_get_buffer_size_ptr(nullptr),

  364.           port_get_latency_range_ptr(nullptr),

  365.           port_set_latency_range_ptr(nullptr),

  366.           recompute_total_latencies_ptr(nullptr),

  367.           get_ports_ptr(nullptr),

  368.           port_by_name_ptr(nullptr),

  369.           port_by_id_ptr(nullptr),

  370.           free_ptr(nullptr),

  371.           midi_get_event_count_ptr(nullptr),

  372.           midi_event_get_ptr(nullptr),

  373.           midi_clear_buffer_ptr(nullptr),

  374.           midi_event_write_ptr(nullptr),

  375.           midi_event_reserve_ptr(nullptr),

  376.           release_timebase_ptr(nullptr),

  377.           set_sync_callback_ptr(nullptr),

  378.           set_sync_timeout_ptr(nullptr),

  379.           set_timebase_callback_ptr(nullptr),

  380.           transport_locate_ptr(nullptr),

  381.           transport_query_ptr(nullptr),

  382.           get_current_transport_frame_ptr(nullptr),

  383.           transport_reposition_ptr(nullptr),

  384.           transport_start_ptr(nullptr),

  385.           transport_stop_ptr(nullptr),

  386.           set_property_ptr(nullptr),

  387.           get_property_ptr(nullptr),

  388.           free_description_ptr(nullptr),

  389.           get_properties_ptr(nullptr),

  390.           get_all_properties_ptr(nullptr),

  391.           remove_property_ptr(nullptr),

  392.           remove_properties_ptr(nullptr),

  393.           remove_all_properties_ptr(nullptr),

  394.           set_property_change_callback_ptr(nullptr)

  395. #ifdef __WINE__

  396.         , set_thread_creator_ptr(nullptr)

  397. #endif

  398.     {

  399. # if defined(CARLA_OS_MAC)

  400.         const char* const filename("libjack.dylib");

  401. # elif defined(CARLA_OS_WIN64)

  402.         const char* const filename("libjack64.dll");

  403. # elif defined(CARLA_OS_WIN)

  404.         const char* const filename("libjack.dll");

  405. # else

  406.         const char* const filename("libjack.so.0");

  407. # endif

  408. 

  409.         lib = lib_open(filename);

  410. 

  411.         if (lib == nullptr)

  412.         {

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

  414.             return;

  415.         }

  416.         else

  417.         {

  418.             fprintf(stdout, "%s loaded sucessfully!\n", filename);

  419.         }

  420. 

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

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

  423. 

  424.         LIB_SYMBOL(get_version)

  425.         LIB_SYMBOL(get_version_string)

  426. 

  427.         LIB_SYMBOL(client_open)

  428.         LIB_SYMBOL(client_close)

  429. 

  430.         LIB_SYMBOL(client_name_size)

  431.         LIB_SYMBOL(get_client_name)

  432. 

  433.         LIB_SYMBOL(client_get_uuid)

  434.         LIB_SYMBOL(get_uuid_for_client_name)

  435.         LIB_SYMBOL(get_client_name_by_uuid)

  436. 

  437.         LIB_SYMBOL(uuid_parse)

  438. 

  439.         LIB_SYMBOL(activate)

  440.         LIB_SYMBOL(deactivate)

  441.         LIB_SYMBOL(is_realtime)

  442. 

  443.         LIB_SYMBOL(set_thread_init_callback)

  444.         LIB_SYMBOL(on_shutdown)

  445.         LIB_SYMBOL(on_info_shutdown)

  446.         LIB_SYMBOL(set_process_callback)

  447.         LIB_SYMBOL(set_freewheel_callback)

  448.         LIB_SYMBOL(set_buffer_size_callback)

  449.         LIB_SYMBOL(set_sample_rate_callback)

  450.         LIB_SYMBOL(set_client_registration_callback)

  451.         LIB_SYMBOL(set_port_registration_callback)

  452.         LIB_SYMBOL(set_port_rename_callback)

  453.         LIB_SYMBOL(set_port_connect_callback)

  454.         LIB_SYMBOL(set_graph_order_callback)

  455.         LIB_SYMBOL(set_xrun_callback)

  456.         LIB_SYMBOL(set_latency_callback)

  457. 

  458.         LIB_SYMBOL(set_freewheel)

  459.         LIB_SYMBOL(set_buffer_size)

  460. 

  461.         LIB_SYMBOL(get_sample_rate)

  462.         LIB_SYMBOL(get_buffer_size)

  463.         LIB_SYMBOL(cpu_load)

  464. 

  465.         LIB_SYMBOL(port_register)

  466.         LIB_SYMBOL(port_unregister)

  467.         LIB_SYMBOL(port_get_buffer)

  468. 

  469.         LIB_SYMBOL(port_name)

  470.         LIB_SYMBOL(port_uuid)

  471.         LIB_SYMBOL(port_short_name)

  472.         LIB_SYMBOL(port_flags)

  473.         LIB_SYMBOL(port_type)

  474.         LIB_SYMBOL(port_is_mine)

  475.         LIB_SYMBOL(port_connected)

  476.         LIB_SYMBOL(port_connected_to)

  477.         LIB_SYMBOL(port_get_connections)

  478.         LIB_SYMBOL(port_get_all_connections)

  479. 

  480.         LIB_SYMBOL(port_rename)

  481.         LIB_SYMBOL(port_set_name)

  482.         LIB_SYMBOL(port_set_alias)

  483.         LIB_SYMBOL(port_unset_alias)

  484.         LIB_SYMBOL(port_get_aliases)

  485. 

  486.         LIB_SYMBOL(port_request_monitor)

  487.         LIB_SYMBOL(port_request_monitor_by_name)

  488.         LIB_SYMBOL(port_ensure_monitor)

  489.         LIB_SYMBOL(port_monitoring_input)

  490. 

  491.         LIB_SYMBOL(connect)

  492.         LIB_SYMBOL(disconnect)

  493.         LIB_SYMBOL(port_disconnect)

  494. 

  495.         LIB_SYMBOL(port_name_size)

  496.         LIB_SYMBOL(port_type_size)

  497.         LIB_SYMBOL(port_type_get_buffer_size)

  498. 

  499.         LIB_SYMBOL(port_get_latency_range)

  500.         LIB_SYMBOL(port_set_latency_range)

  501.         LIB_SYMBOL(recompute_total_latencies)

  502. 

  503.         LIB_SYMBOL(get_ports)

  504.         LIB_SYMBOL(port_by_name)

  505.         LIB_SYMBOL(port_by_id)

  506. 

  507.         LIB_SYMBOL(free)

  508. 

  509.         LIB_SYMBOL(midi_get_event_count)

  510.         LIB_SYMBOL(midi_event_get)

  511.         LIB_SYMBOL(midi_clear_buffer)

  512.         LIB_SYMBOL(midi_event_write)

  513.         LIB_SYMBOL(midi_event_reserve)

  514. 

  515.         LIB_SYMBOL(release_timebase)

  516.         LIB_SYMBOL(set_sync_callback)

  517.         LIB_SYMBOL(set_sync_timeout)

  518.         LIB_SYMBOL(set_timebase_callback)

  519.         LIB_SYMBOL(transport_locate)

  520.         LIB_SYMBOL(transport_query)

  521.         LIB_SYMBOL(get_current_transport_frame)

  522.         LIB_SYMBOL(transport_reposition)

  523.         LIB_SYMBOL(transport_start)

  524.         LIB_SYMBOL(transport_stop)

  525. 

  526.         LIB_SYMBOL(set_property)

  527.         LIB_SYMBOL(get_property)

  528.         LIB_SYMBOL(free_description)

  529.         LIB_SYMBOL(get_properties)

  530.         LIB_SYMBOL(get_all_properties)

  531.         LIB_SYMBOL(remove_property)

  532.         LIB_SYMBOL(remove_properties)

  533.         LIB_SYMBOL(remove_all_properties)

  534.         LIB_SYMBOL(set_property_change_callback)

  535. 

  536. #ifdef __WINE__

  537.         LIB_SYMBOL(set_thread_creator)

  538. #endif

  539. 

  540.         #undef JOIN

  541.         #undef LIB_SYMBOL

  542.     }

  543. 

  544.     ~JackBridge() noexcept

  545.     {

  546.         if (lib != nullptr)

  547.         {

  548.             lib_close(lib);

  549.             lib = nullptr;

  550.         }

  551.     }

  552. 

  553.     CARLA_DECLARE_NON_COPY_STRUCT(JackBridge);

  554. };

  555. 

  556. // -----------------------------------------------------------------------------

  557. 

  558. static const JackBridge& getBridgeInstance() noexcept

  559. {

  560.     static const JackBridge bridge;

  561.     return bridge;

  562. }

  563. 

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

  565. 

  566. // -----------------------------------------------------------------------------

  567. 

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

  569. 

  570. struct WineBridge {

  571.     void* ptr;

  572.     JackLatencyCallback latency_cb;

  573.     JackProcessCallback process_cb;

  574.     JackThreadInitCallback thread_init_cb;

  575.     JackGraphOrderCallback graph_order_cb;

  576.     JackXRunCallback xrun_cb;

  577.     JackBufferSizeCallback bufsize_cb;

  578.     JackSampleRateCallback srate_cb;

  579.     JackPortRegistrationCallback port_reg_cb;

  580.     JackClientRegistrationCallback client_reg_cb;

  581.     JackPortConnectCallback port_conn_cb;

  582.     JackPortRenameCallback port_rename_cb;

  583.     JackFreewheelCallback freewheel_cb;

  584.     JackShutdownCallback shutdown_cb;

  585.     JackInfoShutdownCallback info_shutdown_cb;

  586.     JackSyncCallback sync_cb;

  587.     JackTimebaseCallback timebase_cb;

  588.     JackSessionCallback session_cb;

  589.     JackPropertyChangeCallback prop_change_cb;

  590. 

  591.     void* (*creator_func)(void*);

  592.     void* creator_arg;

  593.     HANDLE creator_handle;

  594.     pthread_t creator_pthread;

  595. 

  596.     WineBridge() noexcept

  597.         : ptr(nullptr),

  598.           latency_cb(nullptr),

  599.           process_cb(nullptr),

  600.           thread_init_cb(nullptr),

  601.           graph_order_cb(nullptr),

  602.           xrun_cb(nullptr),

  603.           bufsize_cb(nullptr),

  604.           srate_cb(nullptr),

  605.           port_reg_cb(nullptr),

  606.           client_reg_cb(nullptr),

  607.           port_conn_cb(nullptr),

  608.           port_rename_cb(nullptr),

  609.           freewheel_cb(nullptr),

  610.           shutdown_cb(nullptr),

  611.           info_shutdown_cb(nullptr),

  612.           sync_cb(nullptr),

  613.           timebase_cb(nullptr),

  614.           session_cb(nullptr),

  615.           prop_change_cb(nullptr),

  616.           creator_func(nullptr),

  617.           creator_arg(nullptr),

  618.           creator_handle(nullptr),

  619.           creator_pthread(0) {}

  620. 

  621.     static WineBridge& getInstance() noexcept

  622.     {

  623.         static WineBridge bridge;

  624.         return bridge;

  625.     }

  626. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  645. 

  646.     static DWORD WINAPI thread_creator_helper(LPVOID)

  647.     {

  648.         WineBridge& inst(getInstance());

  649. 

  650.         inst.creator_pthread = pthread_self();

  651.         SetEvent(inst.creator_handle);

  652.         inst.creator_func(inst.creator_arg);

  653.         return 0;

  654.     }

  655. 

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

  657.     {

  658.         WineBridge& inst(getInstance());

  659. 

  660.         inst.creator_func   = function;

  661.         inst.creator_arg    = arg;

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

  663. 

  664. #if 0

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

  666. #else

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

  668. 

  669.         if (handle == INVALID_HANDLE_VALUE)

  670.             return 1;

  671. 

  672.         // TODO read attrs and decide this

  673.         ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);

  674.         ::ResumeThread(handle);

  675. #endif

  676. 

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

  678.         *thread_id = inst.creator_pthread;

  679.         return 0;

  680.     }

  681. 

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

  683.     {

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

  685.     }

  686. 

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

  688.     {

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

  690.     }

  691. 

  692.     static void thread_init(void* arg)

  693.     {

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

  695.     }

  696. 

  697.     static int graph_order(void* arg)

  698.     {

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

  700.     }

  701. 

  702.     static int xrun(void* arg)

  703.     {

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

  705.     }

  706. 

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

  708.     {

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

  710.     }

  711. 

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

  713.     {

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

  715.     }

  716. 

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

  718.     {

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

  720.     }

  721. 

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

  723.     {

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

  725.     }

  726. 

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

  728.     {

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

  730.     }

  731. 

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

  733.     {

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

  735.     }

  736. 

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

  738.     {

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

  740.     }

  741. 

  742.     static void shutdown(void* arg)

  743.     {

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

  745.     }

  746. 

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

  748.     {

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

  750.     }

  751. 

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

  753.     {

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

  755.     }

  756. 

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

  758.     {

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

  760.     }

  761. 

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

  763.     {

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

  765.     }

  766. 

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

  768.     {

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

  770.     }

  771. 

  772.     CARLA_DECLARE_NON_COPY_STRUCT(WineBridge);

  773. };

  774. 

  775. #endif // __WINE__ && ! JACKBRIDGE_DIRECT

  776. 

  777. // -----------------------------------------------------------------------------

  778. 

  779. bool jackbridge_is_ok() noexcept

  780. {

  781. #if defined(JACKBRIDGE_DUMMY)

  782.     return false;

  783. #elif defined(JACKBRIDGE_DIRECT)

  784.     return true;

  785. #else

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

  787. #endif

  788. }

  789. 

  790. void jackbridge_init()

  791. {

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

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

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

  795. #endif

  796. }

  797. 

  798. // -----------------------------------------------------------------------------

  799. 

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

  801. {

  802. #if defined(JACKBRIDGE_DUMMY)

  803. #elif defined(JACKBRIDGE_DIRECT)

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

  805. #else

  806.     if (getBridgeInstance().get_version_ptr != nullptr)

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

  808. #endif

  809.     if (major_ptr != nullptr)

  810.         *major_ptr = 0;

  811.     if (minor_ptr != nullptr)

  812.         *minor_ptr = 0;

  813.     if (micro_ptr != nullptr)

  814.         *micro_ptr = 0;

  815.     if (proto_ptr != nullptr)

  816.         *proto_ptr = 0;

  817. }

  818. 

  819. const char* jackbridge_get_version_string()

  820. {

  821. #if defined(JACKBRIDGE_DUMMY)

  822. #elif defined(JACKBRIDGE_DIRECT)

  823.     return jack_get_version_string();

  824. #else

  825.     if (getBridgeInstance().get_version_string_ptr != nullptr)

  826.         return getBridgeInstance().get_version_string_ptr();

  827. #endif

  828.     return nullptr;

  829. }

  830. 

  831. // -----------------------------------------------------------------------------

  832. 

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

  834. {

  835. #if defined(JACKBRIDGE_DUMMY)

  836. #elif defined(JACKBRIDGE_DIRECT)

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

  838. #else

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

  840.         return getBridgeInstance().client_open_ptr(client_name, static_cast<jack_options_t>(options), status);

  841. #endif

  842.     if (status != nullptr)

  843.         *status = JackServerError;

  844.     return nullptr;

  845. }

  846. 

  847. bool jackbridge_client_close(jack_client_t* client)

  848. {

  849. #if defined(JACKBRIDGE_DUMMY)

  850. #elif defined(JACKBRIDGE_DIRECT)

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

  852. #else

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

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

  855. #endif

  856.     return false;

  857. }

  858. 

  859. // -----------------------------------------------------------------------------

  860. 

  861. int jackbridge_client_name_size()

  862. {

  863. #if defined(JACKBRIDGE_DUMMY)

  864. #elif defined(JACKBRIDGE_DIRECT)

  865.     return jack_client_name_size();

  866. #else

  867.     if (getBridgeInstance().client_name_size_ptr != nullptr)

  868.         return getBridgeInstance().client_name_size_ptr();

  869. #endif

  870.     return 33;

  871. }

  872. 

  873. char* jackbridge_get_client_name(jack_client_t* client)

  874. {

  875. #if defined(JACKBRIDGE_DUMMY)

  876. #elif defined(JACKBRIDGE_DIRECT)

  877.     return jack_get_client_name(client);

  878. #else

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

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

  881. #endif

  882.     return nullptr;

  883. }

  884. 

  885. // -----------------------------------------------------------------------------

  886. 

  887. char* jackbridge_client_get_uuid(jack_client_t* client)

  888. {

  889. #if defined(JACKBRIDGE_DUMMY)

  890. #elif defined(JACKBRIDGE_DIRECT)

  891.     return jack_client_get_uuid(client);

  892. #else

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

  894.         return func(client);

  895. #endif

  896.     return nullptr;

  897. }

  898. 

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

  900. {

  901. #if defined(JACKBRIDGE_DUMMY)

  902. #elif defined(JACKBRIDGE_DIRECT)

  903.     return jack_get_uuid_for_client_name(client, name);

  904. #else

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

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

  907. #endif

  908.     return nullptr;

  909. }

  910. 

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

  912. {

  913. #if defined(JACKBRIDGE_DUMMY)

  914. #elif defined(JACKBRIDGE_DIRECT)

  915.     return jack_get_client_name_by_uuid(client, uuid);

  916. #else

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

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

  919. #endif

  920.     return nullptr;

  921. }

  922. 

  923. // -----------------------------------------------------------------------------

  924. 

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

  926. {

  927. #if defined(JACKBRIDGE_DUMMY)

  928. #elif defined(JACKBRIDGE_DIRECT)

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

  930. #else

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

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

  933. #endif

  934.     return false;

  935. }

  936. 

  937. // -----------------------------------------------------------------------------

  938. 

  939. bool jackbridge_activate(jack_client_t* client)

  940. {

  941. #if defined(JACKBRIDGE_DUMMY)

  942. #elif defined(JACKBRIDGE_DIRECT)

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

  944. #else

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

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

  947. #endif

  948.     return false;

  949. }

  950. 

  951. bool jackbridge_deactivate(jack_client_t* client)

  952. {

  953. #if defined(JACKBRIDGE_DUMMY)

  954. #elif defined(JACKBRIDGE_DIRECT)

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

  956. #else

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

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

  959. #endif

  960.     return false;

  961. }

  962. 

  963. bool jackbridge_is_realtime(jack_client_t* client)

  964. {

  965. #if defined(JACKBRIDGE_DUMMY)

  966. #elif defined(JACKBRIDGE_DIRECT)

  967.     return jack_is_realtime(client);

  968. #else

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

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

  971. #endif

  972.     return false;

  973. }

  974. 

  975. // -----------------------------------------------------------------------------

  976. 

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

  978. {

  979. #if defined(JACKBRIDGE_DUMMY)

  980. #elif defined(JACKBRIDGE_DIRECT)

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

  982. #else

  983.     if (getBridgeInstance().set_thread_init_callback_ptr != nullptr)

  984.     {

  985. # ifdef __WINE__

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

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

  988. # else

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

  990. # endif

  991.     }

  992. #endif

  993.     return false;

  994. }

  995. 

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

  997. {

  998. #if defined(JACKBRIDGE_DUMMY)

  999. #elif defined(JACKBRIDGE_DIRECT)

  1000.     jack_on_shutdown(client, shutdown_callback, arg);

  1001. #else

  1002.     if (getBridgeInstance().on_shutdown_ptr != nullptr)

  1003.     {

  1004. # ifdef __WINE__

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

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

  1007. # else

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

  1009. # endif

  1010.     }

  1011. #endif

  1012. }

  1013. 

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

  1015. {

  1016. #if defined(JACKBRIDGE_DUMMY)

  1017. #elif defined(JACKBRIDGE_DIRECT)

  1018.     jack_on_info_shutdown(client, shutdown_callback, arg);

  1019. #else

  1020.     if (getBridgeInstance().on_info_shutdown_ptr != nullptr)

  1021.     {

  1022. # ifdef __WINE__

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

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

  1025. # else

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

  1027. # endif

  1028.     }

  1029. #endif

  1030. }

  1031. 

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

  1033. {

  1034. #if defined(JACKBRIDGE_DUMMY)

  1035. #elif defined(JACKBRIDGE_DIRECT)

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

  1037. #else

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

  1039.     {

  1040. # ifdef __WINE__

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

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

  1043. # else

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

  1045. # endif

  1046.     }

  1047. #endif

  1048.     return false;

  1049. }

  1050. 

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

  1052. {

  1053. #if defined(JACKBRIDGE_DUMMY)

  1054. #elif defined(JACKBRIDGE_DIRECT)

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

  1056. #else

  1057.     if (getBridgeInstance().set_freewheel_callback_ptr != nullptr)

  1058.     {

  1059. # ifdef __WINE__

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

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

  1062. # else

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

  1064. # endif

  1065.     }

  1066. #endif

  1067.     return false;

  1068. }

  1069. 

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

  1071. {

  1072. #if defined(JACKBRIDGE_DUMMY)

  1073. #elif defined(JACKBRIDGE_DIRECT)

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

  1075. #else

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

  1077.     {

  1078. # ifdef __WINE__

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

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

  1081. # else

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

  1083. # endif

  1084.     }

  1085. #endif

  1086.     return false;

  1087. }

  1088. 

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

  1090. {

  1091. #if defined(JACKBRIDGE_DUMMY)

  1092. #elif defined(JACKBRIDGE_DIRECT)

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

  1094. #else

  1095.     if (getBridgeInstance().set_sample_rate_callback_ptr != nullptr)

  1096.     {

  1097. # ifdef __WINE__

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

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

  1100. # else

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

  1102. # endif

  1103.     }

  1104. #endif

  1105.     return false;

  1106. }

  1107. 

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

  1109. {

  1110. #if defined(JACKBRIDGE_DUMMY)

  1111. #elif defined(JACKBRIDGE_DIRECT)

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

  1113. #else

  1114.     if (getBridgeInstance().set_client_registration_callback_ptr != nullptr)

  1115.     {

  1116. # ifdef __WINE__

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

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

  1119. # else

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

  1121. # endif

  1122.     }

  1123. #endif

  1124.     return false;

  1125. }

  1126. 

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

  1128. {

  1129. #if defined(JACKBRIDGE_DUMMY)

  1130. #elif defined(JACKBRIDGE_DIRECT)

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

  1132. #else

  1133.     if (getBridgeInstance().set_port_registration_callback_ptr != nullptr)

  1134.     {

  1135. # ifdef __WINE__

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

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

  1138. # else

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

  1140. # endif

  1141.     }

  1142. #endif

  1143.     return false;

  1144. }

  1145. 

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

  1147. {

  1148. #if defined(JACKBRIDGE_DUMMY)

  1149. #elif defined(JACKBRIDGE_DIRECT)

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

  1151. #else

  1152.     if (getBridgeInstance().set_port_rename_callback_ptr != nullptr)

  1153.     {

  1154. # ifdef __WINE__

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

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

  1157. # else

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

  1159. # endif

  1160.     }

  1161. #endif

  1162.     return false;

  1163. }

  1164. 

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

  1166. {

  1167. #if defined(JACKBRIDGE_DUMMY)

  1168. #elif defined(JACKBRIDGE_DIRECT)

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

  1170. #else

  1171.     if (getBridgeInstance().set_port_connect_callback_ptr != nullptr)

  1172.     {

  1173. # ifdef __WINE__

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

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

  1176. # else

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

  1178. # endif

  1179.     }

  1180. #endif

  1181.     return false;

  1182. }

  1183. 

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

  1185. {

  1186. #if defined(JACKBRIDGE_DUMMY)

  1187. #elif defined(JACKBRIDGE_DIRECT)

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

  1189. #else

  1190.     if (getBridgeInstance().set_graph_order_callback_ptr != nullptr)

  1191.     {

  1192. # ifdef __WINE__

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

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

  1195. # else

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

  1197. # endif

  1198.     }

  1199. #endif

  1200.     return false;

  1201. }

  1202. 

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

  1204. {

  1205. #if defined(JACKBRIDGE_DUMMY)

  1206. #elif defined(JACKBRIDGE_DIRECT)

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

  1208. #else

  1209.     if (getBridgeInstance().set_xrun_callback_ptr != nullptr)

  1210.     {

  1211. # ifdef __WINE__

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

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

  1214. # else

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

  1216. # endif

  1217.     }

  1218. #endif

  1219.     return false;

  1220. }

  1221. 

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

  1223. {

  1224. #if defined(JACKBRIDGE_DUMMY)

  1225. #elif defined(JACKBRIDGE_DIRECT)

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

  1227. #else

  1228.     if (getBridgeInstance().set_latency_callback_ptr != nullptr)

  1229.     {

  1230. # ifdef __WINE__

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

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

  1233. # else

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

  1235. # endif

  1236.     }

  1237. #endif

  1238.     return false;

  1239. }

  1240. 

  1241. // -----------------------------------------------------------------------------

  1242. 

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

  1244. {

  1245. #if defined(JACKBRIDGE_DUMMY)

  1246. #elif defined(JACKBRIDGE_DIRECT)

  1247.     return jack_set_freewheel(client, onoff);

  1248. #else

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

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

  1251. #endif

  1252.     return false;

  1253. }

  1254. 

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

  1256. {

  1257. #if defined(JACKBRIDGE_DUMMY)

  1258. #elif defined(JACKBRIDGE_DIRECT)

  1259.     return jack_set_buffer_size(client, nframes);

  1260. #else

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

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

  1263. #endif

  1264.     return false;

  1265. }

  1266. 

  1267. // -----------------------------------------------------------------------------

  1268. 

  1269. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1270. {

  1271. #if defined(JACKBRIDGE_DUMMY)

  1272. #elif defined(JACKBRIDGE_DIRECT)

  1273.     return jack_get_sample_rate(client);

  1274. #else

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

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

  1277. #endif

  1278.     return 0;

  1279. }

  1280. 

  1281. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1282. {

  1283. #if defined(JACKBRIDGE_DUMMY)

  1284. #elif defined(JACKBRIDGE_DIRECT)

  1285.     return jack_get_buffer_size(client);

  1286. #else

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

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

  1289. #endif

  1290.     return 0;

  1291. }

  1292. 

  1293. float jackbridge_cpu_load(jack_client_t* client)

  1294. {

  1295. #if defined(JACKBRIDGE_DUMMY)

  1296. #elif defined(JACKBRIDGE_DIRECT)

  1297.     return jack_cpu_load(client);

  1298. #else

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

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

  1301. #endif

  1302.     return 0.0f;

  1303. }

  1304. 

  1305. // -----------------------------------------------------------------------------

  1306. 

  1307. jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, uint64_t flags, uint64_t buffer_size)

  1308. {

  1309. #if defined(JACKBRIDGE_DUMMY)

  1310. #elif defined(JACKBRIDGE_DIRECT)

  1311.     return jack_port_register(client, port_name, port_type, flags, buffer_size);

  1312. #else

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

  1314.         return getBridgeInstance().port_register_ptr(client, port_name, port_type,

  1315.                                                      static_cast<ulong>(flags),

  1316.                                                      static_cast<ulong>(buffer_size));

  1317. #endif

  1318.     return nullptr;

  1319. }

  1320. 

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

  1322. {

  1323. #if defined(JACKBRIDGE_DUMMY)

  1324. #elif defined(JACKBRIDGE_DIRECT)

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

  1326. #else

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

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

  1329. #endif

  1330.     return false;

  1331. }

  1332. 

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

  1334. {

  1335. #if defined(JACKBRIDGE_DUMMY)

  1336. #elif defined(JACKBRIDGE_DIRECT)

  1337.     return jack_port_get_buffer(port, nframes);

  1338. #else

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

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

  1341. #endif

  1342.     return nullptr;

  1343. }

  1344. 

  1345. // -----------------------------------------------------------------------------

  1346. 

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

  1348. {

  1349. #if defined(JACKBRIDGE_DUMMY)

  1350. #elif defined(JACKBRIDGE_DIRECT)

  1351.     return jack_port_name(port);

  1352. #else

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

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

  1355. #endif

  1356.     return nullptr;

  1357. }

  1358. 

  1359. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1360. {

  1361. #if defined(JACKBRIDGE_DUMMY)

  1362. #elif defined(JACKBRIDGE_DIRECT)

  1363.     return jack_port_uuid(port);

  1364. #else

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

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

  1367. #endif

  1368.     return 0;

  1369. }

  1370. 

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

  1372. {

  1373. #if defined(JACKBRIDGE_DUMMY)

  1374. #elif defined(JACKBRIDGE_DIRECT)

  1375.     return jack_port_short_name(port);

  1376. #else

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

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

  1379. #endif

  1380.     return nullptr;

  1381. }

  1382. 

  1383. int jackbridge_port_flags(const jack_port_t* port)

  1384. {

  1385. #if defined(JACKBRIDGE_DUMMY)

  1386. #elif defined(JACKBRIDGE_DIRECT)

  1387.     return jack_port_flags(port);

  1388. #else

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

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

  1391. #endif

  1392.     return 0x0;

  1393. }

  1394. 

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

  1396. {

  1397. #if defined(JACKBRIDGE_DUMMY)

  1398. #elif defined(JACKBRIDGE_DIRECT)

  1399.     return jack_port_type(port);

  1400. #else

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

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

  1403. #endif

  1404.     return nullptr;

  1405. }

  1406. 

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

  1408. {

  1409. #if defined(JACKBRIDGE_DUMMY)

  1410. #elif defined(JACKBRIDGE_DIRECT)

  1411.     return jack_port_is_mine(client, port);

  1412. #else

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

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

  1415. #endif

  1416.     return false;

  1417. }

  1418. 

  1419. int jackbridge_port_connected(const jack_port_t* port)

  1420. {

  1421. #if defined(JACKBRIDGE_DUMMY)

  1422. #elif defined(JACKBRIDGE_DIRECT)

  1423.     return jack_port_connected(port);

  1424. #else

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

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

  1427. #endif

  1428.     return 0;

  1429. }

  1430. 

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

  1432. {

  1433. #if defined(JACKBRIDGE_DUMMY)

  1434. #elif defined(JACKBRIDGE_DIRECT)

  1435.     return jack_port_connected_to(port, port_name);

  1436. #else

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

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

  1439. #endif

  1440.     return false;

  1441. }

  1442. 

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

  1444. {

  1445. #if defined(JACKBRIDGE_DUMMY)

  1446. #elif defined(JACKBRIDGE_DIRECT)

  1447.     return jack_port_get_connections(port);

  1448. #else

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

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

  1451. #endif

  1452.     return nullptr;

  1453. }

  1454. 

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

  1456. {

  1457. #if defined(JACKBRIDGE_DUMMY)

  1458. #elif defined(JACKBRIDGE_DIRECT)

  1459.     return jack_port_get_all_connections(client, port);

  1460. #else

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

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

  1463. #endif

  1464.     return nullptr;

  1465. }

  1466. 

  1467. // -----------------------------------------------------------------------------

  1468. 

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

  1470. {

  1471. #if defined(JACKBRIDGE_DUMMY)

  1472. #elif defined(JACKBRIDGE_DIRECT)

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

  1474. #else

  1475.     // Try new API first

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

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

  1478.     // Try old API if using JACK2

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

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

  1481. #endif

  1482.     return false;

  1483. }

  1484. 

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

  1486. {

  1487. #if defined(JACKBRIDGE_DUMMY)

  1488. #elif defined(JACKBRIDGE_DIRECT)

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

  1490. #else

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

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

  1493. #endif

  1494.     return false;

  1495. }

  1496. 

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

  1498. {

  1499. #if defined(JACKBRIDGE_DUMMY)

  1500. #elif defined(JACKBRIDGE_DIRECT)

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

  1502. #else

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

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

  1505. #endif

  1506.     return false;

  1507. }

  1508. 

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

  1510. {

  1511. #if defined(JACKBRIDGE_DUMMY)

  1512. #elif defined(JACKBRIDGE_DIRECT)

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

  1514. #else

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

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

  1517. #endif

  1518.     return 0;

  1519. }

  1520. 

  1521. // -----------------------------------------------------------------------------

  1522. 

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

  1524. {

  1525. #if defined(JACKBRIDGE_DUMMY)

  1526. #elif defined(JACKBRIDGE_DIRECT)

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

  1528. #else

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

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

  1531. #endif

  1532.     return false;

  1533. }

  1534. 

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

  1536. {

  1537. #if defined(JACKBRIDGE_DUMMY)

  1538. #elif defined(JACKBRIDGE_DIRECT)

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

  1540. #else

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

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

  1543. #endif

  1544.     return false;

  1545. }

  1546. 

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

  1548. {

  1549. #if defined(JACKBRIDGE_DUMMY)

  1550. #elif defined(JACKBRIDGE_DIRECT)

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

  1552. #else

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

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

  1555. #endif

  1556.     return false;

  1557. }

  1558. 

  1559. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1560. {

  1561. #if defined(JACKBRIDGE_DUMMY)

  1562. #elif defined(JACKBRIDGE_DIRECT)

  1563.     return jack_port_monitoring_input(port);

  1564. #else

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

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

  1567. #endif

  1568.     return false;

  1569. }

  1570. 

  1571. // -----------------------------------------------------------------------------

  1572. 

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

  1574. {

  1575. #if defined(JACKBRIDGE_DUMMY)

  1576. #elif defined(JACKBRIDGE_DIRECT)

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

  1578. #else

  1579.     if (getBridgeInstance().connect_ptr != nullptr)

  1580.     {

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

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

  1583.     }

  1584. #endif

  1585.     return false;

  1586. }

  1587. 

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

  1589. {

  1590. #if defined(JACKBRIDGE_DUMMY)

  1591. #elif defined(JACKBRIDGE_DIRECT)

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

  1593. #else

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

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

  1596. #endif

  1597.     return false;

  1598. }

  1599. 

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

  1601. {

  1602. #if defined(JACKBRIDGE_DUMMY)

  1603. #elif defined(JACKBRIDGE_DIRECT)

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

  1605. #else

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

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

  1608. #endif

  1609.     return false;

  1610. }

  1611. 

  1612. // -----------------------------------------------------------------------------

  1613. 

  1614. int jackbridge_port_name_size()

  1615. {

  1616. #if defined(JACKBRIDGE_DUMMY)

  1617. #elif defined(JACKBRIDGE_DIRECT)

  1618.     return jack_port_name_size();

  1619. #else

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

  1621.         return getBridgeInstance().port_name_size_ptr();

  1622. #endif

  1623.     return 256;

  1624. }

  1625. 

  1626. int jackbridge_port_type_size()

  1627. {

  1628. #if defined(JACKBRIDGE_DUMMY)

  1629. #elif defined(JACKBRIDGE_DIRECT)

  1630.     return jack_port_type_size();

  1631. #else

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

  1633.         return getBridgeInstance().port_type_size_ptr();

  1634. #endif

  1635.     return 32;

  1636. }

  1637. 

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

  1639. {

  1640. #if defined(JACKBRIDGE_DUMMY)

  1641. #elif defined(JACKBRIDGE_DIRECT)

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

  1643. #else

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

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

  1646. #endif

  1647.     return 0;

  1648. }

  1649. 

  1650. // -----------------------------------------------------------------------------

  1651. 

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

  1653. {

  1654. #if defined(JACKBRIDGE_DUMMY)

  1655. #elif defined(JACKBRIDGE_DIRECT)

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

  1657. #else

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

  1659.         return getBridgeInstance().port_get_latency_range_ptr(port,

  1660.                                                               static_cast<jack_latency_callback_mode_t>(mode),

  1661.                                                               range);

  1662. #endif

  1663.     range->min = 0;

  1664.     range->max = 0;

  1665. }

  1666. 

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

  1668. {

  1669. #if defined(JACKBRIDGE_DUMMY)

  1670. #elif defined(JACKBRIDGE_DIRECT)

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

  1672. #else

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

  1674.         getBridgeInstance().port_set_latency_range_ptr(port,

  1675.                                                        static_cast<jack_latency_callback_mode_t>(mode),

  1676.                                                        range);

  1677. #endif

  1678. }

  1679. 

  1680. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1681. {

  1682. #if defined(JACKBRIDGE_DUMMY)

  1683. #elif defined(JACKBRIDGE_DIRECT)

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

  1685. #else

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

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

  1688. #endif

  1689.     return false;

  1690. }

  1691. 

  1692. // -----------------------------------------------------------------------------

  1693. 

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

  1695. {

  1696. #if defined(JACKBRIDGE_DUMMY)

  1697. #elif defined(JACKBRIDGE_DIRECT)

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

  1699. #else

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

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

  1702.                                                  static_cast<ulong>(flags));

  1703. #endif

  1704.     return nullptr;

  1705. }

  1706. 

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

  1708. {

  1709. #if defined(JACKBRIDGE_DUMMY)

  1710. #elif defined(JACKBRIDGE_DIRECT)

  1711.     return jack_port_by_name(client, port_name);

  1712. #else

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

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

  1715. #endif

  1716.     return nullptr;

  1717. }

  1718. 

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

  1720. {

  1721. #if defined(JACKBRIDGE_DUMMY)

  1722. #elif defined(JACKBRIDGE_DIRECT)

  1723.     return jack_port_by_id(client, port_id);

  1724. #else

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

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

  1727. #endif

  1728.     return nullptr;

  1729. }

  1730. 

  1731. // -----------------------------------------------------------------------------

  1732. 

  1733. void jackbridge_free(void* ptr)

  1734. {

  1735. #if defined(JACKBRIDGE_DUMMY)

  1736. #elif defined(JACKBRIDGE_DIRECT)

  1737.     return jack_free(ptr);

  1738. #else

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

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

  1741. 

  1742.     // just in case

  1743.     std::free(ptr);

  1744. #endif

  1745. }

  1746. 

  1747. // -----------------------------------------------------------------------------

  1748. 

  1749. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1750. {

  1751. #if defined(JACKBRIDGE_DUMMY)

  1752. #elif defined(JACKBRIDGE_DIRECT)

  1753.     return jack_midi_get_event_count(port_buffer);

  1754. #else

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

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

  1757. #endif

  1758.     return 0;

  1759. }

  1760. 

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

  1762. {

  1763. #if defined(JACKBRIDGE_DUMMY)

  1764. #elif defined(JACKBRIDGE_DIRECT)

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

  1766. #else

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

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

  1769. #endif

  1770.     return false;

  1771. }

  1772. 

  1773. void jackbridge_midi_clear_buffer(void* port_buffer)

  1774. {

  1775. #if defined(JACKBRIDGE_DUMMY)

  1776. #elif defined(JACKBRIDGE_DIRECT)

  1777.     jack_midi_clear_buffer(port_buffer);

  1778. #else

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

  1780.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  1781. #endif

  1782. }

  1783. 

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

  1785. {

  1786. #if defined(JACKBRIDGE_DUMMY)

  1787. #elif defined(JACKBRIDGE_DIRECT)

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

  1789. #else

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

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

  1792. #endif

  1793.     return false;

  1794. }

  1795. 

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

  1797. {

  1798. #if defined(JACKBRIDGE_DUMMY)

  1799. #elif defined(JACKBRIDGE_DIRECT)

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

  1801. #else

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

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

  1804. #endif

  1805.     return nullptr;

  1806. }

  1807. 

  1808. // -----------------------------------------------------------------------------

  1809. 

  1810. bool jackbridge_release_timebase(jack_client_t* client)

  1811. {

  1812. #if defined(JACKBRIDGE_DUMMY)

  1813. #elif defined(JACKBRIDGE_DIRECT)

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

  1815. #else

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

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

  1818. #endif

  1819.     return false;

  1820. }

  1821. 

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

  1823. {

  1824. #if defined(JACKBRIDGE_DUMMY)

  1825. #elif defined(JACKBRIDGE_DIRECT)

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

  1827. #else

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

  1829.     {

  1830. # ifdef __WINE__

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

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

  1833. # else

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

  1835. # endif

  1836.     }

  1837. #endif

  1838.     return false;

  1839. }

  1840. 

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

  1842. {

  1843. #if defined(JACKBRIDGE_DUMMY)

  1844. #elif defined(JACKBRIDGE_DIRECT)

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

  1846. #else

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

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

  1849. #endif

  1850.     return false;

  1851. }

  1852. 

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

  1854. {

  1855. #if defined(JACKBRIDGE_DUMMY)

  1856. #elif defined(JACKBRIDGE_DIRECT)

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

  1858. #else

  1859.     if (getBridgeInstance().set_timebase_callback_ptr != nullptr)

  1860.     {

  1861. # ifdef __WINE__

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

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

  1864. # else

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

  1866. # endif

  1867.     }

  1868. #endif

  1869.     return false;

  1870. }

  1871. 

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

  1873. {

  1874. #if defined(JACKBRIDGE_DUMMY)

  1875. #elif defined(JACKBRIDGE_DIRECT)

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

  1877. #else

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

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

  1880. #endif

  1881.     return false;

  1882. }

  1883. 

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

  1885. {

  1886. #if defined(JACKBRIDGE_DUMMY)

  1887. #elif defined(JACKBRIDGE_DIRECT)

  1888.     return jack_transport_query(client, pos);

  1889. #else

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

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

  1892. #endif

  1893.     if (pos != nullptr)

  1894.     {

  1895.         // invalidate

  1896.         pos->unique_1 = 0;

  1897.         pos->unique_2 = 1;

  1898.     }

  1899.     return JackTransportStopped;

  1900. }

  1901. 

  1902. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1903. {

  1904. #if defined(JACKBRIDGE_DUMMY)

  1905. #elif defined(JACKBRIDGE_DIRECT)

  1906.     return jack_get_current_transport_frame(client);

  1907. #else

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

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

  1910. #endif

  1911.     return 0;

  1912. }

  1913. 

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

  1915. {

  1916. #if defined(JACKBRIDGE_DUMMY)

  1917. #elif defined(JACKBRIDGE_DIRECT)

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

  1919. #else

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

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

  1922. #endif

  1923.     return false;

  1924. }

  1925. 

  1926. void jackbridge_transport_start(jack_client_t* client)

  1927. {

  1928. #if defined(JACKBRIDGE_DUMMY)

  1929. #elif defined(JACKBRIDGE_DIRECT)

  1930.     jack_transport_start(client);

  1931. #else

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

  1933.         getBridgeInstance().transport_start_ptr(client);

  1934. #endif

  1935. }

  1936. 

  1937. void jackbridge_transport_stop(jack_client_t* client)

  1938. {

  1939. #if defined(JACKBRIDGE_DUMMY)

  1940. #elif defined(JACKBRIDGE_DIRECT)

  1941.     jack_transport_stop(client);

  1942. #else

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

  1944.         getBridgeInstance().transport_stop_ptr(client);

  1945. #endif

  1946. }

  1947. 

  1948. // -----------------------------------------------------------------------------

  1949. 

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

  1951. {

  1952. #if defined(JACKBRIDGE_DUMMY)

  1953. #elif defined(JACKBRIDGE_DIRECT)

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

  1955. #else

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

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

  1958. #endif

  1959.     return false;

  1960. }

  1961. 

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

  1963. {

  1964. #if defined(JACKBRIDGE_DUMMY)

  1965. #elif defined(JACKBRIDGE_DIRECT)

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

  1967. #else

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

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

  1970. #endif

  1971.     return false;

  1972. }

  1973. 

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

  1975. {

  1976. #if defined(JACKBRIDGE_DUMMY)

  1977. #elif defined(JACKBRIDGE_DIRECT)

  1978.     jack_free_description(desc, free_description_itself);

  1979. #else

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

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

  1982. #endif

  1983. }

  1984. 

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

  1986. {

  1987. #if defined(JACKBRIDGE_DUMMY)

  1988. #elif defined(JACKBRIDGE_DIRECT)

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

  1990. #else

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

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

  1993. #endif

  1994.     return false;

  1995. }

  1996. 

  1997. bool jackbridge_get_all_properties(jack_description_t** descs)

  1998. {

  1999. #if defined(JACKBRIDGE_DUMMY)

  2000. #elif defined(JACKBRIDGE_DIRECT)

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

  2002. #else

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

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

  2005. #endif

  2006.     return false;

  2007. }

  2008. 

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

  2010. {

  2011. #if defined(JACKBRIDGE_DUMMY)

  2012. #elif defined(JACKBRIDGE_DIRECT)

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

  2014. #else

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

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

  2017. #endif

  2018.     return false;

  2019. }

  2020. 

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

  2022. {

  2023. #if defined(JACKBRIDGE_DUMMY)

  2024. #elif defined(JACKBRIDGE_DIRECT)

  2025.     return jack_remove_properties(client, subject);

  2026. #else

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

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

  2029. #endif

  2030.     return 0;

  2031. }

  2032. 

  2033. bool jackbridge_remove_all_properties(jack_client_t* client)

  2034. {

  2035. #if defined(JACKBRIDGE_DUMMY)

  2036. #elif defined(JACKBRIDGE_DIRECT)

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

  2038. #else

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

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

  2041. #endif

  2042.     return false;

  2043. }

  2044. 

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

  2046. {

  2047. #if defined(JACKBRIDGE_DUMMY)

  2048. #elif defined(JACKBRIDGE_DIRECT)

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

  2050. #else

  2051.     if (getBridgeInstance().set_property_change_callback_ptr != nullptr)

  2052.     {

  2053. # ifdef __WINE__

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

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

  2056. # else

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

  2058. # endif

  2059.     }

  2060. #endif

  2061.     return false;

  2062. }

  2063. 

  2064. // -----------------------------------------------------------------------------