falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
4847 Commits
17 Branches
116MB
Tree: 191939cd80
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '191939cd80'
${ noResults }
Carla/source/jackbridge/JackBridge1.cpp

2028 lines
71KB
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_get_uuid_for_client_name)(jack_client_t*, const char*);

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

  69. 

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

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

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

  73. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  88. 

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

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

  91. 

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

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

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

  95. 

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

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

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

  99. 

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

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

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

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

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

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

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

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

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

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

  110. 

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

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

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

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

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

  116. 

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

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

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

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

  121. 

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

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

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

  125. 

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

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

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

  129. 

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

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

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

  133. 

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

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

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

  137. 

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

  139. 

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

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

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

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

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

  145. 

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

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

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

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

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

  151. 

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

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

  154. 

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

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

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

  158. 

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

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

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

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

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

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

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

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

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

  168. 

  169. #ifdef __WINE__

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

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

  172. #endif

  173. 

  174. } // extern "C"

  175. 

  176. // -----------------------------------------------------------------------------

  177. 

  178. struct JackBridge {

  179.     lib_t lib;

  180. 

  181.     jacksym_get_version get_version_ptr;

  182.     jacksym_get_version_string get_version_string_ptr;

  183. 

  184.     jacksym_client_open client_open_ptr;

  185.     jacksym_client_close client_close_ptr;

  186. 

  187.     jacksym_client_name_size client_name_size_ptr;

  188.     jacksym_get_client_name get_client_name_ptr;

  189. 

  190.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  191.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  192. 

  193.     jacksym_activate activate_ptr;

  194.     jacksym_deactivate deactivate_ptr;

  195.     jacksym_is_realtime is_realtime_ptr;

  196. 

  197.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  198.     jacksym_on_shutdown on_shutdown_ptr;

  199.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  200.     jacksym_set_process_callback set_process_callback_ptr;

  201.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  202.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  203.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  204.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  205.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  206.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  207.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  208.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  209.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  210.     jacksym_set_latency_callback set_latency_callback_ptr;

  211. 

  212.     jacksym_set_freewheel set_freewheel_ptr;

  213.     jacksym_set_buffer_size set_buffer_size_ptr;

  214. 

  215.     jacksym_get_sample_rate get_sample_rate_ptr;

  216.     jacksym_get_buffer_size get_buffer_size_ptr;

  217.     jacksym_cpu_load cpu_load_ptr;

  218. 

  219.     jacksym_port_register port_register_ptr;

  220.     jacksym_port_unregister port_unregister_ptr;

  221.     jacksym_port_get_buffer port_get_buffer_ptr;

  222. 

  223.     jacksym_port_name port_name_ptr;

  224.     jacksym_port_uuid port_uuid_ptr;

  225.     jacksym_port_short_name port_short_name_ptr;

  226.     jacksym_port_flags port_flags_ptr;

  227.     jacksym_port_type port_type_ptr;

  228.     jacksym_port_is_mine port_is_mine_ptr;

  229.     jacksym_port_connected port_connected_ptr;

  230.     jacksym_port_connected_to port_connected_to_ptr;

  231.     jacksym_port_get_connections port_get_connections_ptr;

  232.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  233. 

  234.     jacksym_port_rename port_rename_ptr;

  235.     jacksym_port_set_name port_set_name_ptr;

  236.     jacksym_port_set_alias port_set_alias_ptr;

  237.     jacksym_port_unset_alias port_unset_alias_ptr;

  238.     jacksym_port_get_aliases port_get_aliases_ptr;

  239. 

  240.     jacksym_port_request_monitor port_request_monitor_ptr;

  241.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  242.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  243.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  244. 

  245.     jacksym_connect connect_ptr;

  246.     jacksym_disconnect disconnect_ptr;

  247.     jacksym_port_disconnect port_disconnect_ptr;

  248. 

  249.     jacksym_port_name_size port_name_size_ptr;

  250.     jacksym_port_type_size port_type_size_ptr;

  251.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  252. 

  253.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  254.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  255.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  256. 

  257.     jacksym_get_ports get_ports_ptr;

  258.     jacksym_port_by_name port_by_name_ptr;

  259.     jacksym_port_by_id port_by_id_ptr;

  260. 

  261.     jacksym_free free_ptr;

  262. 

  263.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  264.     jacksym_midi_event_get midi_event_get_ptr;

  265.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  266.     jacksym_midi_event_write midi_event_write_ptr;

  267.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  268. 

  269.     jacksym_release_timebase release_timebase_ptr;

  270.     jacksym_set_sync_callback set_sync_callback_ptr;

  271.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  272.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  273.     jacksym_transport_locate transport_locate_ptr;

  274. 

  275.     jacksym_transport_query transport_query_ptr;

  276.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  277. 

  278.     jacksym_transport_reposition transport_reposition_ptr;

  279.     jacksym_transport_start transport_start_ptr;

  280.     jacksym_transport_stop transport_stop_ptr;

  281. 

  282.     jacksym_set_property set_property_ptr;

  283.     jacksym_get_property get_property_ptr;

  284.     jacksym_free_description free_description_ptr;

  285.     jacksym_get_properties get_properties_ptr;

  286.     jacksym_get_all_properties get_all_properties_ptr;

  287.     jacksym_remove_property remove_property_ptr;

  288.     jacksym_remove_properties remove_properties_ptr;

  289.     jacksym_remove_all_properties remove_all_properties_ptr;

  290.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  291. 

  292. #ifdef __WINE__

  293.     jacksym_set_thread_creator set_thread_creator_ptr;

  294. #endif

  295. 

  296.     JackBridge()

  297.         : lib(nullptr),

  298.           get_version_ptr(nullptr),

  299.           get_version_string_ptr(nullptr),

  300.           client_open_ptr(nullptr),

  301.           client_close_ptr(nullptr),

  302.           client_name_size_ptr(nullptr),

  303.           get_client_name_ptr(nullptr),

  304.           get_uuid_for_client_name_ptr(nullptr),

  305.           get_client_name_by_uuid_ptr(nullptr),

  306.           activate_ptr(nullptr),

  307.           deactivate_ptr(nullptr),

  308.           is_realtime_ptr(nullptr),

  309.           set_thread_init_callback_ptr(nullptr),

  310.           on_shutdown_ptr(nullptr),

  311.           on_info_shutdown_ptr(nullptr),

  312.           set_process_callback_ptr(nullptr),

  313.           set_freewheel_callback_ptr(nullptr),

  314.           set_buffer_size_callback_ptr(nullptr),

  315.           set_sample_rate_callback_ptr(nullptr),

  316.           set_client_registration_callback_ptr(nullptr),

  317.           set_port_registration_callback_ptr(nullptr),

  318.           set_port_rename_callback_ptr(nullptr),

  319.           set_port_connect_callback_ptr(nullptr),

  320.           set_graph_order_callback_ptr(nullptr),

  321.           set_xrun_callback_ptr(nullptr),

  322.           set_latency_callback_ptr(nullptr),

  323.           set_freewheel_ptr(nullptr),

  324.           set_buffer_size_ptr(nullptr),

  325.           get_sample_rate_ptr(nullptr),

  326.           get_buffer_size_ptr(nullptr),

  327.           cpu_load_ptr(nullptr),

  328.           port_register_ptr(nullptr),

  329.           port_unregister_ptr(nullptr),

  330.           port_get_buffer_ptr(nullptr),

  331.           port_name_ptr(nullptr),

  332.           port_uuid_ptr(nullptr),

  333.           port_short_name_ptr(nullptr),

  334.           port_flags_ptr(nullptr),

  335.           port_type_ptr(nullptr),

  336.           port_is_mine_ptr(nullptr),

  337.           port_connected_ptr(nullptr),

  338.           port_connected_to_ptr(nullptr),

  339.           port_get_connections_ptr(nullptr),

  340.           port_get_all_connections_ptr(nullptr),

  341.           port_rename_ptr(nullptr),

  342.           port_set_name_ptr(nullptr),

  343.           port_set_alias_ptr(nullptr),

  344.           port_unset_alias_ptr(nullptr),

  345.           port_get_aliases_ptr(nullptr),

  346.           port_request_monitor_ptr(nullptr),

  347.           port_request_monitor_by_name_ptr(nullptr),

  348.           port_ensure_monitor_ptr(nullptr),

  349.           port_monitoring_input_ptr(nullptr),

  350.           connect_ptr(nullptr),

  351.           disconnect_ptr(nullptr),

  352.           port_disconnect_ptr(nullptr),

  353.           port_name_size_ptr(nullptr),

  354.           port_type_size_ptr(nullptr),

  355.           port_type_get_buffer_size_ptr(nullptr),

  356.           port_get_latency_range_ptr(nullptr),

  357.           port_set_latency_range_ptr(nullptr),

  358.           recompute_total_latencies_ptr(nullptr),

  359.           get_ports_ptr(nullptr),

  360.           port_by_name_ptr(nullptr),

  361.           port_by_id_ptr(nullptr),

  362.           free_ptr(nullptr),

  363.           midi_get_event_count_ptr(nullptr),

  364.           midi_event_get_ptr(nullptr),

  365.           midi_clear_buffer_ptr(nullptr),

  366.           midi_event_write_ptr(nullptr),

  367.           midi_event_reserve_ptr(nullptr),

  368.           release_timebase_ptr(nullptr),

  369.           set_sync_callback_ptr(nullptr),

  370.           set_sync_timeout_ptr(nullptr),

  371.           set_timebase_callback_ptr(nullptr),

  372.           transport_locate_ptr(nullptr),

  373.           transport_query_ptr(nullptr),

  374.           get_current_transport_frame_ptr(nullptr),

  375.           transport_reposition_ptr(nullptr),

  376.           transport_start_ptr(nullptr),

  377.           transport_stop_ptr(nullptr),

  378.           set_property_ptr(nullptr),

  379.           get_property_ptr(nullptr),

  380.           free_description_ptr(nullptr),

  381.           get_properties_ptr(nullptr),

  382.           get_all_properties_ptr(nullptr),

  383.           remove_property_ptr(nullptr),

  384.           remove_properties_ptr(nullptr),

  385.           remove_all_properties_ptr(nullptr),

  386.           set_property_change_callback_ptr(nullptr)

  387. #ifdef __WINE__

  388.         , set_thread_creator_ptr(nullptr)

  389. #endif

  390.     {

  391. # if defined(CARLA_OS_MAC)

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

  393. # elif defined(CARLA_OS_WIN64)

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

  395. # elif defined(CARLA_OS_WIN)

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

  397. # else

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

  399. # endif

  400. 

  401.         lib = lib_open(filename);

  402. 

  403.         if (lib == nullptr)

  404.         {

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

  406.             return;

  407.         }

  408.         else

  409.         {

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

  411.         }

  412. 

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

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

  415. 

  416.         LIB_SYMBOL(get_version)

  417.         LIB_SYMBOL(get_version_string)

  418. 

  419.         LIB_SYMBOL(client_open)

  420.         LIB_SYMBOL(client_close)

  421. 

  422.         LIB_SYMBOL(client_name_size)

  423.         LIB_SYMBOL(get_client_name)

  424. 

  425.         LIB_SYMBOL(get_uuid_for_client_name)

  426.         LIB_SYMBOL(get_client_name_by_uuid)

  427. 

  428.         LIB_SYMBOL(activate)

  429.         LIB_SYMBOL(deactivate)

  430.         LIB_SYMBOL(is_realtime)

  431. 

  432.         LIB_SYMBOL(set_thread_init_callback)

  433.         LIB_SYMBOL(on_shutdown)

  434.         LIB_SYMBOL(on_info_shutdown)

  435.         LIB_SYMBOL(set_process_callback)

  436.         LIB_SYMBOL(set_freewheel_callback)

  437.         LIB_SYMBOL(set_buffer_size_callback)

  438.         LIB_SYMBOL(set_sample_rate_callback)

  439.         LIB_SYMBOL(set_client_registration_callback)

  440.         LIB_SYMBOL(set_port_registration_callback)

  441.         LIB_SYMBOL(set_port_rename_callback)

  442.         LIB_SYMBOL(set_port_connect_callback)

  443.         LIB_SYMBOL(set_graph_order_callback)

  444.         LIB_SYMBOL(set_xrun_callback)

  445.         LIB_SYMBOL(set_latency_callback)

  446. 

  447.         LIB_SYMBOL(set_freewheel)

  448.         LIB_SYMBOL(set_buffer_size)

  449. 

  450.         LIB_SYMBOL(get_sample_rate)

  451.         LIB_SYMBOL(get_buffer_size)

  452.         LIB_SYMBOL(cpu_load)

  453. 

  454.         LIB_SYMBOL(port_register)

  455.         LIB_SYMBOL(port_unregister)

  456.         LIB_SYMBOL(port_get_buffer)

  457. 

  458.         LIB_SYMBOL(port_name)

  459.         LIB_SYMBOL(port_uuid)

  460.         LIB_SYMBOL(port_short_name)

  461.         LIB_SYMBOL(port_flags)

  462.         LIB_SYMBOL(port_type)

  463.         LIB_SYMBOL(port_is_mine)

  464.         LIB_SYMBOL(port_connected)

  465.         LIB_SYMBOL(port_connected_to)

  466.         LIB_SYMBOL(port_get_connections)

  467.         LIB_SYMBOL(port_get_all_connections)

  468. 

  469.         LIB_SYMBOL(port_rename)

  470.         LIB_SYMBOL(port_set_name)

  471.         LIB_SYMBOL(port_set_alias)

  472.         LIB_SYMBOL(port_unset_alias)

  473.         LIB_SYMBOL(port_get_aliases)

  474. 

  475.         LIB_SYMBOL(port_request_monitor)

  476.         LIB_SYMBOL(port_request_monitor_by_name)

  477.         LIB_SYMBOL(port_ensure_monitor)

  478.         LIB_SYMBOL(port_monitoring_input)

  479. 

  480.         LIB_SYMBOL(connect)

  481.         LIB_SYMBOL(disconnect)

  482.         LIB_SYMBOL(port_disconnect)

  483. 

  484.         LIB_SYMBOL(port_name_size)

  485.         LIB_SYMBOL(port_type_size)

  486.         LIB_SYMBOL(port_type_get_buffer_size)

  487. 

  488.         LIB_SYMBOL(port_get_latency_range)

  489.         LIB_SYMBOL(port_set_latency_range)

  490.         LIB_SYMBOL(recompute_total_latencies)

  491. 

  492.         LIB_SYMBOL(get_ports)

  493.         LIB_SYMBOL(port_by_name)

  494.         LIB_SYMBOL(port_by_id)

  495. 

  496.         LIB_SYMBOL(free)

  497. 

  498.         LIB_SYMBOL(midi_get_event_count)

  499.         LIB_SYMBOL(midi_event_get)

  500.         LIB_SYMBOL(midi_clear_buffer)

  501.         LIB_SYMBOL(midi_event_write)

  502.         LIB_SYMBOL(midi_event_reserve)

  503. 

  504.         LIB_SYMBOL(release_timebase)

  505.         LIB_SYMBOL(set_sync_callback)

  506.         LIB_SYMBOL(set_sync_timeout)

  507.         LIB_SYMBOL(set_timebase_callback)

  508.         LIB_SYMBOL(transport_locate)

  509.         LIB_SYMBOL(transport_query)

  510.         LIB_SYMBOL(get_current_transport_frame)

  511.         LIB_SYMBOL(transport_reposition)

  512.         LIB_SYMBOL(transport_start)

  513.         LIB_SYMBOL(transport_stop)

  514. 

  515.         LIB_SYMBOL(set_property)

  516.         LIB_SYMBOL(get_property)

  517.         LIB_SYMBOL(free_description)

  518.         LIB_SYMBOL(get_properties)

  519.         LIB_SYMBOL(get_all_properties)

  520.         LIB_SYMBOL(remove_property)

  521.         LIB_SYMBOL(remove_properties)

  522.         LIB_SYMBOL(remove_all_properties)

  523.         LIB_SYMBOL(set_property_change_callback)

  524. 

  525. #ifdef __WINE__

  526.         LIB_SYMBOL(set_thread_creator)

  527. #endif

  528. 

  529.         #undef JOIN

  530.         #undef LIB_SYMBOL

  531.     }

  532. 

  533.     ~JackBridge() noexcept

  534.     {

  535.         if (lib != nullptr)

  536.         {

  537.             lib_close(lib);

  538.             lib = nullptr;

  539.         }

  540.     }

  541. 

  542.     CARLA_DECLARE_NON_COPY_STRUCT(JackBridge);

  543. };

  544. 

  545. // -----------------------------------------------------------------------------

  546. 

  547. static const JackBridge& getBridgeInstance() noexcept

  548. {

  549.     static const JackBridge bridge;

  550.     return bridge;

  551. }

  552. 

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

  554. 

  555. // -----------------------------------------------------------------------------

  556. 

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

  558. 

  559. struct WineBridge {

  560.     void* ptr;

  561.     JackLatencyCallback latency_cb;

  562.     JackProcessCallback process_cb;

  563.     JackThreadInitCallback thread_init_cb;

  564.     JackGraphOrderCallback graph_order_cb;

  565.     JackXRunCallback xrun_cb;

  566.     JackBufferSizeCallback bufsize_cb;

  567.     JackSampleRateCallback srate_cb;

  568.     JackPortRegistrationCallback port_reg_cb;

  569.     JackClientRegistrationCallback client_reg_cb;

  570.     JackPortConnectCallback port_conn_cb;

  571.     JackPortRenameCallback port_rename_cb;

  572.     JackFreewheelCallback freewheel_cb;

  573.     JackShutdownCallback shutdown_cb;

  574.     JackInfoShutdownCallback info_shutdown_cb;

  575.     JackSyncCallback sync_cb;

  576.     JackTimebaseCallback timebase_cb;

  577.     JackSessionCallback session_cb;

  578.     JackPropertyChangeCallback prop_change_cb;

  579. 

  580.     void* (*creator_func)(void*);

  581.     void* creator_arg;

  582.     HANDLE creator_handle;

  583.     pthread_t creator_pthread;

  584. 

  585.     WineBridge() noexcept

  586.         : ptr(nullptr),

  587.           latency_cb(nullptr),

  588.           process_cb(nullptr),

  589.           thread_init_cb(nullptr),

  590.           graph_order_cb(nullptr),

  591.           xrun_cb(nullptr),

  592.           bufsize_cb(nullptr),

  593.           srate_cb(nullptr),

  594.           port_reg_cb(nullptr),

  595.           client_reg_cb(nullptr),

  596.           port_conn_cb(nullptr),

  597.           port_rename_cb(nullptr),

  598.           freewheel_cb(nullptr),

  599.           shutdown_cb(nullptr),

  600.           info_shutdown_cb(nullptr),

  601.           sync_cb(nullptr),

  602.           timebase_cb(nullptr),

  603.           session_cb(nullptr),

  604.           prop_change_cb(nullptr),

  605.           creator_func(nullptr),

  606.           creator_arg(nullptr),

  607.           creator_handle(nullptr),

  608.           creator_pthread(0) {}

  609. 

  610.     static WineBridge& getInstance() noexcept

  611.     {

  612.         static WineBridge bridge;

  613.         return bridge;

  614.     }

  615. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  634. 

  635.     static DWORD WINAPI thread_creator_helper(LPVOID)

  636.     {

  637.         WineBridge& inst(getInstance());

  638. 

  639.         inst.creator_pthread = pthread_self();

  640.         SetEvent(inst.creator_handle);

  641.         inst.creator_func(inst.creator_arg);

  642.         return 0;

  643.     }

  644. 

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

  646.     {

  647.         WineBridge& inst(getInstance());

  648. 

  649.         inst.creator_func   = function;

  650.         inst.creator_arg    = arg;

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

  652. 

  653. #if 0

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

  655. #else

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

  657. 

  658.         if (handle == INVALID_HANDLE_VALUE)

  659.             return 1;

  660. 

  661.         // TODO read attrs and decide this

  662.         ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);

  663.         ::ResumeThread(handle);

  664. #endif

  665. 

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

  667.         *thread_id = inst.creator_pthread;

  668.         return 0;

  669.     }

  670. 

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

  672.     {

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

  674.     }

  675. 

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

  677.     {

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

  679.     }

  680. 

  681.     static void thread_init(void* arg)

  682.     {

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

  684.     }

  685. 

  686.     static int graph_order(void* arg)

  687.     {

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

  689.     }

  690. 

  691.     static int xrun(void* arg)

  692.     {

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

  694.     }

  695. 

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

  697.     {

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

  699.     }

  700. 

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

  702.     {

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

  704.     }

  705. 

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

  707.     {

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

  709.     }

  710. 

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

  712.     {

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

  714.     }

  715. 

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

  717.     {

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

  719.     }

  720. 

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

  722.     {

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

  724.     }

  725. 

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

  727.     {

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

  729.     }

  730. 

  731.     static void shutdown(void* arg)

  732.     {

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

  734.     }

  735. 

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

  737.     {

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

  739.     }

  740. 

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

  742.     {

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

  744.     }

  745. 

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

  747.     {

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

  749.     }

  750. 

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

  752.     {

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

  754.     }

  755. 

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

  757.     {

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

  759.     }

  760. 

  761.     CARLA_DECLARE_NON_COPY_STRUCT(WineBridge);

  762. };

  763. 

  764. #endif // __WINE__ && ! JACKBRIDGE_DIRECT

  765. 

  766. // -----------------------------------------------------------------------------

  767. 

  768. bool jackbridge_is_ok() noexcept

  769. {

  770. #if defined(JACKBRIDGE_DUMMY)

  771.     return false;

  772. #elif defined(JACKBRIDGE_DIRECT)

  773.     return true;

  774. #else

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

  776. #endif

  777. }

  778. 

  779. void jackbridge_init()

  780. {

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

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

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

  784. #endif

  785. }

  786. 

  787. // -----------------------------------------------------------------------------

  788. 

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

  790. {

  791. #if defined(JACKBRIDGE_DUMMY)

  792. #elif defined(JACKBRIDGE_DIRECT)

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

  794. #else

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

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

  797. #endif

  798.     if (major_ptr != nullptr)

  799.         *major_ptr = 0;

  800.     if (minor_ptr != nullptr)

  801.         *minor_ptr = 0;

  802.     if (micro_ptr != nullptr)

  803.         *micro_ptr = 0;

  804.     if (proto_ptr != nullptr)

  805.         *proto_ptr = 0;

  806. }

  807. 

  808. const char* jackbridge_get_version_string()

  809. {

  810. #if defined(JACKBRIDGE_DUMMY)

  811. #elif defined(JACKBRIDGE_DIRECT)

  812.     return jack_get_version_string();

  813. #else

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

  815.         return getBridgeInstance().get_version_string_ptr();

  816. #endif

  817.     return nullptr;

  818. }

  819. 

  820. // -----------------------------------------------------------------------------

  821. 

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

  823. {

  824. #if defined(JACKBRIDGE_DUMMY)

  825. #elif defined(JACKBRIDGE_DIRECT)

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

  827. #else

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

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

  830. #endif

  831.     if (status != nullptr)

  832.         *status = JackServerError;

  833.     return nullptr;

  834. }

  835. 

  836. bool jackbridge_client_close(jack_client_t* client)

  837. {

  838. #if defined(JACKBRIDGE_DUMMY)

  839. #elif defined(JACKBRIDGE_DIRECT)

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

  841. #else

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

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

  844. #endif

  845.     return false;

  846. }

  847. 

  848. // -----------------------------------------------------------------------------

  849. 

  850. int jackbridge_client_name_size()

  851. {

  852. #if defined(JACKBRIDGE_DUMMY)

  853. #elif defined(JACKBRIDGE_DIRECT)

  854.     return jack_client_name_size();

  855. #else

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

  857.         return getBridgeInstance().client_name_size_ptr();

  858. #endif

  859.     return 33;

  860. }

  861. 

  862. char* jackbridge_get_client_name(jack_client_t* client)

  863. {

  864. #if defined(JACKBRIDGE_DUMMY)

  865. #elif defined(JACKBRIDGE_DIRECT)

  866.     return jack_get_client_name(client);

  867. #else

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

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

  870. #endif

  871.     return nullptr;

  872. }

  873. 

  874. // -----------------------------------------------------------------------------

  875. 

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

  877. {

  878. #if defined(JACKBRIDGE_DUMMY)

  879. #elif defined(JACKBRIDGE_DIRECT)

  880.     return jack_get_uuid_for_client_name(client, name);

  881. #else

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

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

  884. #endif

  885.     return nullptr;

  886. }

  887. 

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

  889. {

  890. #if defined(JACKBRIDGE_DUMMY)

  891. #elif defined(JACKBRIDGE_DIRECT)

  892.     return jack_get_client_name_by_uuid(client, uuid);

  893. #else

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

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

  896. #endif

  897.     return nullptr;

  898. }

  899. 

  900. // -----------------------------------------------------------------------------

  901. 

  902. bool jackbridge_activate(jack_client_t* client)

  903. {

  904. #if defined(JACKBRIDGE_DUMMY)

  905. #elif defined(JACKBRIDGE_DIRECT)

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

  907. #else

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

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

  910. #endif

  911.     return false;

  912. }

  913. 

  914. bool jackbridge_deactivate(jack_client_t* client)

  915. {

  916. #if defined(JACKBRIDGE_DUMMY)

  917. #elif defined(JACKBRIDGE_DIRECT)

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

  919. #else

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

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

  922. #endif

  923.     return false;

  924. }

  925. 

  926. bool jackbridge_is_realtime(jack_client_t* client)

  927. {

  928. #if defined(JACKBRIDGE_DUMMY)

  929. #elif defined(JACKBRIDGE_DIRECT)

  930.     return jack_is_realtime(client);

  931. #else

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

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

  934. #endif

  935.     return false;

  936. }

  937. 

  938. // -----------------------------------------------------------------------------

  939. 

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

  941. {

  942. #if defined(JACKBRIDGE_DUMMY)

  943. #elif defined(JACKBRIDGE_DIRECT)

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

  945. #else

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

  947.     {

  948. # ifdef __WINE__

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

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

  951. # else

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

  953. # endif

  954.     }

  955. #endif

  956.     return false;

  957. }

  958. 

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

  960. {

  961. #if defined(JACKBRIDGE_DUMMY)

  962. #elif defined(JACKBRIDGE_DIRECT)

  963.     jack_on_shutdown(client, shutdown_callback, arg);

  964. #else

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

  966.     {

  967. # ifdef __WINE__

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

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

  970. # else

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

  972. # endif

  973.     }

  974. #endif

  975. }

  976. 

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

  978. {

  979. #if defined(JACKBRIDGE_DUMMY)

  980. #elif defined(JACKBRIDGE_DIRECT)

  981.     jack_on_info_shutdown(client, shutdown_callback, arg);

  982. #else

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

  984.     {

  985. # ifdef __WINE__

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

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

  988. # else

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

  990. # endif

  991.     }

  992. #endif

  993. }

  994. 

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

  996. {

  997. #if defined(JACKBRIDGE_DUMMY)

  998. #elif defined(JACKBRIDGE_DIRECT)

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

  1000. #else

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

  1002.     {

  1003. # ifdef __WINE__

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

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

  1006. # else

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

  1008. # endif

  1009.     }

  1010. #endif

  1011.     return false;

  1012. }

  1013. 

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

  1015. {

  1016. #if defined(JACKBRIDGE_DUMMY)

  1017. #elif defined(JACKBRIDGE_DIRECT)

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

  1019. #else

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

  1021.     {

  1022. # ifdef __WINE__

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

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

  1025. # else

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

  1027. # endif

  1028.     }

  1029. #endif

  1030.     return false;

  1031. }

  1032. 

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

  1034. {

  1035. #if defined(JACKBRIDGE_DUMMY)

  1036. #elif defined(JACKBRIDGE_DIRECT)

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

  1038. #else

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

  1040.     {

  1041. # ifdef __WINE__

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

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

  1044. # else

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

  1046. # endif

  1047.     }

  1048. #endif

  1049.     return false;

  1050. }

  1051. 

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

  1053. {

  1054. #if defined(JACKBRIDGE_DUMMY)

  1055. #elif defined(JACKBRIDGE_DIRECT)

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

  1057. #else

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

  1059.     {

  1060. # ifdef __WINE__

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

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

  1063. # else

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

  1065. # endif

  1066.     }

  1067. #endif

  1068.     return false;

  1069. }

  1070. 

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

  1072. {

  1073. #if defined(JACKBRIDGE_DUMMY)

  1074. #elif defined(JACKBRIDGE_DIRECT)

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

  1076. #else

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

  1078.     {

  1079. # ifdef __WINE__

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

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

  1082. # else

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

  1084. # endif

  1085.     }

  1086. #endif

  1087.     return false;

  1088. }

  1089. 

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

  1091. {

  1092. #if defined(JACKBRIDGE_DUMMY)

  1093. #elif defined(JACKBRIDGE_DIRECT)

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

  1095. #else

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

  1097.     {

  1098. # ifdef __WINE__

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

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

  1101. # else

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

  1103. # endif

  1104.     }

  1105. #endif

  1106.     return false;

  1107. }

  1108. 

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

  1110. {

  1111. #if defined(JACKBRIDGE_DUMMY)

  1112. #elif defined(JACKBRIDGE_DIRECT)

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

  1114. #else

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

  1116.     {

  1117. # ifdef __WINE__

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

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

  1120. # else

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

  1122. # endif

  1123.     }

  1124. #endif

  1125.     return false;

  1126. }

  1127. 

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

  1129. {

  1130. #if defined(JACKBRIDGE_DUMMY)

  1131. #elif defined(JACKBRIDGE_DIRECT)

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

  1133. #else

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

  1135.     {

  1136. # ifdef __WINE__

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

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

  1139. # else

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

  1141. # endif

  1142.     }

  1143. #endif

  1144.     return false;

  1145. }

  1146. 

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

  1148. {

  1149. #if defined(JACKBRIDGE_DUMMY)

  1150. #elif defined(JACKBRIDGE_DIRECT)

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

  1152. #else

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

  1154.     {

  1155. # ifdef __WINE__

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

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

  1158. # else

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

  1160. # endif

  1161.     }

  1162. #endif

  1163.     return false;

  1164. }

  1165. 

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

  1167. {

  1168. #if defined(JACKBRIDGE_DUMMY)

  1169. #elif defined(JACKBRIDGE_DIRECT)

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

  1171. #else

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

  1173.     {

  1174. # ifdef __WINE__

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

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

  1177. # else

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

  1179. # endif

  1180.     }

  1181. #endif

  1182.     return false;

  1183. }

  1184. 

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

  1186. {

  1187. #if defined(JACKBRIDGE_DUMMY)

  1188. #elif defined(JACKBRIDGE_DIRECT)

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

  1190. #else

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

  1192.     {

  1193. # ifdef __WINE__

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

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

  1196. # else

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

  1198. # endif

  1199.     }

  1200. #endif

  1201.     return false;

  1202. }

  1203. 

  1204. // -----------------------------------------------------------------------------

  1205. 

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

  1207. {

  1208. #if defined(JACKBRIDGE_DUMMY)

  1209. #elif defined(JACKBRIDGE_DIRECT)

  1210.     return jack_set_freewheel(client, onoff);

  1211. #else

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

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

  1214. #endif

  1215.     return false;

  1216. }

  1217. 

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

  1219. {

  1220. #if defined(JACKBRIDGE_DUMMY)

  1221. #elif defined(JACKBRIDGE_DIRECT)

  1222.     return jack_set_buffer_size(client, nframes);

  1223. #else

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

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

  1226. #endif

  1227.     return false;

  1228. }

  1229. 

  1230. // -----------------------------------------------------------------------------

  1231. 

  1232. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1233. {

  1234. #if defined(JACKBRIDGE_DUMMY)

  1235. #elif defined(JACKBRIDGE_DIRECT)

  1236.     return jack_get_sample_rate(client);

  1237. #else

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

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

  1240. #endif

  1241.     return 0;

  1242. }

  1243. 

  1244. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1245. {

  1246. #if defined(JACKBRIDGE_DUMMY)

  1247. #elif defined(JACKBRIDGE_DIRECT)

  1248.     return jack_get_buffer_size(client);

  1249. #else

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

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

  1252. #endif

  1253.     return 0;

  1254. }

  1255. 

  1256. float jackbridge_cpu_load(jack_client_t* client)

  1257. {

  1258. #if defined(JACKBRIDGE_DUMMY)

  1259. #elif defined(JACKBRIDGE_DIRECT)

  1260.     return jack_cpu_load(client);

  1261. #else

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

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

  1264. #endif

  1265.     return 0.0f;

  1266. }

  1267. 

  1268. // -----------------------------------------------------------------------------

  1269. 

  1270. 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)

  1271. {

  1272. #if defined(JACKBRIDGE_DUMMY)

  1273. #elif defined(JACKBRIDGE_DIRECT)

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

  1275. #else

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

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

  1278.                                                      static_cast<ulong>(flags),

  1279.                                                      static_cast<ulong>(buffer_size));

  1280. #endif

  1281.     return nullptr;

  1282. }

  1283. 

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

  1285. {

  1286. #if defined(JACKBRIDGE_DUMMY)

  1287. #elif defined(JACKBRIDGE_DIRECT)

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

  1289. #else

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

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

  1292. #endif

  1293.     return false;

  1294. }

  1295. 

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

  1297. {

  1298. #if defined(JACKBRIDGE_DUMMY)

  1299. #elif defined(JACKBRIDGE_DIRECT)

  1300.     return jack_port_get_buffer(port, nframes);

  1301. #else

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

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

  1304. #endif

  1305.     return nullptr;

  1306. }

  1307. 

  1308. // -----------------------------------------------------------------------------

  1309. 

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

  1311. {

  1312. #if defined(JACKBRIDGE_DUMMY)

  1313. #elif defined(JACKBRIDGE_DIRECT)

  1314.     return jack_port_name(port);

  1315. #else

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

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

  1318. #endif

  1319.     return nullptr;

  1320. }

  1321. 

  1322. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1323. {

  1324. #if defined(JACKBRIDGE_DUMMY)

  1325. #elif defined(JACKBRIDGE_DIRECT)

  1326.     return jack_port_uuid(port);

  1327. #else

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

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

  1330. #endif

  1331.     return 0;

  1332. }

  1333. 

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

  1335. {

  1336. #if defined(JACKBRIDGE_DUMMY)

  1337. #elif defined(JACKBRIDGE_DIRECT)

  1338.     return jack_port_short_name(port);

  1339. #else

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

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

  1342. #endif

  1343.     return nullptr;

  1344. }

  1345. 

  1346. int jackbridge_port_flags(const jack_port_t* port)

  1347. {

  1348. #if defined(JACKBRIDGE_DUMMY)

  1349. #elif defined(JACKBRIDGE_DIRECT)

  1350.     return jack_port_flags(port);

  1351. #else

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

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

  1354. #endif

  1355.     return 0x0;

  1356. }

  1357. 

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

  1359. {

  1360. #if defined(JACKBRIDGE_DUMMY)

  1361. #elif defined(JACKBRIDGE_DIRECT)

  1362.     return jack_port_type(port);

  1363. #else

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

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

  1366. #endif

  1367.     return nullptr;

  1368. }

  1369. 

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

  1371. {

  1372. #if defined(JACKBRIDGE_DUMMY)

  1373. #elif defined(JACKBRIDGE_DIRECT)

  1374.     return jack_port_is_mine(client, port);

  1375. #else

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

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

  1378. #endif

  1379.     return false;

  1380. }

  1381. 

  1382. int jackbridge_port_connected(const jack_port_t* port)

  1383. {

  1384. #if defined(JACKBRIDGE_DUMMY)

  1385. #elif defined(JACKBRIDGE_DIRECT)

  1386.     return jack_port_connected(port);

  1387. #else

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

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

  1390. #endif

  1391.     return 0;

  1392. }

  1393. 

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

  1395. {

  1396. #if defined(JACKBRIDGE_DUMMY)

  1397. #elif defined(JACKBRIDGE_DIRECT)

  1398.     return jack_port_connected_to(port, port_name);

  1399. #else

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

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

  1402. #endif

  1403.     return false;

  1404. }

  1405. 

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

  1407. {

  1408. #if defined(JACKBRIDGE_DUMMY)

  1409. #elif defined(JACKBRIDGE_DIRECT)

  1410.     return jack_port_get_connections(port);

  1411. #else

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

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

  1414. #endif

  1415.     return nullptr;

  1416. }

  1417. 

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

  1419. {

  1420. #if defined(JACKBRIDGE_DUMMY)

  1421. #elif defined(JACKBRIDGE_DIRECT)

  1422.     return jack_port_get_all_connections(client, port);

  1423. #else

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

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

  1426. #endif

  1427.     return nullptr;

  1428. }

  1429. 

  1430. // -----------------------------------------------------------------------------

  1431. 

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

  1433. {

  1434. #if defined(JACKBRIDGE_DUMMY)

  1435. #elif defined(JACKBRIDGE_DIRECT)

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

  1437. #else

  1438.     // Try new API first

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

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

  1441.     // Try old API if using JACK2

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

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

  1444. #endif

  1445.     return false;

  1446. }

  1447. 

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

  1449. {

  1450. #if defined(JACKBRIDGE_DUMMY)

  1451. #elif defined(JACKBRIDGE_DIRECT)

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

  1453. #else

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

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

  1456. #endif

  1457.     return false;

  1458. }

  1459. 

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

  1461. {

  1462. #if defined(JACKBRIDGE_DUMMY)

  1463. #elif defined(JACKBRIDGE_DIRECT)

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

  1465. #else

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

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

  1468. #endif

  1469.     return false;

  1470. }

  1471. 

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

  1473. {

  1474. #if defined(JACKBRIDGE_DUMMY)

  1475. #elif defined(JACKBRIDGE_DIRECT)

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

  1477. #else

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

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

  1480. #endif

  1481.     return 0;

  1482. }

  1483. 

  1484. // -----------------------------------------------------------------------------

  1485. 

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

  1487. {

  1488. #if defined(JACKBRIDGE_DUMMY)

  1489. #elif defined(JACKBRIDGE_DIRECT)

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

  1491. #else

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

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

  1494. #endif

  1495.     return false;

  1496. }

  1497. 

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

  1499. {

  1500. #if defined(JACKBRIDGE_DUMMY)

  1501. #elif defined(JACKBRIDGE_DIRECT)

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

  1503. #else

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

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

  1506. #endif

  1507.     return false;

  1508. }

  1509. 

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

  1511. {

  1512. #if defined(JACKBRIDGE_DUMMY)

  1513. #elif defined(JACKBRIDGE_DIRECT)

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

  1515. #else

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

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

  1518. #endif

  1519.     return false;

  1520. }

  1521. 

  1522. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1523. {

  1524. #if defined(JACKBRIDGE_DUMMY)

  1525. #elif defined(JACKBRIDGE_DIRECT)

  1526.     return jack_port_monitoring_input(port);

  1527. #else

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

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

  1530. #endif

  1531.     return false;

  1532. }

  1533. 

  1534. // -----------------------------------------------------------------------------

  1535. 

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

  1537. {

  1538. #if defined(JACKBRIDGE_DUMMY)

  1539. #elif defined(JACKBRIDGE_DIRECT)

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

  1541. #else

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

  1543.     {

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

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

  1546.     }

  1547. #endif

  1548.     return false;

  1549. }

  1550. 

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

  1552. {

  1553. #if defined(JACKBRIDGE_DUMMY)

  1554. #elif defined(JACKBRIDGE_DIRECT)

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

  1556. #else

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

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

  1559. #endif

  1560.     return false;

  1561. }

  1562. 

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

  1564. {

  1565. #if defined(JACKBRIDGE_DUMMY)

  1566. #elif defined(JACKBRIDGE_DIRECT)

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

  1568. #else

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

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

  1571. #endif

  1572.     return false;

  1573. }

  1574. 

  1575. // -----------------------------------------------------------------------------

  1576. 

  1577. int jackbridge_port_name_size()

  1578. {

  1579. #if defined(JACKBRIDGE_DUMMY)

  1580. #elif defined(JACKBRIDGE_DIRECT)

  1581.     return jack_port_name_size();

  1582. #else

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

  1584.         return getBridgeInstance().port_name_size_ptr();

  1585. #endif

  1586.     return 256;

  1587. }

  1588. 

  1589. int jackbridge_port_type_size()

  1590. {

  1591. #if defined(JACKBRIDGE_DUMMY)

  1592. #elif defined(JACKBRIDGE_DIRECT)

  1593.     return jack_port_type_size();

  1594. #else

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

  1596.         return getBridgeInstance().port_type_size_ptr();

  1597. #endif

  1598.     return 32;

  1599. }

  1600. 

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

  1602. {

  1603. #if defined(JACKBRIDGE_DUMMY)

  1604. #elif defined(JACKBRIDGE_DIRECT)

  1605.     return jack_port_type_get_buffer_size(client, port_type);

  1606. #else

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

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

  1609. #endif

  1610.     return 0;

  1611. }

  1612. 

  1613. // -----------------------------------------------------------------------------

  1614. 

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

  1616. {

  1617. #if defined(JACKBRIDGE_DUMMY)

  1618. #elif defined(JACKBRIDGE_DIRECT)

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

  1620. #else

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

  1622.         return getBridgeInstance().port_get_latency_range_ptr(port,

  1623.                                                               static_cast<jack_latency_callback_mode_t>(mode),

  1624.                                                               range);

  1625. #endif

  1626.     range->min = 0;

  1627.     range->max = 0;

  1628. }

  1629. 

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

  1631. {

  1632. #if defined(JACKBRIDGE_DUMMY)

  1633. #elif defined(JACKBRIDGE_DIRECT)

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

  1635. #else

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

  1637.         getBridgeInstance().port_set_latency_range_ptr(port,

  1638.                                                        static_cast<jack_latency_callback_mode_t>(mode),

  1639.                                                        range);

  1640. #endif

  1641. }

  1642. 

  1643. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1644. {

  1645. #if defined(JACKBRIDGE_DUMMY)

  1646. #elif defined(JACKBRIDGE_DIRECT)

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

  1648. #else

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

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

  1651. #endif

  1652.     return false;

  1653. }

  1654. 

  1655. // -----------------------------------------------------------------------------

  1656. 

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

  1658. {

  1659. #if defined(JACKBRIDGE_DUMMY)

  1660. #elif defined(JACKBRIDGE_DIRECT)

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

  1662. #else

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

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

  1665.                                                  static_cast<ulong>(flags));

  1666. #endif

  1667.     return nullptr;

  1668. }

  1669. 

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

  1671. {

  1672. #if defined(JACKBRIDGE_DUMMY)

  1673. #elif defined(JACKBRIDGE_DIRECT)

  1674.     return jack_port_by_name(client, port_name);

  1675. #else

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

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

  1678. #endif

  1679.     return nullptr;

  1680. }

  1681. 

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

  1683. {

  1684. #if defined(JACKBRIDGE_DUMMY)

  1685. #elif defined(JACKBRIDGE_DIRECT)

  1686.     return jack_port_by_id(client, port_id);

  1687. #else

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

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

  1690. #endif

  1691.     return nullptr;

  1692. }

  1693. 

  1694. // -----------------------------------------------------------------------------

  1695. 

  1696. void jackbridge_free(void* ptr)

  1697. {

  1698. #if defined(JACKBRIDGE_DUMMY)

  1699. #elif defined(JACKBRIDGE_DIRECT)

  1700.     return jack_free(ptr);

  1701. #else

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

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

  1704. 

  1705.     // just in case

  1706.     std::free(ptr);

  1707. #endif

  1708. }

  1709. 

  1710. // -----------------------------------------------------------------------------

  1711. 

  1712. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1713. {

  1714. #if defined(JACKBRIDGE_DUMMY)

  1715. #elif defined(JACKBRIDGE_DIRECT)

  1716.     return jack_midi_get_event_count(port_buffer);

  1717. #else

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

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

  1720. #endif

  1721.     return 0;

  1722. }

  1723. 

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

  1725. {

  1726. #if defined(JACKBRIDGE_DUMMY)

  1727. #elif defined(JACKBRIDGE_DIRECT)

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

  1729. #else

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

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

  1732. #endif

  1733.     return false;

  1734. }

  1735. 

  1736. void jackbridge_midi_clear_buffer(void* port_buffer)

  1737. {

  1738. #if defined(JACKBRIDGE_DUMMY)

  1739. #elif defined(JACKBRIDGE_DIRECT)

  1740.     jack_midi_clear_buffer(port_buffer);

  1741. #else

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

  1743.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  1744. #endif

  1745. }

  1746. 

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

  1748. {

  1749. #if defined(JACKBRIDGE_DUMMY)

  1750. #elif defined(JACKBRIDGE_DIRECT)

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

  1752. #else

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

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

  1755. #endif

  1756.     return false;

  1757. }

  1758. 

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

  1760. {

  1761. #if defined(JACKBRIDGE_DUMMY)

  1762. #elif defined(JACKBRIDGE_DIRECT)

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

  1764. #else

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

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

  1767. #endif

  1768.     return nullptr;

  1769. }

  1770. 

  1771. // -----------------------------------------------------------------------------

  1772. 

  1773. bool jackbridge_release_timebase(jack_client_t* client)

  1774. {

  1775. #if defined(JACKBRIDGE_DUMMY)

  1776. #elif defined(JACKBRIDGE_DIRECT)

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

  1778. #else

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

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

  1781. #endif

  1782.     return false;

  1783. }

  1784. 

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

  1786. {

  1787. #if defined(JACKBRIDGE_DUMMY)

  1788. #elif defined(JACKBRIDGE_DIRECT)

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

  1790. #else

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

  1792.     {

  1793. # ifdef __WINE__

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

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

  1796. # else

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

  1798. # endif

  1799.     }

  1800. #endif

  1801.     return false;

  1802. }

  1803. 

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

  1805. {

  1806. #if defined(JACKBRIDGE_DUMMY)

  1807. #elif defined(JACKBRIDGE_DIRECT)

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

  1809. #else

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

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

  1812. #endif

  1813.     return false;

  1814. }

  1815. 

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

  1817. {

  1818. #if defined(JACKBRIDGE_DUMMY)

  1819. #elif defined(JACKBRIDGE_DIRECT)

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

  1821. #else

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

  1823.     {

  1824. # ifdef __WINE__

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

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

  1827. # else

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

  1829. # endif

  1830.     }

  1831. #endif

  1832.     return false;

  1833. }

  1834. 

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

  1836. {

  1837. #if defined(JACKBRIDGE_DUMMY)

  1838. #elif defined(JACKBRIDGE_DIRECT)

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

  1840. #else

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

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

  1843. #endif

  1844.     return false;

  1845. }

  1846. 

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

  1848. {

  1849. #if defined(JACKBRIDGE_DUMMY)

  1850. #elif defined(JACKBRIDGE_DIRECT)

  1851.     return jack_transport_query(client, pos);

  1852. #else

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

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

  1855. #endif

  1856.     if (pos != nullptr)

  1857.     {

  1858.         // invalidate

  1859.         pos->unique_1 = 0;

  1860.         pos->unique_2 = 1;

  1861.     }

  1862.     return JackTransportStopped;

  1863. }

  1864. 

  1865. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1866. {

  1867. #if defined(JACKBRIDGE_DUMMY)

  1868. #elif defined(JACKBRIDGE_DIRECT)

  1869.     return jack_get_current_transport_frame(client);

  1870. #else

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

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

  1873. #endif

  1874.     return 0;

  1875. }

  1876. 

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

  1878. {

  1879. #if defined(JACKBRIDGE_DUMMY)

  1880. #elif defined(JACKBRIDGE_DIRECT)

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

  1882. #else

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

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

  1885. #endif

  1886.     return false;

  1887. }

  1888. 

  1889. void jackbridge_transport_start(jack_client_t* client)

  1890. {

  1891. #if defined(JACKBRIDGE_DUMMY)

  1892. #elif defined(JACKBRIDGE_DIRECT)

  1893.     jack_transport_start(client);

  1894. #else

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

  1896.         getBridgeInstance().transport_start_ptr(client);

  1897. #endif

  1898. }

  1899. 

  1900. void jackbridge_transport_stop(jack_client_t* client)

  1901. {

  1902. #if defined(JACKBRIDGE_DUMMY)

  1903. #elif defined(JACKBRIDGE_DIRECT)

  1904.     jack_transport_stop(client);

  1905. #else

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

  1907.         getBridgeInstance().transport_stop_ptr(client);

  1908. #endif

  1909. }

  1910. 

  1911. // -----------------------------------------------------------------------------

  1912. 

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

  1914. {

  1915. #if defined(JACKBRIDGE_DUMMY)

  1916. #elif defined(JACKBRIDGE_DIRECT)

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

  1918. #else

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

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

  1921. #endif

  1922.     return false;

  1923. }

  1924. 

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

  1926. {

  1927. #if defined(JACKBRIDGE_DUMMY)

  1928. #elif defined(JACKBRIDGE_DIRECT)

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

  1930. #else

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

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

  1933. #endif

  1934.     return false;

  1935. }

  1936. 

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

  1938. {

  1939. #if defined(JACKBRIDGE_DUMMY)

  1940. #elif defined(JACKBRIDGE_DIRECT)

  1941.     jack_free_description(desc, free_description_itself);

  1942. #else

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

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

  1945. #endif

  1946. }

  1947. 

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

  1949. {

  1950. #if defined(JACKBRIDGE_DUMMY)

  1951. #elif defined(JACKBRIDGE_DIRECT)

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

  1953. #else

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

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

  1956. #endif

  1957.     return false;

  1958. }

  1959. 

  1960. bool jackbridge_get_all_properties(jack_description_t** descs)

  1961. {

  1962. #if defined(JACKBRIDGE_DUMMY)

  1963. #elif defined(JACKBRIDGE_DIRECT)

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

  1965. #else

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

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

  1968. #endif

  1969.     return false;

  1970. }

  1971. 

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

  1973. {

  1974. #if defined(JACKBRIDGE_DUMMY)

  1975. #elif defined(JACKBRIDGE_DIRECT)

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

  1977. #else

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

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

  1980. #endif

  1981.     return false;

  1982. }

  1983. 

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

  1985. {

  1986. #if defined(JACKBRIDGE_DUMMY)

  1987. #elif defined(JACKBRIDGE_DIRECT)

  1988.     return jack_remove_properties(client, subject);

  1989. #else

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

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

  1992. #endif

  1993.     return 0;

  1994. }

  1995. 

  1996. bool jackbridge_remove_all_properties(jack_client_t* client)

  1997. {

  1998. #if defined(JACKBRIDGE_DUMMY)

  1999. #elif defined(JACKBRIDGE_DIRECT)

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

  2001. #else

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

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

  2004. #endif

  2005.     return false;

  2006. }

  2007. 

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

  2009. {

  2010. #if defined(JACKBRIDGE_DUMMY)

  2011. #elif defined(JACKBRIDGE_DIRECT)

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

  2013. #else

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

  2015.     {

  2016. # ifdef __WINE__

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

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

  2019. # else

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

  2021. # endif

  2022.     }

  2023. #endif

  2024.     return false;

  2025. }

  2026. 

  2027. // -----------------------------------------------------------------------------