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.
4553 Commits
16 Branches
14GB
Tree: 570b8d5976
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '570b8d5976'
${ noResults }
Carla/source/jackbridge/JackBridge1.cpp

2017 lines
70KB
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 "CarlaLibUtils.hpp"

  33. 

  34. // -----------------------------------------------------------------------------

  35. 

  36. extern "C" {

  37. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  56. 

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

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

  59. 

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

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

  62. 

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

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

  65. 

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

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

  68. 

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

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

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

  72. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  87. 

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

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

  90. 

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

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

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

  94. 

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

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

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

  98. 

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

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

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

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

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

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

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

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

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

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

  109. 

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

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

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

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

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

  115. 

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

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

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

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

  120. 

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

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

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

  124. 

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

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

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

  128. 

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

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

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

  132. 

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

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

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

  136. 

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

  138. 

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

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

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

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

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

  144. 

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

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

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

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

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

  150. 

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

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

  153. 

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

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

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

  157. 

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

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

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

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

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

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

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

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

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

  167. 

  168. #ifdef __WINE__

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

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

  171. #endif

  172. 

  173. } // extern "C"

  174. 

  175. // -----------------------------------------------------------------------------

  176. 

  177. struct JackBridge {

  178.     lib_t lib;

  179. 

  180.     jacksym_get_version get_version_ptr;

  181.     jacksym_get_version_string get_version_string_ptr;

  182. 

  183.     jacksym_client_open client_open_ptr;

  184.     jacksym_client_close client_close_ptr;

  185. 

  186.     jacksym_client_name_size client_name_size_ptr;

  187.     jacksym_get_client_name get_client_name_ptr;

  188. 

  189.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  190.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  191. 

  192.     jacksym_activate activate_ptr;

  193.     jacksym_deactivate deactivate_ptr;

  194.     jacksym_is_realtime is_realtime_ptr;

  195. 

  196.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  197.     jacksym_on_shutdown on_shutdown_ptr;

  198.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  199.     jacksym_set_process_callback set_process_callback_ptr;

  200.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  201.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  202.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  203.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  204.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  205.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  206.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  207.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  208.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  209.     jacksym_set_latency_callback set_latency_callback_ptr;

  210. 

  211.     jacksym_set_freewheel set_freewheel_ptr;

  212.     jacksym_set_buffer_size set_buffer_size_ptr;

  213. 

  214.     jacksym_get_sample_rate get_sample_rate_ptr;

  215.     jacksym_get_buffer_size get_buffer_size_ptr;

  216.     jacksym_cpu_load cpu_load_ptr;

  217. 

  218.     jacksym_port_register port_register_ptr;

  219.     jacksym_port_unregister port_unregister_ptr;

  220.     jacksym_port_get_buffer port_get_buffer_ptr;

  221. 

  222.     jacksym_port_name port_name_ptr;

  223.     jacksym_port_uuid port_uuid_ptr;

  224.     jacksym_port_short_name port_short_name_ptr;

  225.     jacksym_port_flags port_flags_ptr;

  226.     jacksym_port_type port_type_ptr;

  227.     jacksym_port_is_mine port_is_mine_ptr;

  228.     jacksym_port_connected port_connected_ptr;

  229.     jacksym_port_connected_to port_connected_to_ptr;

  230.     jacksym_port_get_connections port_get_connections_ptr;

  231.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  232. 

  233.     jacksym_port_rename port_rename_ptr;

  234.     jacksym_port_set_name port_set_name_ptr;

  235.     jacksym_port_set_alias port_set_alias_ptr;

  236.     jacksym_port_unset_alias port_unset_alias_ptr;

  237.     jacksym_port_get_aliases port_get_aliases_ptr;

  238. 

  239.     jacksym_port_request_monitor port_request_monitor_ptr;

  240.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  241.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  242.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  243. 

  244.     jacksym_connect connect_ptr;

  245.     jacksym_disconnect disconnect_ptr;

  246.     jacksym_port_disconnect port_disconnect_ptr;

  247. 

  248.     jacksym_port_name_size port_name_size_ptr;

  249.     jacksym_port_type_size port_type_size_ptr;

  250.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  251. 

  252.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  253.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  254.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  255. 

  256.     jacksym_get_ports get_ports_ptr;

  257.     jacksym_port_by_name port_by_name_ptr;

  258.     jacksym_port_by_id port_by_id_ptr;

  259. 

  260.     jacksym_free free_ptr;

  261. 

  262.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  263.     jacksym_midi_event_get midi_event_get_ptr;

  264.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  265.     jacksym_midi_event_write midi_event_write_ptr;

  266.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  267. 

  268.     jacksym_release_timebase release_timebase_ptr;

  269.     jacksym_set_sync_callback set_sync_callback_ptr;

  270.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  271.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  272.     jacksym_transport_locate transport_locate_ptr;

  273. 

  274.     jacksym_transport_query transport_query_ptr;

  275.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  276. 

  277.     jacksym_transport_reposition transport_reposition_ptr;

  278.     jacksym_transport_start transport_start_ptr;

  279.     jacksym_transport_stop transport_stop_ptr;

  280. 

  281.     jacksym_set_property set_property_ptr;

  282.     jacksym_get_property get_property_ptr;

  283.     jacksym_free_description free_description_ptr;

  284.     jacksym_get_properties get_properties_ptr;

  285.     jacksym_get_all_properties get_all_properties_ptr;

  286.     jacksym_remove_property remove_property_ptr;

  287.     jacksym_remove_properties remove_properties_ptr;

  288.     jacksym_remove_all_properties remove_all_properties_ptr;

  289.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  290. 

  291. #ifdef __WINE__

  292.     jacksym_set_thread_creator set_thread_creator_ptr;

  293. #endif

  294. 

  295.     JackBridge()

  296.         : lib(nullptr),

  297.           get_version_ptr(nullptr),

  298.           get_version_string_ptr(nullptr),

  299.           client_open_ptr(nullptr),

  300.           client_close_ptr(nullptr),

  301.           client_name_size_ptr(nullptr),

  302.           get_client_name_ptr(nullptr),

  303.           get_uuid_for_client_name_ptr(nullptr),

  304.           get_client_name_by_uuid_ptr(nullptr),

  305.           activate_ptr(nullptr),

  306.           deactivate_ptr(nullptr),

  307.           is_realtime_ptr(nullptr),

  308.           set_thread_init_callback_ptr(nullptr),

  309.           on_shutdown_ptr(nullptr),

  310.           on_info_shutdown_ptr(nullptr),

  311.           set_process_callback_ptr(nullptr),

  312.           set_freewheel_callback_ptr(nullptr),

  313.           set_buffer_size_callback_ptr(nullptr),

  314.           set_sample_rate_callback_ptr(nullptr),

  315.           set_client_registration_callback_ptr(nullptr),

  316.           set_port_registration_callback_ptr(nullptr),

  317.           set_port_rename_callback_ptr(nullptr),

  318.           set_port_connect_callback_ptr(nullptr),

  319.           set_graph_order_callback_ptr(nullptr),

  320.           set_xrun_callback_ptr(nullptr),

  321.           set_latency_callback_ptr(nullptr),

  322.           set_freewheel_ptr(nullptr),

  323.           set_buffer_size_ptr(nullptr),

  324.           get_sample_rate_ptr(nullptr),

  325.           get_buffer_size_ptr(nullptr),

  326.           cpu_load_ptr(nullptr),

  327.           port_register_ptr(nullptr),

  328.           port_unregister_ptr(nullptr),

  329.           port_get_buffer_ptr(nullptr),

  330.           port_name_ptr(nullptr),

  331.           port_uuid_ptr(nullptr),

  332.           port_short_name_ptr(nullptr),

  333.           port_flags_ptr(nullptr),

  334.           port_type_ptr(nullptr),

  335.           port_is_mine_ptr(nullptr),

  336.           port_connected_ptr(nullptr),

  337.           port_connected_to_ptr(nullptr),

  338.           port_get_connections_ptr(nullptr),

  339.           port_get_all_connections_ptr(nullptr),

  340.           port_rename_ptr(nullptr),

  341.           port_set_name_ptr(nullptr),

  342.           port_set_alias_ptr(nullptr),

  343.           port_unset_alias_ptr(nullptr),

  344.           port_get_aliases_ptr(nullptr),

  345.           port_request_monitor_ptr(nullptr),

  346.           port_request_monitor_by_name_ptr(nullptr),

  347.           port_ensure_monitor_ptr(nullptr),

  348.           port_monitoring_input_ptr(nullptr),

  349.           connect_ptr(nullptr),

  350.           disconnect_ptr(nullptr),

  351.           port_disconnect_ptr(nullptr),

  352.           port_name_size_ptr(nullptr),

  353.           port_type_size_ptr(nullptr),

  354.           port_type_get_buffer_size_ptr(nullptr),

  355.           port_get_latency_range_ptr(nullptr),

  356.           port_set_latency_range_ptr(nullptr),

  357.           recompute_total_latencies_ptr(nullptr),

  358.           get_ports_ptr(nullptr),

  359.           port_by_name_ptr(nullptr),

  360.           port_by_id_ptr(nullptr),

  361.           free_ptr(nullptr),

  362.           midi_get_event_count_ptr(nullptr),

  363.           midi_event_get_ptr(nullptr),

  364.           midi_clear_buffer_ptr(nullptr),

  365.           midi_event_write_ptr(nullptr),

  366.           midi_event_reserve_ptr(nullptr),

  367.           release_timebase_ptr(nullptr),

  368.           set_sync_callback_ptr(nullptr),

  369.           set_sync_timeout_ptr(nullptr),

  370.           set_timebase_callback_ptr(nullptr),

  371.           transport_locate_ptr(nullptr),

  372.           transport_query_ptr(nullptr),

  373.           get_current_transport_frame_ptr(nullptr),

  374.           transport_reposition_ptr(nullptr),

  375.           transport_start_ptr(nullptr),

  376.           transport_stop_ptr(nullptr),

  377.           set_property_ptr(nullptr),

  378.           get_property_ptr(nullptr),

  379.           free_description_ptr(nullptr),

  380.           get_properties_ptr(nullptr),

  381.           get_all_properties_ptr(nullptr),

  382.           remove_property_ptr(nullptr),

  383.           remove_properties_ptr(nullptr),

  384.           remove_all_properties_ptr(nullptr),

  385.           set_property_change_callback_ptr(nullptr)

  386. #ifdef __WINE__

  387.         , set_thread_creator_ptr(nullptr)

  388. #endif

  389.     {

  390. # if defined(CARLA_OS_MAC)

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

  392. # elif defined(CARLA_OS_WIN64)

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

  394. # elif defined(CARLA_OS_WIN)

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

  396. # else

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

  398. # endif

  399. 

  400.         lib = lib_open(filename);

  401. 

  402.         if (lib == nullptr)

  403.         {

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

  405.             return;

  406.         }

  407.         else

  408.         {

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

  410.         }

  411. 

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

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

  414. 

  415.         LIB_SYMBOL(get_version)

  416.         LIB_SYMBOL(get_version_string)

  417. 

  418.         LIB_SYMBOL(client_open)

  419.         LIB_SYMBOL(client_close)

  420. 

  421.         LIB_SYMBOL(client_name_size)

  422.         LIB_SYMBOL(get_client_name)

  423. 

  424.         LIB_SYMBOL(get_uuid_for_client_name)

  425.         LIB_SYMBOL(get_client_name_by_uuid)

  426. 

  427.         LIB_SYMBOL(activate)

  428.         LIB_SYMBOL(deactivate)

  429.         LIB_SYMBOL(is_realtime)

  430. 

  431.         LIB_SYMBOL(set_thread_init_callback)

  432.         LIB_SYMBOL(on_shutdown)

  433.         LIB_SYMBOL(on_info_shutdown)

  434.         LIB_SYMBOL(set_process_callback)

  435.         LIB_SYMBOL(set_freewheel_callback)

  436.         LIB_SYMBOL(set_buffer_size_callback)

  437.         LIB_SYMBOL(set_sample_rate_callback)

  438.         LIB_SYMBOL(set_client_registration_callback)

  439.         LIB_SYMBOL(set_port_registration_callback)

  440.         LIB_SYMBOL(set_port_rename_callback)

  441.         LIB_SYMBOL(set_port_connect_callback)

  442.         LIB_SYMBOL(set_graph_order_callback)

  443.         LIB_SYMBOL(set_xrun_callback)

  444.         LIB_SYMBOL(set_latency_callback)

  445. 

  446.         LIB_SYMBOL(set_freewheel)

  447.         LIB_SYMBOL(set_buffer_size)

  448. 

  449.         LIB_SYMBOL(get_sample_rate)

  450.         LIB_SYMBOL(get_buffer_size)

  451.         LIB_SYMBOL(cpu_load)

  452. 

  453.         LIB_SYMBOL(port_register)

  454.         LIB_SYMBOL(port_unregister)

  455.         LIB_SYMBOL(port_get_buffer)

  456. 

  457.         LIB_SYMBOL(port_name)

  458.         LIB_SYMBOL(port_uuid)

  459.         LIB_SYMBOL(port_short_name)

  460.         LIB_SYMBOL(port_flags)

  461.         LIB_SYMBOL(port_type)

  462.         LIB_SYMBOL(port_is_mine)

  463.         LIB_SYMBOL(port_connected)

  464.         LIB_SYMBOL(port_connected_to)

  465.         LIB_SYMBOL(port_get_connections)

  466.         LIB_SYMBOL(port_get_all_connections)

  467. 

  468.         LIB_SYMBOL(port_rename)

  469.         LIB_SYMBOL(port_set_name)

  470.         LIB_SYMBOL(port_set_alias)

  471.         LIB_SYMBOL(port_unset_alias)

  472.         LIB_SYMBOL(port_get_aliases)

  473. 

  474.         LIB_SYMBOL(port_request_monitor)

  475.         LIB_SYMBOL(port_request_monitor_by_name)

  476.         LIB_SYMBOL(port_ensure_monitor)

  477.         LIB_SYMBOL(port_monitoring_input)

  478. 

  479.         LIB_SYMBOL(connect)

  480.         LIB_SYMBOL(disconnect)

  481.         LIB_SYMBOL(port_disconnect)

  482. 

  483.         LIB_SYMBOL(port_name_size)

  484.         LIB_SYMBOL(port_type_size)

  485.         LIB_SYMBOL(port_type_get_buffer_size)

  486. 

  487.         LIB_SYMBOL(port_get_latency_range)

  488.         LIB_SYMBOL(port_set_latency_range)

  489.         LIB_SYMBOL(recompute_total_latencies)

  490. 

  491.         LIB_SYMBOL(get_ports)

  492.         LIB_SYMBOL(port_by_name)

  493.         LIB_SYMBOL(port_by_id)

  494. 

  495.         LIB_SYMBOL(free)

  496. 

  497.         LIB_SYMBOL(midi_get_event_count)

  498.         LIB_SYMBOL(midi_event_get)

  499.         LIB_SYMBOL(midi_clear_buffer)

  500.         LIB_SYMBOL(midi_event_write)

  501.         LIB_SYMBOL(midi_event_reserve)

  502. 

  503.         LIB_SYMBOL(release_timebase)

  504.         LIB_SYMBOL(set_sync_callback)

  505.         LIB_SYMBOL(set_sync_timeout)

  506.         LIB_SYMBOL(set_timebase_callback)

  507.         LIB_SYMBOL(transport_locate)

  508.         LIB_SYMBOL(transport_query)

  509.         LIB_SYMBOL(get_current_transport_frame)

  510.         LIB_SYMBOL(transport_reposition)

  511.         LIB_SYMBOL(transport_start)

  512.         LIB_SYMBOL(transport_stop)

  513. 

  514.         LIB_SYMBOL(set_property)

  515.         LIB_SYMBOL(get_property)

  516.         LIB_SYMBOL(free_description)

  517.         LIB_SYMBOL(get_properties)

  518.         LIB_SYMBOL(get_all_properties)

  519.         LIB_SYMBOL(remove_property)

  520.         LIB_SYMBOL(remove_properties)

  521.         LIB_SYMBOL(remove_all_properties)

  522.         LIB_SYMBOL(set_property_change_callback)

  523. 

  524. #ifdef __WINE__

  525.         LIB_SYMBOL(set_thread_creator)

  526. #endif

  527. 

  528.         #undef JOIN

  529.         #undef LIB_SYMBOL

  530.     }

  531. 

  532.     ~JackBridge() noexcept

  533.     {

  534.         if (lib != nullptr)

  535.         {

  536.             lib_close(lib);

  537.             lib = nullptr;

  538.         }

  539.     }

  540. 

  541.     CARLA_DECLARE_NON_COPY_STRUCT(JackBridge);

  542. };

  543. 

  544. // -----------------------------------------------------------------------------

  545. 

  546. static const JackBridge& getBridgeInstance() noexcept

  547. {

  548.     static const JackBridge bridge;

  549.     return bridge;

  550. }

  551. 

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

  553. 

  554. // -----------------------------------------------------------------------------

  555. 

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

  557. 

  558. struct WineBridge {

  559.     void* ptr;

  560.     JackLatencyCallback latency_cb;

  561.     JackProcessCallback process_cb;

  562.     JackThreadInitCallback thread_init_cb;

  563.     JackGraphOrderCallback graph_order_cb;

  564.     JackXRunCallback xrun_cb;

  565.     JackBufferSizeCallback bufsize_cb;

  566.     JackSampleRateCallback srate_cb;

  567.     JackPortRegistrationCallback port_reg_cb;

  568.     JackClientRegistrationCallback client_reg_cb;

  569.     JackPortConnectCallback port_conn_cb;

  570.     JackPortRenameCallback port_rename_cb;

  571.     JackFreewheelCallback freewheel_cb;

  572.     JackShutdownCallback shutdown_cb;

  573.     JackInfoShutdownCallback info_shutdown_cb;

  574.     JackSyncCallback sync_cb;

  575.     JackTimebaseCallback timebase_cb;

  576.     JackSessionCallback session_cb;

  577.     JackPropertyChangeCallback prop_change_cb;

  578. 

  579.     void* (*creator_func)(void*);

  580.     void* creator_arg;

  581.     HANDLE creator_handle;

  582.     pthread_t creator_pthread;

  583. 

  584.     WineBridge() noexcept

  585.         : ptr(nullptr),

  586.           latency_cb(nullptr),

  587.           process_cb(nullptr),

  588.           thread_init_cb(nullptr),

  589.           graph_order_cb(nullptr),

  590.           xrun_cb(nullptr),

  591.           bufsize_cb(nullptr),

  592.           srate_cb(nullptr),

  593.           port_reg_cb(nullptr),

  594.           client_reg_cb(nullptr),

  595.           port_conn_cb(nullptr),

  596.           port_rename_cb(nullptr),

  597.           freewheel_cb(nullptr),

  598.           shutdown_cb(nullptr),

  599.           info_shutdown_cb(nullptr),

  600.           sync_cb(nullptr),

  601.           timebase_cb(nullptr),

  602.           session_cb(nullptr),

  603.           prop_change_cb(nullptr),

  604.           creator_func(nullptr),

  605.           creator_arg(nullptr),

  606.           creator_handle(nullptr),

  607.           creator_pthread(0) {}

  608. 

  609.     static WineBridge& getInstance() noexcept

  610.     {

  611.         static WineBridge bridge;

  612.         return bridge;

  613.     }

  614. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  633. 

  634.     static DWORD WINAPI thread_creator_helper(LPVOID)

  635.     {

  636.         WineBridge& inst(getInstance());

  637. 

  638.         inst.creator_pthread = pthread_self();

  639.         SetEvent(inst.creator_handle);

  640.         inst.creator_func(inst.creator_arg);

  641.         return 0;

  642.     }

  643. 

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

  645.     {

  646.         WineBridge& inst(getInstance());

  647. 

  648.         inst.creator_func   = function;

  649.         inst.creator_arg    = arg;

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

  651. 

  652. #if 0

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

  654. #else

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

  656. 

  657.         if (handle == INVALID_HANDLE_VALUE)

  658.             return 1;

  659. 

  660.         // TODO read attrs and decide this

  661.         ::SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);

  662.         ::ResumeThread(handle);

  663. #endif

  664. 

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

  666.         *thread_id = inst.creator_pthread;

  667.         return 0;

  668.     }

  669. 

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

  671.     {

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

  673.     }

  674. 

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

  676.     {

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

  678.     }

  679. 

  680.     static void thread_init(void* arg)

  681.     {

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

  683.     }

  684. 

  685.     static int graph_order(void* arg)

  686.     {

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

  688.     }

  689. 

  690.     static int xrun(void* arg)

  691.     {

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

  693.     }

  694. 

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

  696.     {

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

  698.     }

  699. 

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

  701.     {

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

  703.     }

  704. 

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

  706.     {

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

  708.     }

  709. 

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

  711.     {

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

  713.     }

  714. 

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

  716.     {

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

  718.     }

  719. 

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

  721.     {

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

  723.     }

  724. 

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

  726.     {

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

  728.     }

  729. 

  730.     static void shutdown(void* arg)

  731.     {

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

  733.     }

  734. 

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

  736.     {

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

  738.     }

  739. 

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

  741.     {

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

  743.     }

  744. 

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

  746.     {

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

  748.     }

  749. 

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

  751.     {

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

  753.     }

  754. 

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

  756.     {

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

  758.     }

  759. 

  760.     CARLA_DECLARE_NON_COPY_STRUCT(WineBridge);

  761. };

  762. 

  763. #endif // __WINE__ && ! JACKBRIDGE_DIRECT

  764. 

  765. // -----------------------------------------------------------------------------

  766. 

  767. bool jackbridge_is_ok() noexcept

  768. {

  769. #if defined(JACKBRIDGE_DUMMY)

  770.     return false;

  771. #elif defined(JACKBRIDGE_DIRECT)

  772.     return true;

  773. #else

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

  775. #endif

  776. }

  777. 

  778. void jackbridge_init()

  779. {

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

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

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

  783. #endif

  784. }

  785. 

  786. // -----------------------------------------------------------------------------

  787. 

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

  789. {

  790. #if defined(JACKBRIDGE_DUMMY)

  791. #elif defined(JACKBRIDGE_DIRECT)

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

  793. #else

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

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

  796. #endif

  797.     if (major_ptr != nullptr)

  798.         *major_ptr = 0;

  799.     if (minor_ptr != nullptr)

  800.         *minor_ptr = 0;

  801.     if (micro_ptr != nullptr)

  802.         *micro_ptr = 0;

  803.     if (proto_ptr != nullptr)

  804.         *proto_ptr = 0;

  805. }

  806. 

  807. const char* jackbridge_get_version_string()

  808. {

  809. #if defined(JACKBRIDGE_DUMMY)

  810. #elif defined(JACKBRIDGE_DIRECT)

  811.     return jack_get_version_string();

  812. #else

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

  814.         return getBridgeInstance().get_version_string_ptr();

  815. #endif

  816.     return nullptr;

  817. }

  818. 

  819. // -----------------------------------------------------------------------------

  820. 

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

  822. {

  823. #if defined(JACKBRIDGE_DUMMY)

  824. #elif defined(JACKBRIDGE_DIRECT)

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

  826. #else

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

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

  829. #endif

  830.     if (status != nullptr)

  831.         *status = JackServerError;

  832.     return nullptr;

  833. }

  834. 

  835. bool jackbridge_client_close(jack_client_t* client)

  836. {

  837. #if defined(JACKBRIDGE_DUMMY)

  838. #elif defined(JACKBRIDGE_DIRECT)

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

  840. #else

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

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

  843. #endif

  844.     return false;

  845. }

  846. 

  847. // -----------------------------------------------------------------------------

  848. 

  849. int jackbridge_client_name_size()

  850. {

  851. #if defined(JACKBRIDGE_DUMMY)

  852. #elif defined(JACKBRIDGE_DIRECT)

  853.     return jack_client_name_size();

  854. #else

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

  856.         return getBridgeInstance().client_name_size_ptr();

  857. #endif

  858.     return 33;

  859. }

  860. 

  861. char* jackbridge_get_client_name(jack_client_t* client)

  862. {

  863. #if defined(JACKBRIDGE_DUMMY)

  864. #elif defined(JACKBRIDGE_DIRECT)

  865.     return jack_get_client_name(client);

  866. #else

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

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

  869. #endif

  870.     return nullptr;

  871. }

  872. 

  873. // -----------------------------------------------------------------------------

  874. 

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

  876. {

  877. #if defined(JACKBRIDGE_DUMMY)

  878. #elif defined(JACKBRIDGE_DIRECT)

  879.     return jack_get_uuid_for_client_name(client, name);

  880. #else

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

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

  883. #endif

  884.     return nullptr;

  885. }

  886. 

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

  888. {

  889. #if defined(JACKBRIDGE_DUMMY)

  890. #elif defined(JACKBRIDGE_DIRECT)

  891.     return jack_get_client_name_by_uuid(client, uuid);

  892. #else

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

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

  895. #endif

  896.     return nullptr;

  897. }

  898. 

  899. // -----------------------------------------------------------------------------

  900. 

  901. bool jackbridge_activate(jack_client_t* client)

  902. {

  903. #if defined(JACKBRIDGE_DUMMY)

  904. #elif defined(JACKBRIDGE_DIRECT)

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

  906. #else

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

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

  909. #endif

  910.     return false;

  911. }

  912. 

  913. bool jackbridge_deactivate(jack_client_t* client)

  914. {

  915. #if defined(JACKBRIDGE_DUMMY)

  916. #elif defined(JACKBRIDGE_DIRECT)

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

  918. #else

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

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

  921. #endif

  922.     return false;

  923. }

  924. 

  925. bool jackbridge_is_realtime(jack_client_t* client)

  926. {

  927. #if defined(JACKBRIDGE_DUMMY)

  928. #elif defined(JACKBRIDGE_DIRECT)

  929.     return jack_is_realtime(client);

  930. #else

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

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

  933. #endif

  934.     return false;

  935. }

  936. 

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

  938. 

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

  940. {

  941. #if defined(JACKBRIDGE_DUMMY)

  942. #elif defined(JACKBRIDGE_DIRECT)

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

  944. #else

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

  946.     {

  947. # ifdef __WINE__

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

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

  950. # else

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

  952. # endif

  953.     }

  954. #endif

  955.     return false;

  956. }

  957. 

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

  959. {

  960. #if defined(JACKBRIDGE_DUMMY)

  961. #elif defined(JACKBRIDGE_DIRECT)

  962.     jack_on_shutdown(client, shutdown_callback, arg);

  963. #else

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

  965.     {

  966. # ifdef __WINE__

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

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

  969. # else

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

  971. # endif

  972.     }

  973. #endif

  974. }

  975. 

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

  977. {

  978. #if defined(JACKBRIDGE_DUMMY)

  979. #elif defined(JACKBRIDGE_DIRECT)

  980.     jack_on_info_shutdown(client, shutdown_callback, arg);

  981. #else

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

  983.     {

  984. # ifdef __WINE__

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

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

  987. # else

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

  989. # endif

  990.     }

  991. #endif

  992. }

  993. 

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

  995. {

  996. #if defined(JACKBRIDGE_DUMMY)

  997. #elif defined(JACKBRIDGE_DIRECT)

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

  999. #else

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

  1001.     {

  1002. # ifdef __WINE__

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

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

  1005. # else

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

  1007. # endif

  1008.     }

  1009. #endif

  1010.     return false;

  1011. }

  1012. 

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

  1014. {

  1015. #if defined(JACKBRIDGE_DUMMY)

  1016. #elif defined(JACKBRIDGE_DIRECT)

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

  1018. #else

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

  1020.     {

  1021. # ifdef __WINE__

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

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

  1024. # else

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

  1026. # endif

  1027.     }

  1028. #endif

  1029.     return false;

  1030. }

  1031. 

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

  1033. {

  1034. #if defined(JACKBRIDGE_DUMMY)

  1035. #elif defined(JACKBRIDGE_DIRECT)

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

  1037. #else

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

  1039.     {

  1040. # ifdef __WINE__

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

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

  1043. # else

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

  1045. # endif

  1046.     }

  1047. #endif

  1048.     return false;

  1049. }

  1050. 

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

  1052. {

  1053. #if defined(JACKBRIDGE_DUMMY)

  1054. #elif defined(JACKBRIDGE_DIRECT)

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

  1056. #else

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

  1058.     {

  1059. # ifdef __WINE__

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

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

  1062. # else

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

  1064. # endif

  1065.     }

  1066. #endif

  1067.     return false;

  1068. }

  1069. 

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

  1071. {

  1072. #if defined(JACKBRIDGE_DUMMY)

  1073. #elif defined(JACKBRIDGE_DIRECT)

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

  1075. #else

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

  1077.     {

  1078. # ifdef __WINE__

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

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

  1081. # else

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

  1083. # endif

  1084.     }

  1085. #endif

  1086.     return false;

  1087. }

  1088. 

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

  1090. {

  1091. #if defined(JACKBRIDGE_DUMMY)

  1092. #elif defined(JACKBRIDGE_DIRECT)

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

  1094. #else

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

  1096.     {

  1097. # ifdef __WINE__

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

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

  1100. # else

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

  1102. # endif

  1103.     }

  1104. #endif

  1105.     return false;

  1106. }

  1107. 

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

  1109. {

  1110. #if defined(JACKBRIDGE_DUMMY)

  1111. #elif defined(JACKBRIDGE_DIRECT)

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

  1113. #else

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

  1115.     {

  1116. # ifdef __WINE__

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

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

  1119. # else

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

  1121. # endif

  1122.     }

  1123. #endif

  1124.     return false;

  1125. }

  1126. 

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

  1128. {

  1129. #if defined(JACKBRIDGE_DUMMY)

  1130. #elif defined(JACKBRIDGE_DIRECT)

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

  1132. #else

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

  1134.     {

  1135. # ifdef __WINE__

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

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

  1138. # else

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

  1140. # endif

  1141.     }

  1142. #endif

  1143.     return false;

  1144. }

  1145. 

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

  1147. {

  1148. #if defined(JACKBRIDGE_DUMMY)

  1149. #elif defined(JACKBRIDGE_DIRECT)

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

  1151. #else

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

  1153.     {

  1154. # ifdef __WINE__

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

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

  1157. # else

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

  1159. # endif

  1160.     }

  1161. #endif

  1162.     return false;

  1163. }

  1164. 

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

  1166. {

  1167. #if defined(JACKBRIDGE_DUMMY)

  1168. #elif defined(JACKBRIDGE_DIRECT)

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

  1170. #else

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

  1172.     {

  1173. # ifdef __WINE__

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

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

  1176. # else

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

  1178. # endif

  1179.     }

  1180. #endif

  1181.     return false;

  1182. }

  1183. 

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

  1185. {

  1186. #if defined(JACKBRIDGE_DUMMY)

  1187. #elif defined(JACKBRIDGE_DIRECT)

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

  1189. #else

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

  1191.     {

  1192. # ifdef __WINE__

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

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

  1195. # else

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

  1197. # endif

  1198.     }

  1199. #endif

  1200.     return false;

  1201. }

  1202. 

  1203. // -----------------------------------------------------------------------------

  1204. 

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

  1206. {

  1207. #if defined(JACKBRIDGE_DUMMY)

  1208. #elif defined(JACKBRIDGE_DIRECT)

  1209.     return jack_set_freewheel(client, onoff);

  1210. #else

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

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

  1213. #endif

  1214.     return false;

  1215. }

  1216. 

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

  1218. {

  1219. #if defined(JACKBRIDGE_DUMMY)

  1220. #elif defined(JACKBRIDGE_DIRECT)

  1221.     return jack_set_buffer_size(client, nframes);

  1222. #else

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

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

  1225. #endif

  1226.     return false;

  1227. }

  1228. 

  1229. // -----------------------------------------------------------------------------

  1230. 

  1231. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1232. {

  1233. #if defined(JACKBRIDGE_DUMMY)

  1234. #elif defined(JACKBRIDGE_DIRECT)

  1235.     return jack_get_sample_rate(client);

  1236. #else

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

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

  1239. #endif

  1240.     return 0;

  1241. }

  1242. 

  1243. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1244. {

  1245. #if defined(JACKBRIDGE_DUMMY)

  1246. #elif defined(JACKBRIDGE_DIRECT)

  1247.     return jack_get_buffer_size(client);

  1248. #else

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

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

  1251. #endif

  1252.     return 0;

  1253. }

  1254. 

  1255. float jackbridge_cpu_load(jack_client_t* client)

  1256. {

  1257. #if defined(JACKBRIDGE_DUMMY)

  1258. #elif defined(JACKBRIDGE_DIRECT)

  1259.     return jack_cpu_load(client);

  1260. #else

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

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

  1263. #endif

  1264.     return 0.0f;

  1265. }

  1266. 

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

  1268. 

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

  1270. {

  1271. #if defined(JACKBRIDGE_DUMMY)

  1272. #elif defined(JACKBRIDGE_DIRECT)

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

  1274. #else

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

  1276.         return getBridgeInstance().port_register_ptr(client, port_name, port_type, flags, buffer_size);

  1277. #endif

  1278.     return nullptr;

  1279. }

  1280. 

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

  1282. {

  1283. #if defined(JACKBRIDGE_DUMMY)

  1284. #elif defined(JACKBRIDGE_DIRECT)

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

  1286. #else

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

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

  1289. #endif

  1290.     return false;

  1291. }

  1292. 

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

  1294. {

  1295. #if defined(JACKBRIDGE_DUMMY)

  1296. #elif defined(JACKBRIDGE_DIRECT)

  1297.     return jack_port_get_buffer(port, nframes);

  1298. #else

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

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

  1301. #endif

  1302.     return nullptr;

  1303. }

  1304. 

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

  1306. 

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

  1308. {

  1309. #if defined(JACKBRIDGE_DUMMY)

  1310. #elif defined(JACKBRIDGE_DIRECT)

  1311.     return jack_port_name(port);

  1312. #else

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

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

  1315. #endif

  1316.     return nullptr;

  1317. }

  1318. 

  1319. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1320. {

  1321. #if defined(JACKBRIDGE_DUMMY)

  1322. #elif defined(JACKBRIDGE_DIRECT)

  1323.     return jack_port_uuid(port);

  1324. #else

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

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

  1327. #endif

  1328.     return 0;

  1329. }

  1330. 

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

  1332. {

  1333. #if defined(JACKBRIDGE_DUMMY)

  1334. #elif defined(JACKBRIDGE_DIRECT)

  1335.     return jack_port_short_name(port);

  1336. #else

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

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

  1339. #endif

  1340.     return nullptr;

  1341. }

  1342. 

  1343. int jackbridge_port_flags(const jack_port_t* port)

  1344. {

  1345. #if defined(JACKBRIDGE_DUMMY)

  1346. #elif defined(JACKBRIDGE_DIRECT)

  1347.     return jack_port_flags(port);

  1348. #else

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

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

  1351. #endif

  1352.     return 0x0;

  1353. }

  1354. 

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

  1356. {

  1357. #if defined(JACKBRIDGE_DUMMY)

  1358. #elif defined(JACKBRIDGE_DIRECT)

  1359.     return jack_port_type(port);

  1360. #else

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

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

  1363. #endif

  1364.     return nullptr;

  1365. }

  1366. 

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

  1368. {

  1369. #if defined(JACKBRIDGE_DUMMY)

  1370. #elif defined(JACKBRIDGE_DIRECT)

  1371.     return jack_port_is_mine(client, port);

  1372. #else

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

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

  1375. #endif

  1376.     return false;

  1377. }

  1378. 

  1379. int jackbridge_port_connected(const jack_port_t* port)

  1380. {

  1381. #if defined(JACKBRIDGE_DUMMY)

  1382. #elif defined(JACKBRIDGE_DIRECT)

  1383.     return jack_port_connected(port);

  1384. #else

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

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

  1387. #endif

  1388.     return 0;

  1389. }

  1390. 

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

  1392. {

  1393. #if defined(JACKBRIDGE_DUMMY)

  1394. #elif defined(JACKBRIDGE_DIRECT)

  1395.     return jack_port_connected_to(port, port_name);

  1396. #else

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

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

  1399. #endif

  1400.     return false;

  1401. }

  1402. 

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

  1404. {

  1405. #if defined(JACKBRIDGE_DUMMY)

  1406. #elif defined(JACKBRIDGE_DIRECT)

  1407.     return jack_port_get_connections(port);

  1408. #else

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

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

  1411. #endif

  1412.     return nullptr;

  1413. }

  1414. 

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

  1416. {

  1417. #if defined(JACKBRIDGE_DUMMY)

  1418. #elif defined(JACKBRIDGE_DIRECT)

  1419.     return jack_port_get_all_connections(client, port);

  1420. #else

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

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

  1423. #endif

  1424.     return nullptr;

  1425. }

  1426. 

  1427. // -----------------------------------------------------------------------------

  1428. 

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

  1430. {

  1431. #if defined(JACKBRIDGE_DUMMY)

  1432. #elif defined(JACKBRIDGE_DIRECT)

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

  1434. #else

  1435.     // Try new API first

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

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

  1438.     // Try old API if using JACK2

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

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

  1441. #endif

  1442.     return false;

  1443. }

  1444. 

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

  1446. {

  1447. #if defined(JACKBRIDGE_DUMMY)

  1448. #elif defined(JACKBRIDGE_DIRECT)

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

  1450. #else

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

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

  1453. #endif

  1454.     return false;

  1455. }

  1456. 

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

  1458. {

  1459. #if defined(JACKBRIDGE_DUMMY)

  1460. #elif defined(JACKBRIDGE_DIRECT)

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

  1462. #else

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

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

  1465. #endif

  1466.     return false;

  1467. }

  1468. 

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

  1470. {

  1471. #if defined(JACKBRIDGE_DUMMY)

  1472. #elif defined(JACKBRIDGE_DIRECT)

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

  1474. #else

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

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

  1477. #endif

  1478.     return 0;

  1479. }

  1480. 

  1481. // -----------------------------------------------------------------------------

  1482. 

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

  1484. {

  1485. #if defined(JACKBRIDGE_DUMMY)

  1486. #elif defined(JACKBRIDGE_DIRECT)

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

  1488. #else

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

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

  1491. #endif

  1492.     return false;

  1493. }

  1494. 

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

  1496. {

  1497. #if defined(JACKBRIDGE_DUMMY)

  1498. #elif defined(JACKBRIDGE_DIRECT)

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

  1500. #else

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

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

  1503. #endif

  1504.     return false;

  1505. }

  1506. 

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

  1508. {

  1509. #if defined(JACKBRIDGE_DUMMY)

  1510. #elif defined(JACKBRIDGE_DIRECT)

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

  1512. #else

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

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

  1515. #endif

  1516.     return false;

  1517. }

  1518. 

  1519. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1520. {

  1521. #if defined(JACKBRIDGE_DUMMY)

  1522. #elif defined(JACKBRIDGE_DIRECT)

  1523.     return jack_port_monitoring_input(port);

  1524. #else

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

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

  1527. #endif

  1528.     return false;

  1529. }

  1530. 

  1531. // -----------------------------------------------------------------------------

  1532. 

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

  1534. {

  1535. #if defined(JACKBRIDGE_DUMMY)

  1536. #elif defined(JACKBRIDGE_DIRECT)

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

  1538. #else

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

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

  1541. #endif

  1542.     return false;

  1543. }

  1544. 

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

  1546. {

  1547. #if defined(JACKBRIDGE_DUMMY)

  1548. #elif defined(JACKBRIDGE_DIRECT)

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

  1550. #else

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

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

  1553. #endif

  1554.     return false;

  1555. }

  1556. 

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

  1558. {

  1559. #if defined(JACKBRIDGE_DUMMY)

  1560. #elif defined(JACKBRIDGE_DIRECT)

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

  1562. #else

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

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

  1565. #endif

  1566.     return false;

  1567. }

  1568. 

  1569. // -----------------------------------------------------------------------------

  1570. 

  1571. int jackbridge_port_name_size()

  1572. {

  1573. #if defined(JACKBRIDGE_DUMMY)

  1574. #elif defined(JACKBRIDGE_DIRECT)

  1575.     return jack_port_name_size();

  1576. #else

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

  1578.         return getBridgeInstance().port_name_size_ptr();

  1579. #endif

  1580.     return 256;

  1581. }

  1582. 

  1583. int jackbridge_port_type_size()

  1584. {

  1585. #if defined(JACKBRIDGE_DUMMY)

  1586. #elif defined(JACKBRIDGE_DIRECT)

  1587.     return jack_port_type_size();

  1588. #else

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

  1590.         return getBridgeInstance().port_type_size_ptr();

  1591. #endif

  1592.     return 32;

  1593. }

  1594. 

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

  1596. {

  1597. #if defined(JACKBRIDGE_DUMMY)

  1598. #elif defined(JACKBRIDGE_DIRECT)

  1599.     return jack_port_type_get_buffer_size(client, port_type);

  1600. #else

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

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

  1603. #endif

  1604.     return 0;

  1605. }

  1606. 

  1607. // -----------------------------------------------------------------------------

  1608. 

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

  1610. {

  1611. #if defined(JACKBRIDGE_DUMMY)

  1612. #elif defined(JACKBRIDGE_DIRECT)

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

  1614. #else

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

  1616.         return getBridgeInstance().port_get_latency_range_ptr(port, static_cast<jack_latency_callback_mode_t>(mode), range);

  1617. #endif

  1618.     range->min = 0;

  1619.     range->max = 0;

  1620. }

  1621. 

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

  1623. {

  1624. #if defined(JACKBRIDGE_DUMMY)

  1625. #elif defined(JACKBRIDGE_DIRECT)

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

  1627. #else

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

  1629.         getBridgeInstance().port_set_latency_range_ptr(port, static_cast<jack_latency_callback_mode_t>(mode), range);

  1630. #endif

  1631. }

  1632. 

  1633. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1634. {

  1635. #if defined(JACKBRIDGE_DUMMY)

  1636. #elif defined(JACKBRIDGE_DIRECT)

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

  1638. #else

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

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

  1641. #endif

  1642.     return false;

  1643. }

  1644. 

  1645. // -----------------------------------------------------------------------------

  1646. 

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

  1648. {

  1649. #if defined(JACKBRIDGE_DUMMY)

  1650. #elif defined(JACKBRIDGE_DIRECT)

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

  1652. #else

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

  1654.         return getBridgeInstance().get_ports_ptr(client, port_name_pattern, type_name_pattern, flags);

  1655. #endif

  1656.     return nullptr;

  1657. }

  1658. 

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

  1660. {

  1661. #if defined(JACKBRIDGE_DUMMY)

  1662. #elif defined(JACKBRIDGE_DIRECT)

  1663.     return jack_port_by_name(client, port_name);

  1664. #else

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

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

  1667. #endif

  1668.     return nullptr;

  1669. }

  1670. 

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

  1672. {

  1673. #if defined(JACKBRIDGE_DUMMY)

  1674. #elif defined(JACKBRIDGE_DIRECT)

  1675.     return jack_port_by_id(client, port_id);

  1676. #else

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

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

  1679. #endif

  1680.     return nullptr;

  1681. }

  1682. 

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

  1684. 

  1685. void jackbridge_free(void* ptr)

  1686. {

  1687. #if defined(JACKBRIDGE_DUMMY)

  1688. #elif defined(JACKBRIDGE_DIRECT)

  1689.     return jack_free(ptr);

  1690. #else

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

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

  1693. 

  1694.     // just in case

  1695.     std::free(ptr);

  1696. #endif

  1697. }

  1698. 

  1699. // -----------------------------------------------------------------------------

  1700. 

  1701. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1702. {

  1703. #if defined(JACKBRIDGE_DUMMY)

  1704. #elif defined(JACKBRIDGE_DIRECT)

  1705.     return jack_midi_get_event_count(port_buffer);

  1706. #else

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

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

  1709. #endif

  1710.     return 0;

  1711. }

  1712. 

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

  1714. {

  1715. #if defined(JACKBRIDGE_DUMMY)

  1716. #elif defined(JACKBRIDGE_DIRECT)

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

  1718. #else

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

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

  1721. #endif

  1722.     return false;

  1723. }

  1724. 

  1725. void jackbridge_midi_clear_buffer(void* port_buffer)

  1726. {

  1727. #if defined(JACKBRIDGE_DUMMY)

  1728. #elif defined(JACKBRIDGE_DIRECT)

  1729.     jack_midi_clear_buffer(port_buffer);

  1730. #else

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

  1732.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  1733. #endif

  1734. }

  1735. 

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

  1737. {

  1738. #if defined(JACKBRIDGE_DUMMY)

  1739. #elif defined(JACKBRIDGE_DIRECT)

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

  1741. #else

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

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

  1744. #endif

  1745.     return false;

  1746. }

  1747. 

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

  1749. {

  1750. #if defined(JACKBRIDGE_DUMMY)

  1751. #elif defined(JACKBRIDGE_DIRECT)

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

  1753. #else

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

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

  1756. #endif

  1757.     return nullptr;

  1758. }

  1759. 

  1760. // -----------------------------------------------------------------------------

  1761. 

  1762. bool jackbridge_release_timebase(jack_client_t* client)

  1763. {

  1764. #if defined(JACKBRIDGE_DUMMY)

  1765. #elif defined(JACKBRIDGE_DIRECT)

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

  1767. #else

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

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

  1770. #endif

  1771.     return false;

  1772. }

  1773. 

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

  1775. {

  1776. #if defined(JACKBRIDGE_DUMMY)

  1777. #elif defined(JACKBRIDGE_DIRECT)

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

  1779. #else

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

  1781.     {

  1782. # ifdef __WINE__

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

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

  1785. # else

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

  1787. # endif

  1788.     }

  1789. #endif

  1790.     return false;

  1791. }

  1792. 

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

  1794. {

  1795. #if defined(JACKBRIDGE_DUMMY)

  1796. #elif defined(JACKBRIDGE_DIRECT)

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

  1798. #else

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

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

  1801. #endif

  1802.     return false;

  1803. }

  1804. 

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

  1806. {

  1807. #if defined(JACKBRIDGE_DUMMY)

  1808. #elif defined(JACKBRIDGE_DIRECT)

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

  1810. #else

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

  1812.     {

  1813. # ifdef __WINE__

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

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

  1816. # else

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

  1818. # endif

  1819.     }

  1820. #endif

  1821.     return false;

  1822. }

  1823. 

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

  1825. {

  1826. #if defined(JACKBRIDGE_DUMMY)

  1827. #elif defined(JACKBRIDGE_DIRECT)

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

  1829. #else

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

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

  1832. #endif

  1833.     return false;

  1834. }

  1835. 

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

  1837. {

  1838. #if defined(JACKBRIDGE_DUMMY)

  1839. #elif defined(JACKBRIDGE_DIRECT)

  1840.     return jack_transport_query(client, pos);

  1841. #else

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

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

  1844. #endif

  1845.     if (pos != nullptr)

  1846.     {

  1847.         // invalidate

  1848.         pos->unique_1 = 0;

  1849.         pos->unique_2 = 1;

  1850.     }

  1851.     return JackTransportStopped;

  1852. }

  1853. 

  1854. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1855. {

  1856. #if defined(JACKBRIDGE_DUMMY)

  1857. #elif defined(JACKBRIDGE_DIRECT)

  1858.     return jack_get_current_transport_frame(client);

  1859. #else

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

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

  1862. #endif

  1863.     return 0;

  1864. }

  1865. 

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

  1867. {

  1868. #if defined(JACKBRIDGE_DUMMY)

  1869. #elif defined(JACKBRIDGE_DIRECT)

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

  1871. #else

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

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

  1874. #endif

  1875.     return false;

  1876. }

  1877. 

  1878. void jackbridge_transport_start(jack_client_t* client)

  1879. {

  1880. #if defined(JACKBRIDGE_DUMMY)

  1881. #elif defined(JACKBRIDGE_DIRECT)

  1882.     jack_transport_start(client);

  1883. #else

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

  1885.         getBridgeInstance().transport_start_ptr(client);

  1886. #endif

  1887. }

  1888. 

  1889. void jackbridge_transport_stop(jack_client_t* client)

  1890. {

  1891. #if defined(JACKBRIDGE_DUMMY)

  1892. #elif defined(JACKBRIDGE_DIRECT)

  1893.     jack_transport_stop(client);

  1894. #else

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

  1896.         getBridgeInstance().transport_stop_ptr(client);

  1897. #endif

  1898. }

  1899. 

  1900. // -----------------------------------------------------------------------------

  1901. 

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

  1903. {

  1904. #if defined(JACKBRIDGE_DUMMY)

  1905. #elif defined(JACKBRIDGE_DIRECT)

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

  1907. #else

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

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

  1910. #endif

  1911.     return false;

  1912. }

  1913. 

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

  1915. {

  1916. #if defined(JACKBRIDGE_DUMMY)

  1917. #elif defined(JACKBRIDGE_DIRECT)

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

  1919. #else

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

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

  1922. #endif

  1923.     return false;

  1924. }

  1925. 

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

  1927. {

  1928. #if defined(JACKBRIDGE_DUMMY)

  1929. #elif defined(JACKBRIDGE_DIRECT)

  1930.     jack_free_description(desc, free_description_itself);

  1931. #else

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

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

  1934. #endif

  1935. }

  1936. 

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

  1938. {

  1939. #if defined(JACKBRIDGE_DUMMY)

  1940. #elif defined(JACKBRIDGE_DIRECT)

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

  1942. #else

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

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

  1945. #endif

  1946.     return false;

  1947. }

  1948. 

  1949. bool jackbridge_get_all_properties(jack_description_t** descs)

  1950. {

  1951. #if defined(JACKBRIDGE_DUMMY)

  1952. #elif defined(JACKBRIDGE_DIRECT)

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

  1954. #else

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

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

  1957. #endif

  1958.     return false;

  1959. }

  1960. 

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

  1962. {

  1963. #if defined(JACKBRIDGE_DUMMY)

  1964. #elif defined(JACKBRIDGE_DIRECT)

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

  1966. #else

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

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

  1969. #endif

  1970.     return false;

  1971. }

  1972. 

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

  1974. {

  1975. #if defined(JACKBRIDGE_DUMMY)

  1976. #elif defined(JACKBRIDGE_DIRECT)

  1977.     return jack_remove_properties(client, subject);

  1978. #else

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

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

  1981. #endif

  1982.     return 0;

  1983. }

  1984. 

  1985. bool jackbridge_remove_all_properties(jack_client_t* client)

  1986. {

  1987. #if defined(JACKBRIDGE_DUMMY)

  1988. #elif defined(JACKBRIDGE_DIRECT)

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

  1990. #else

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

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

  1993. #endif

  1994.     return false;

  1995. }

  1996. 

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

  1998. {

  1999. #if defined(JACKBRIDGE_DUMMY)

  2000. #elif defined(JACKBRIDGE_DIRECT)

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

  2002. #else

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

  2004.     {

  2005. # ifdef __WINE__

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

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

  2008. # else

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

  2010. # endif

  2011.     }

  2012. #endif

  2013.     return false;

  2014. }

  2015. 

  2016. // -----------------------------------------------------------------------------