WineASIO
/
wineasio
mirror of https://github.com/wineasio/wineasio
1
0
Fork 0
Code Releases 3 Activity
ASIO to JACK driver for WINE
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.
100 Commits
2 Branches
1.1MB
Branch: mod-desktop
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'mod-desktop'
${ noResults }
wineasio/JackBridge.c

1822 lines
62KB
Raw Permalink Blame History 

  1. /*

  2.  * JackBridge for DPF

  3.  * Copyright (C) 2013-2023 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.h"

  18. 

  19. #include <stdio.h>

  20. #include <shlobj.h>

  21. #include <windows.h>

  22. 

  23. #define JACKSYM_API __cdecl

  24. typedef HANDLE lib_t;

  25. 

  26. typedef unsigned long ulong;

  27. 

  28. // -----------------------------------------------------------------------------

  29. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  48. typedef void* (JACKSYM_API *JackSymThreadCallback)(void*);

  49. 

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

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

  52. 

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

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

  55. 

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

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

  58. 

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

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

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

  62. 

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

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

  65. 

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

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

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

  69. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  84. 

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

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

  87. 

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

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

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

  91. 

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

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

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

  95. 

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

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

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

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

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

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

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

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

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

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

  106. 

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

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

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

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

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

  112. 

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

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

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

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

  117. 

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

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

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

  121. 

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

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

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

  125. 

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

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

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

  129. 

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

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

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

  133. 

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

  135. 

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

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

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

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

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

  141. 

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

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

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

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

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

  147. 

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

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

  150. 

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

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

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

  154. 

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

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

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

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

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

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

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

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

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

  164. 

  165. typedef bool           (JACKSYM_API *jacksym_set_process_thread)(jack_client_t*, JackSymThreadCallback callback, void*);

  166. typedef jack_nframes_t (JACKSYM_API *jacksym_cycle_wait)(jack_client_t*);

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

  168. 

  169. typedef jack_nframes_t (JACKSYM_API *jacksym_port_get_latency)(jack_port_t*);

  170. typedef jack_nframes_t (JACKSYM_API *jacksym_frame_time)(const jack_client_t*);

  171. 

  172. // -----------------------------------------------------------------------------

  173. 

  174. typedef struct JackBridge {

  175.     lib_t lib;

  176. 

  177.     jacksym_get_version get_version_ptr;

  178.     jacksym_get_version_string get_version_string_ptr;

  179. 

  180.     jacksym_client_open client_open_ptr;

  181.     jacksym_client_close client_close_ptr;

  182. 

  183.     jacksym_client_name_size client_name_size_ptr;

  184.     jacksym_get_client_name get_client_name_ptr;

  185. 

  186.     jacksym_client_get_uuid client_get_uuid_ptr;

  187.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  188.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  189. 

  190.     jacksym_uuid_parse uuid_parse_ptr;

  191.     jacksym_uuid_unparse uuid_unparse_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.     jacksym_set_process_thread set_process_thread_ptr;

  293.     jacksym_cycle_wait cycle_wait_ptr;

  294.     jacksym_cycle_signal cycle_signal_ptr;

  295. 

  296.     jacksym_port_get_latency port_get_latency_ptr;

  297.     jacksym_frame_time frame_time_ptr;

  298. } JackBridge;

  299. 

  300. static void jackbridge_init(JackBridge* const bridge)

  301. {

  302.     memset(bridge, 0, sizeof(*bridge));

  303. 

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

  305.     WCHAR path[MAX_PATH];

  306.     if (SHGetFolderPathW(NULL, CSIDL_PROGRAM_FILES, NULL, SHGFP_TYPE_CURRENT, path) != S_OK)

  307.     {

  308.         fprintf(stderr, "Failed to load MOD Desktop JACK DLL\n");

  309.         return;

  310.     }

  311. 

  312.     WCHAR *path2 = path;

  313.     while (*path2++) {}

  314.     --path2;

  315.     memcpy(path2,  L"\\MOD Desktop\\libjack64.dll", sizeof(WCHAR)*27);

  316. 

  317.     const HANDLE lib = LoadLibraryW(path);

  318. 

  319.     if (lib == NULL)

  320.     {

  321.         fprintf(stderr, "Failed to load MOD Desktop JACK '%ls'\n", path);

  322.         return;

  323.     }

  324.     else

  325.     {

  326.         fprintf(stdout, "MOD Desktop JACK '%ls' loaded successfully!\n", path);

  327.     }

  328. 

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

  330.     #define LIB_SYMBOL(NAME) bridge->JOIN(NAME, _ptr) = (jacksym_##NAME)GetProcAddress(lib, "jack_" #NAME);

  331. 

  332.     LIB_SYMBOL(get_version)

  333.     LIB_SYMBOL(get_version_string)

  334. 

  335.     LIB_SYMBOL(client_open)

  336.     LIB_SYMBOL(client_close)

  337. 

  338.     LIB_SYMBOL(client_name_size)

  339.     LIB_SYMBOL(get_client_name)

  340. 

  341.     LIB_SYMBOL(client_get_uuid)

  342.     LIB_SYMBOL(get_uuid_for_client_name)

  343.     LIB_SYMBOL(get_client_name_by_uuid)

  344. 

  345.     LIB_SYMBOL(uuid_parse)

  346.     LIB_SYMBOL(uuid_unparse)

  347. 

  348.     LIB_SYMBOL(activate)

  349.     LIB_SYMBOL(deactivate)

  350.     LIB_SYMBOL(is_realtime)

  351. 

  352.     LIB_SYMBOL(set_thread_init_callback)

  353.     LIB_SYMBOL(on_shutdown)

  354.     LIB_SYMBOL(on_info_shutdown)

  355.     LIB_SYMBOL(set_process_callback)

  356.     LIB_SYMBOL(set_freewheel_callback)

  357.     LIB_SYMBOL(set_buffer_size_callback)

  358.     LIB_SYMBOL(set_sample_rate_callback)

  359.     LIB_SYMBOL(set_client_registration_callback)

  360.     LIB_SYMBOL(set_port_registration_callback)

  361.     LIB_SYMBOL(set_port_rename_callback)

  362.     LIB_SYMBOL(set_port_connect_callback)

  363.     LIB_SYMBOL(set_graph_order_callback)

  364.     LIB_SYMBOL(set_xrun_callback)

  365.     LIB_SYMBOL(set_latency_callback)

  366. 

  367.     LIB_SYMBOL(set_freewheel)

  368.     LIB_SYMBOL(set_buffer_size)

  369. 

  370.     LIB_SYMBOL(get_sample_rate)

  371.     LIB_SYMBOL(get_buffer_size)

  372.     LIB_SYMBOL(cpu_load)

  373. 

  374.     LIB_SYMBOL(port_register)

  375.     LIB_SYMBOL(port_unregister)

  376.     LIB_SYMBOL(port_get_buffer)

  377. 

  378.     LIB_SYMBOL(port_name)

  379.     LIB_SYMBOL(port_uuid)

  380.     LIB_SYMBOL(port_short_name)

  381.     LIB_SYMBOL(port_flags)

  382.     LIB_SYMBOL(port_type)

  383.     LIB_SYMBOL(port_is_mine)

  384.     LIB_SYMBOL(port_connected)

  385.     LIB_SYMBOL(port_connected_to)

  386.     LIB_SYMBOL(port_get_connections)

  387.     LIB_SYMBOL(port_get_all_connections)

  388. 

  389.     LIB_SYMBOL(port_rename)

  390.     LIB_SYMBOL(port_set_name)

  391.     LIB_SYMBOL(port_set_alias)

  392.     LIB_SYMBOL(port_unset_alias)

  393.     LIB_SYMBOL(port_get_aliases)

  394. 

  395.     LIB_SYMBOL(port_request_monitor)

  396.     LIB_SYMBOL(port_request_monitor_by_name)

  397.     LIB_SYMBOL(port_ensure_monitor)

  398.     LIB_SYMBOL(port_monitoring_input)

  399. 

  400.     LIB_SYMBOL(connect)

  401.     LIB_SYMBOL(disconnect)

  402.     LIB_SYMBOL(port_disconnect)

  403. 

  404.     LIB_SYMBOL(port_name_size)

  405.     LIB_SYMBOL(port_type_size)

  406.     LIB_SYMBOL(port_type_get_buffer_size)

  407. 

  408.     LIB_SYMBOL(port_get_latency_range)

  409.     LIB_SYMBOL(port_set_latency_range)

  410.     LIB_SYMBOL(recompute_total_latencies)

  411. 

  412.     LIB_SYMBOL(get_ports)

  413.     LIB_SYMBOL(port_by_name)

  414.     LIB_SYMBOL(port_by_id)

  415. 

  416.     LIB_SYMBOL(free)

  417. 

  418.     LIB_SYMBOL(midi_get_event_count)

  419.     LIB_SYMBOL(midi_event_get)

  420.     LIB_SYMBOL(midi_clear_buffer)

  421.     LIB_SYMBOL(midi_event_write)

  422.     LIB_SYMBOL(midi_event_reserve)

  423. 

  424.     LIB_SYMBOL(release_timebase)

  425.     LIB_SYMBOL(set_sync_callback)

  426.     LIB_SYMBOL(set_sync_timeout)

  427.     LIB_SYMBOL(set_timebase_callback)

  428.     LIB_SYMBOL(transport_locate)

  429.     LIB_SYMBOL(transport_query)

  430.     LIB_SYMBOL(get_current_transport_frame)

  431.     LIB_SYMBOL(transport_reposition)

  432.     LIB_SYMBOL(transport_start)

  433.     LIB_SYMBOL(transport_stop)

  434. 

  435.     LIB_SYMBOL(set_property)

  436.     LIB_SYMBOL(get_property)

  437.     LIB_SYMBOL(free_description)

  438.     LIB_SYMBOL(get_properties)

  439.     LIB_SYMBOL(get_all_properties)

  440.     LIB_SYMBOL(remove_property)

  441.     LIB_SYMBOL(remove_properties)

  442.     LIB_SYMBOL(remove_all_properties)

  443.     LIB_SYMBOL(set_property_change_callback)

  444. 

  445.     LIB_SYMBOL(set_process_thread)

  446.     LIB_SYMBOL(cycle_wait)

  447.     LIB_SYMBOL(cycle_signal)

  448. 

  449.     LIB_SYMBOL(port_get_latency)

  450.     LIB_SYMBOL(frame_time)

  451. 

  452.     #undef JOIN

  453.     #undef LIB_SYMBOL

  454. 

  455.     bridge->lib = lib;

  456. #endif

  457. }

  458. 

  459. static void jackbridge_destroy(JackBridge* const bridge)

  460. {

  461.     if (bridge->lib != NULL)

  462.     {

  463.         FreeLibrary(bridge->lib);

  464.         bridge->lib = NULL;

  465.     }

  466. }

  467. 

  468. static JackBridge* jackbridge_instance()

  469. {

  470.     static JackBridge bridge;

  471.     static bool init = false;

  472.     if (! init)

  473.     {

  474.         init = true;

  475.         jackbridge_init(&bridge);

  476.     }

  477.     return &bridge;

  478. }

  479. 

  480. // -----------------------------------------------------------------------------

  481. 

  482. bool jackbridge_is_ok()

  483. {

  484. #if defined(JACKBRIDGE_DUMMY)

  485.     return false;

  486. #elif defined(JACKBRIDGE_DIRECT)

  487.     return true;

  488. #else

  489.     return jackbridge_instance()->lib != NULL;

  490. #endif

  491. }

  492. 

  493. // -----------------------------------------------------------------------------

  494. 

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

  496. {

  497. #if defined(JACKBRIDGE_DUMMY)

  498. #elif defined(JACKBRIDGE_DIRECT)

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

  500. #else

  501.     if (jackbridge_instance()->get_version_ptr != NULL)

  502.         return jackbridge_instance()->get_version_ptr(major_ptr, minor_ptr, micro_ptr, proto_ptr);

  503. #endif

  504.     if (major_ptr != NULL)

  505.         *major_ptr = 0;

  506.     if (minor_ptr != NULL)

  507.         *minor_ptr = 0;

  508.     if (micro_ptr != NULL)

  509.         *micro_ptr = 0;

  510.     if (proto_ptr != NULL)

  511.         *proto_ptr = 0;

  512. }

  513. 

  514. const char* jackbridge_get_version_string()

  515. {

  516. #if defined(JACKBRIDGE_DUMMY)

  517. #elif defined(JACKBRIDGE_DIRECT)

  518.     return jack_get_version_string();

  519. #else

  520.     if (jackbridge_instance()->get_version_string_ptr != NULL)

  521.         return jackbridge_instance()->get_version_string_ptr();

  522. #endif

  523.     return NULL;

  524. }

  525. 

  526. // -----------------------------------------------------------------------------

  527. 

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

  529. {

  530. #if defined(JACKBRIDGE_DUMMY)

  531. #elif defined(JACKBRIDGE_DIRECT)

  532.     return jack_client_open(client_name, (jack_options_t)options, status);

  533. #endif

  534.     if (jackbridge_instance()->client_open_ptr != NULL)

  535.         return jackbridge_instance()->client_open_ptr(client_name, (jack_options_t)options, status, server_name);

  536.     if (status != NULL)

  537.         *status = JackServerError;

  538.     return NULL;

  539. }

  540. 

  541. bool jackbridge_client_close(jack_client_t* client)

  542. {

  543. #if defined(JACKBRIDGE_DUMMY)

  544. #elif defined(JACKBRIDGE_DIRECT)

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

  546. #else

  547.     if (jackbridge_instance()->client_close_ptr != NULL)

  548.         return (jackbridge_instance()->client_close_ptr(client) == 0);

  549. #endif

  550.     return false;

  551. }

  552. 

  553. // -----------------------------------------------------------------------------

  554. 

  555. int jackbridge_client_name_size()

  556. {

  557. #if defined(JACKBRIDGE_DUMMY)

  558. #elif defined(JACKBRIDGE_DIRECT)

  559.     return jack_client_name_size();

  560. #else

  561.     if (jackbridge_instance()->client_name_size_ptr != NULL)

  562.         return jackbridge_instance()->client_name_size_ptr();

  563. #endif

  564.     return 33;

  565. }

  566. 

  567. const char* jackbridge_get_client_name(jack_client_t* client)

  568. {

  569. #if defined(JACKBRIDGE_DUMMY)

  570. #elif defined(JACKBRIDGE_DIRECT)

  571.     return jack_get_client_name(client);

  572. #else

  573.     if (jackbridge_instance()->get_client_name_ptr != NULL)

  574.         return jackbridge_instance()->get_client_name_ptr(client);

  575. #endif

  576.     return NULL;

  577. }

  578. 

  579. // -----------------------------------------------------------------------------

  580. 

  581. char* jackbridge_client_get_uuid(jack_client_t* client)

  582. {

  583. #if defined(JACKBRIDGE_DUMMY)

  584. #elif defined(JACKBRIDGE_DIRECT)

  585.     return jack_client_get_uuid(client);

  586. #else

  587.     if (jackbridge_instance()->client_get_uuid_ptr != NULL)

  588.         return jackbridge_instance()->client_get_uuid_ptr(client);

  589. #endif

  590.     return NULL;

  591. }

  592. 

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

  594. {

  595. #if defined(JACKBRIDGE_DUMMY)

  596. #elif defined(JACKBRIDGE_DIRECT)

  597.     return jack_get_uuid_for_client_name(client, name);

  598. #else

  599.     if (jackbridge_instance()->get_uuid_for_client_name_ptr != NULL)

  600.         return jackbridge_instance()->get_uuid_for_client_name_ptr(client, name);

  601. #endif

  602.     return NULL;

  603. }

  604. 

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

  606. {

  607. #if defined(JACKBRIDGE_DUMMY)

  608. #elif defined(JACKBRIDGE_DIRECT)

  609.     return jack_get_client_name_by_uuid(client, uuid);

  610. #else

  611.     if (jackbridge_instance()->get_client_name_by_uuid_ptr != NULL)

  612.         return jackbridge_instance()->get_client_name_by_uuid_ptr(client, uuid);

  613. #endif

  614.     return NULL;

  615. }

  616. 

  617. // -----------------------------------------------------------------------------

  618. 

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

  620. {

  621. #if defined(JACKBRIDGE_DUMMY)

  622. #elif defined(JACKBRIDGE_DIRECT)

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

  624. #else

  625.     if (jackbridge_instance()->uuid_parse_ptr != NULL)

  626.         return jackbridge_instance()->uuid_parse_ptr(buf, uuid) == 0;

  627. #endif

  628.     return false;

  629. }

  630. 

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

  632. {

  633. #if defined(JACKBRIDGE_DUMMY)

  634. #elif defined(JACKBRIDGE_DIRECT)

  635.     jack_uuid_unparse(uuid, buf);

  636. #else

  637.     if (jackbridge_instance()->uuid_unparse_ptr != NULL)

  638.         return jackbridge_instance()->uuid_unparse_ptr(uuid, buf);

  639. #endif

  640. }

  641. 

  642. // -----------------------------------------------------------------------------

  643. 

  644. bool jackbridge_activate(jack_client_t* client)

  645. {

  646. #if defined(JACKBRIDGE_DUMMY)

  647. #elif defined(JACKBRIDGE_DIRECT)

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

  649. #else

  650.     if (jackbridge_instance()->activate_ptr != NULL)

  651.         return (jackbridge_instance()->activate_ptr(client) == 0);

  652. #endif

  653.     return false;

  654. }

  655. 

  656. bool jackbridge_deactivate(jack_client_t* client)

  657. {

  658. #if defined(JACKBRIDGE_DUMMY)

  659. #elif defined(JACKBRIDGE_DIRECT)

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

  661. #else

  662.     if (jackbridge_instance()->deactivate_ptr != NULL)

  663.         return (jackbridge_instance()->deactivate_ptr(client) == 0);

  664. #endif

  665.     return false;

  666. }

  667. 

  668. bool jackbridge_is_realtime(jack_client_t* client)

  669. {

  670. #if defined(JACKBRIDGE_DUMMY)

  671. #elif defined(JACKBRIDGE_DIRECT)

  672.     return jack_is_realtime(client);

  673. #else

  674.     if (jackbridge_instance()->is_realtime_ptr != NULL)

  675.         return jackbridge_instance()->is_realtime_ptr(client);

  676. #endif

  677.     return false;

  678. }

  679. 

  680. // -----------------------------------------------------------------------------

  681. 

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

  683. {

  684. #if defined(JACKBRIDGE_DUMMY)

  685. #elif defined(JACKBRIDGE_DIRECT)

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

  687. #else

  688.     if (jackbridge_instance()->set_thread_init_callback_ptr != NULL)

  689.     {

  690. # ifdef __WINE__

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

  692.         return (jackbridge_instance()->set_thread_init_callback_ptr(client, WineBridge::thread_init, arg) == 0);

  693. # else

  694.         return (jackbridge_instance()->set_thread_init_callback_ptr(client, thread_init_callback, arg) == 0);

  695. # endif

  696.     }

  697. #endif

  698.     return false;

  699. }

  700. 

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

  702. {

  703. #if defined(JACKBRIDGE_DUMMY)

  704. #elif defined(JACKBRIDGE_DIRECT)

  705.     jack_on_shutdown(client, shutdown_callback, arg);

  706. #else

  707.     if (jackbridge_instance()->on_shutdown_ptr != NULL)

  708.     {

  709. # ifdef __WINE__

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

  711.         jackbridge_instance()->on_shutdown_ptr(client, WineBridge::shutdown, arg);

  712. # else

  713.         jackbridge_instance()->on_shutdown_ptr(client, shutdown_callback, arg);

  714. # endif

  715.     }

  716. #endif

  717. }

  718. 

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

  720. {

  721. #if defined(JACKBRIDGE_DUMMY)

  722. #elif defined(JACKBRIDGE_DIRECT)

  723.     jack_on_info_shutdown(client, shutdown_callback, arg);

  724. #else

  725.     if (jackbridge_instance()->on_info_shutdown_ptr != NULL)

  726.     {

  727. # ifdef __WINE__

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

  729.         jackbridge_instance()->on_info_shutdown_ptr(client, WineBridge::info_shutdown, arg);

  730. # else

  731.         jackbridge_instance()->on_info_shutdown_ptr(client, shutdown_callback, arg);

  732. # endif

  733.     }

  734. #endif

  735. }

  736. 

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

  738. {

  739. #if defined(JACKBRIDGE_DUMMY)

  740. #elif defined(JACKBRIDGE_DIRECT)

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

  742. #else

  743.     if (jackbridge_instance()->set_process_callback_ptr != NULL)

  744.     {

  745. # ifdef __WINE__

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

  747.         return (jackbridge_instance()->set_process_callback_ptr(client, WineBridge::process, arg) == 0);

  748. # else

  749.         return (jackbridge_instance()->set_process_callback_ptr(client, process_callback, arg) == 0);

  750. # endif

  751.     }

  752. #endif

  753.     return false;

  754. }

  755. 

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

  757. {

  758. #if defined(JACKBRIDGE_DUMMY)

  759. #elif defined(JACKBRIDGE_DIRECT)

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

  761. #else

  762.     if (jackbridge_instance()->set_freewheel_callback_ptr != NULL)

  763.     {

  764. # ifdef __WINE__

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

  766.         return (jackbridge_instance()->set_freewheel_callback_ptr(client, WineBridge::freewheel, arg) == 0);

  767. # else

  768.         return (jackbridge_instance()->set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);

  769. # endif

  770.     }

  771. #endif

  772.     return false;

  773. }

  774. 

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

  776. {

  777. #if defined(JACKBRIDGE_DUMMY)

  778. #elif defined(JACKBRIDGE_DIRECT)

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

  780. #else

  781.     if (jackbridge_instance()->set_buffer_size_callback_ptr != NULL)

  782.     {

  783. # ifdef __WINE__

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

  785.         return (jackbridge_instance()->set_buffer_size_callback_ptr(client, WineBridge::bufsize, arg) == 0);

  786. # else

  787.         return (jackbridge_instance()->set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);

  788. # endif

  789.     }

  790. #endif

  791.     return false;

  792. }

  793. 

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

  795. {

  796. #if defined(JACKBRIDGE_DUMMY)

  797. #elif defined(JACKBRIDGE_DIRECT)

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

  799. #else

  800.     if (jackbridge_instance()->set_sample_rate_callback_ptr != NULL)

  801.     {

  802. # ifdef __WINE__

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

  804.         return (jackbridge_instance()->set_sample_rate_callback_ptr(client, WineBridge::srate, arg) == 0);

  805. # else

  806.         return (jackbridge_instance()->set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);

  807. # endif

  808.     }

  809. #endif

  810.     return false;

  811. }

  812. 

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

  814. {

  815. #if defined(JACKBRIDGE_DUMMY)

  816. #elif defined(JACKBRIDGE_DIRECT)

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

  818. #else

  819.     if (jackbridge_instance()->set_client_registration_callback_ptr != NULL)

  820.     {

  821. # ifdef __WINE__

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

  823.         return (jackbridge_instance()->set_client_registration_callback_ptr(client, WineBridge::client_reg, arg) == 0);

  824. # else

  825.         return (jackbridge_instance()->set_client_registration_callback_ptr(client, registration_callback, arg) == 0);

  826. # endif

  827.     }

  828. #endif

  829.     return false;

  830. }

  831. 

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

  833. {

  834. #if defined(JACKBRIDGE_DUMMY)

  835. #elif defined(JACKBRIDGE_DIRECT)

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

  837. #else

  838.     if (jackbridge_instance()->set_port_registration_callback_ptr != NULL)

  839.     {

  840. # ifdef __WINE__

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

  842.         return (jackbridge_instance()->set_port_registration_callback_ptr(client, WineBridge::port_reg, arg) == 0);

  843. # else

  844.         return (jackbridge_instance()->set_port_registration_callback_ptr(client, registration_callback, arg) == 0);

  845. # endif

  846.     }

  847. #endif

  848.     return false;

  849. }

  850. 

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

  852. {

  853. #if defined(JACKBRIDGE_DUMMY)

  854. #elif defined(JACKBRIDGE_DIRECT)

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

  856. #else

  857.     if (jackbridge_instance()->set_port_rename_callback_ptr != NULL)

  858.     {

  859. # ifdef __WINE__

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

  861.         return (jackbridge_instance()->set_port_rename_callback_ptr(client, WineBridge::port_rename, arg) == 0);

  862. # else

  863.         return (jackbridge_instance()->set_port_rename_callback_ptr(client, rename_callback, arg) == 0);

  864. # endif

  865.     }

  866. #endif

  867.     return false;

  868. }

  869. 

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

  871. {

  872. #if defined(JACKBRIDGE_DUMMY)

  873. #elif defined(JACKBRIDGE_DIRECT)

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

  875. #else

  876.     if (jackbridge_instance()->set_port_connect_callback_ptr != NULL)

  877.     {

  878. # ifdef __WINE__

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

  880.         return (jackbridge_instance()->set_port_connect_callback_ptr(client, WineBridge::port_conn, arg) == 0);

  881. # else

  882.         return (jackbridge_instance()->set_port_connect_callback_ptr(client, connect_callback, arg) == 0);

  883. # endif

  884.     }

  885. #endif

  886.     return false;

  887. }

  888. 

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

  890. {

  891. #if defined(JACKBRIDGE_DUMMY)

  892. #elif defined(JACKBRIDGE_DIRECT)

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

  894. #else

  895.     if (jackbridge_instance()->set_graph_order_callback_ptr != NULL)

  896.     {

  897. # ifdef __WINE__

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

  899.         return (jackbridge_instance()->set_graph_order_callback_ptr(client, WineBridge::graph_order, arg) == 0);

  900. # else

  901.         return (jackbridge_instance()->set_graph_order_callback_ptr(client, graph_callback, arg) == 0);

  902. # endif

  903.     }

  904. #endif

  905.     return false;

  906. }

  907. 

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

  909. {

  910. #if defined(JACKBRIDGE_DUMMY)

  911. #elif defined(JACKBRIDGE_DIRECT)

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

  913. #else

  914.     if (jackbridge_instance()->set_xrun_callback_ptr != NULL)

  915.     {

  916. # ifdef __WINE__

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

  918.         return (jackbridge_instance()->set_xrun_callback_ptr(client, WineBridge::xrun, arg) == 0);

  919. # else

  920.         return (jackbridge_instance()->set_xrun_callback_ptr(client, xrun_callback, arg) == 0);

  921. # endif

  922.     }

  923. #endif

  924.     return false;

  925. }

  926. 

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

  928. {

  929. #if defined(JACKBRIDGE_DUMMY)

  930. #elif defined(JACKBRIDGE_DIRECT)

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

  932. #else

  933.     if (jackbridge_instance()->set_latency_callback_ptr != NULL)

  934.     {

  935. # ifdef __WINE__

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

  937.         return (jackbridge_instance()->set_latency_callback_ptr(client, WineBridge::latency, arg) == 0);

  938. # else

  939.         return (jackbridge_instance()->set_latency_callback_ptr(client, latency_callback, arg) == 0);

  940. # endif

  941.     }

  942. #endif

  943.     return false;

  944. }

  945. 

  946. // -----------------------------------------------------------------------------

  947. 

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

  949. {

  950. #if defined(JACKBRIDGE_DUMMY)

  951. #elif defined(JACKBRIDGE_DIRECT)

  952.     return jack_set_freewheel(client, onoff);

  953. #else

  954.     if (jackbridge_instance()->set_freewheel_ptr != NULL)

  955.         return jackbridge_instance()->set_freewheel_ptr(client, onoff);

  956. #endif

  957.     return false;

  958. }

  959. 

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

  961. {

  962. #if defined(JACKBRIDGE_DUMMY)

  963. #elif defined(JACKBRIDGE_DIRECT)

  964.     return jack_set_buffer_size(client, nframes);

  965. #else

  966.     if (jackbridge_instance()->set_buffer_size_ptr != NULL)

  967.         return jackbridge_instance()->set_buffer_size_ptr(client, nframes);

  968. #endif

  969.     return false;

  970. }

  971. 

  972. // -----------------------------------------------------------------------------

  973. 

  974. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  975. {

  976. #if defined(JACKBRIDGE_DUMMY)

  977. #elif defined(JACKBRIDGE_DIRECT)

  978.     return jack_get_sample_rate(client);

  979. #else

  980.     if (jackbridge_instance()->get_sample_rate_ptr != NULL)

  981.         return jackbridge_instance()->get_sample_rate_ptr(client);

  982. #endif

  983.     return 0;

  984. }

  985. 

  986. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  987. {

  988. #if defined(JACKBRIDGE_DUMMY)

  989. #elif defined(JACKBRIDGE_DIRECT)

  990.     return jack_get_buffer_size(client);

  991. #else

  992.     if (jackbridge_instance()->get_buffer_size_ptr != NULL)

  993.         return jackbridge_instance()->get_buffer_size_ptr(client);

  994. #endif

  995.     return 0;

  996. }

  997. 

  998. float jackbridge_cpu_load(jack_client_t* client)

  999. {

  1000. #if defined(JACKBRIDGE_DUMMY)

  1001. #elif defined(JACKBRIDGE_DIRECT)

  1002.     return jack_cpu_load(client);

  1003. #else

  1004.     if (jackbridge_instance()->cpu_load_ptr != NULL)

  1005.         return jackbridge_instance()->cpu_load_ptr(client);

  1006. #endif

  1007.     return 0.0f;

  1008. }

  1009. 

  1010. // -----------------------------------------------------------------------------

  1011. 

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

  1013. {

  1014. #if defined(JACKBRIDGE_DUMMY)

  1015. #elif defined(JACKBRIDGE_DIRECT)

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

  1017. #else

  1018.     if (jackbridge_instance()->port_register_ptr != NULL)

  1019.         return jackbridge_instance()->port_register_ptr(client, port_name, type, (ulong)flags, (ulong)buffer_size);

  1020. #endif

  1021.     return NULL;

  1022. }

  1023. 

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

  1025. {

  1026. #if defined(JACKBRIDGE_DUMMY)

  1027. #elif defined(JACKBRIDGE_DIRECT)

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

  1029. #else

  1030.     if (jackbridge_instance()->port_unregister_ptr != NULL)

  1031.         return (jackbridge_instance()->port_unregister_ptr(client, port) == 0);

  1032. #endif

  1033.     return false;

  1034. }

  1035. 

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

  1037. {

  1038. #if defined(JACKBRIDGE_DUMMY)

  1039. #elif defined(JACKBRIDGE_DIRECT)

  1040.     return jack_port_get_buffer(port, nframes);

  1041. #else

  1042.     if (jackbridge_instance()->port_get_buffer_ptr != NULL)

  1043.         return jackbridge_instance()->port_get_buffer_ptr(port, nframes);

  1044. #endif

  1045.     return NULL;

  1046. }

  1047. 

  1048. // -----------------------------------------------------------------------------

  1049. 

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

  1051. {

  1052. #if defined(JACKBRIDGE_DUMMY)

  1053. #elif defined(JACKBRIDGE_DIRECT)

  1054.     return jack_port_name(port);

  1055. #else

  1056.     if (jackbridge_instance()->port_name_ptr != NULL)

  1057.         return jackbridge_instance()->port_name_ptr(port);

  1058. #endif

  1059.     return NULL;

  1060. }

  1061. 

  1062. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1063. {

  1064. #if defined(JACKBRIDGE_DUMMY)

  1065. #elif defined(JACKBRIDGE_DIRECT)

  1066.     return jack_port_uuid(port);

  1067. #else

  1068.     if (jackbridge_instance()->port_uuid_ptr != NULL)

  1069.         return jackbridge_instance()->port_uuid_ptr(port);

  1070. #endif

  1071.     return 0;

  1072. }

  1073. 

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

  1075. {

  1076. #if defined(JACKBRIDGE_DUMMY)

  1077. #elif defined(JACKBRIDGE_DIRECT)

  1078.     return jack_port_short_name(port);

  1079. #else

  1080.     if (jackbridge_instance()->port_short_name_ptr != NULL)

  1081.         return jackbridge_instance()->port_short_name_ptr(port);

  1082. #endif

  1083.     return NULL;

  1084. }

  1085. 

  1086. int jackbridge_port_flags(const jack_port_t* port)

  1087. {

  1088. #if defined(JACKBRIDGE_DUMMY)

  1089. #elif defined(JACKBRIDGE_DIRECT)

  1090.     return jack_port_flags(port);

  1091. #else

  1092.     if (jackbridge_instance()->port_flags_ptr != NULL)

  1093.         return jackbridge_instance()->port_flags_ptr(port);

  1094. #endif

  1095.     return 0x0;

  1096. }

  1097. 

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

  1099. {

  1100. #if defined(JACKBRIDGE_DUMMY)

  1101. #elif defined(JACKBRIDGE_DIRECT)

  1102.     return jack_port_type(port);

  1103. #else

  1104.     if (jackbridge_instance()->port_type_ptr != NULL)

  1105.         return jackbridge_instance()->port_type_ptr(port);

  1106. #endif

  1107.     return NULL;

  1108. }

  1109. 

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

  1111. {

  1112. #if defined(JACKBRIDGE_DUMMY)

  1113. #elif defined(JACKBRIDGE_DIRECT)

  1114.     return jack_port_is_mine(client, port);

  1115. #else

  1116.     if (jackbridge_instance()->port_is_mine_ptr != NULL)

  1117.         return jackbridge_instance()->port_is_mine_ptr(client, port);

  1118. #endif

  1119.     return false;

  1120. }

  1121. 

  1122. int jackbridge_port_connected(const jack_port_t* port)

  1123. {

  1124. #if defined(JACKBRIDGE_DUMMY)

  1125. #elif defined(JACKBRIDGE_DIRECT)

  1126.     return jack_port_connected(port);

  1127. #else

  1128.     if (jackbridge_instance()->port_connected_ptr != NULL)

  1129.         return jackbridge_instance()->port_connected_ptr(port);

  1130. #endif

  1131.     return 0;

  1132. }

  1133. 

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

  1135. {

  1136. #if defined(JACKBRIDGE_DUMMY)

  1137. #elif defined(JACKBRIDGE_DIRECT)

  1138.     return jack_port_connected_to(port, port_name);

  1139. #else

  1140.     if (jackbridge_instance()->port_connected_to_ptr != NULL)

  1141.         return jackbridge_instance()->port_connected_to_ptr(port, port_name);

  1142. #endif

  1143.     return false;

  1144. }

  1145. 

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

  1147. {

  1148. #if defined(JACKBRIDGE_DUMMY)

  1149. #elif defined(JACKBRIDGE_DIRECT)

  1150.     return jack_port_get_connections(port);

  1151. #else

  1152.     if (jackbridge_instance()->port_get_connections_ptr != NULL)

  1153.         return jackbridge_instance()->port_get_connections_ptr(port);

  1154. #endif

  1155.     return NULL;

  1156. }

  1157. 

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

  1159. {

  1160. #if defined(JACKBRIDGE_DUMMY)

  1161. #elif defined(JACKBRIDGE_DIRECT)

  1162.     return jack_port_get_all_connections(client, port);

  1163. #else

  1164.     if (jackbridge_instance()->port_get_all_connections_ptr != NULL)

  1165.         return jackbridge_instance()->port_get_all_connections_ptr(client, port);

  1166. #endif

  1167.     return NULL;

  1168. }

  1169. 

  1170. // -----------------------------------------------------------------------------

  1171. 

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

  1173. {

  1174. #if defined(JACKBRIDGE_DUMMY)

  1175. #elif defined(JACKBRIDGE_DIRECT)

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

  1177. #else

  1178.     // Try new API first

  1179.     if (jackbridge_instance()->port_rename_ptr != NULL)

  1180.         return (jackbridge_instance()->port_rename_ptr(client, port, port_name) == 0);

  1181.     // Try old API if using JACK2

  1182.     if (jackbridge_instance()->get_version_string_ptr != NULL && jackbridge_instance()->port_set_name_ptr != NULL)

  1183.         return (jackbridge_instance()->port_set_name_ptr(port, port_name) == 0);

  1184. #endif

  1185.     return false;

  1186. }

  1187. 

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

  1189. {

  1190. #if defined(JACKBRIDGE_DUMMY)

  1191. #elif defined(JACKBRIDGE_DIRECT)

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

  1193. #else

  1194.     if (jackbridge_instance()->port_set_alias_ptr != NULL)

  1195.         return (jackbridge_instance()->port_set_alias_ptr(port, alias) == 0);

  1196. #endif

  1197.     return false;

  1198. }

  1199. 

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

  1201. {

  1202. #if defined(JACKBRIDGE_DUMMY)

  1203. #elif defined(JACKBRIDGE_DIRECT)

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

  1205. #else

  1206.     if (jackbridge_instance()->port_unset_alias_ptr != NULL)

  1207.         return (jackbridge_instance()->port_unset_alias_ptr(port, alias) == 0);

  1208. #endif

  1209.     return false;

  1210. }

  1211. 

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

  1213. {

  1214. #if defined(JACKBRIDGE_DUMMY)

  1215. #elif defined(JACKBRIDGE_DIRECT)

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

  1217. #else

  1218.     if (jackbridge_instance()->port_get_aliases_ptr != NULL)

  1219.         return jackbridge_instance()->port_get_aliases_ptr(port, aliases);

  1220. #endif

  1221.     return 0;

  1222. }

  1223. 

  1224. // -----------------------------------------------------------------------------

  1225. 

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

  1227. {

  1228. #if defined(JACKBRIDGE_DUMMY)

  1229. #elif defined(JACKBRIDGE_DIRECT)

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

  1231. #else

  1232.     if (jackbridge_instance()->port_request_monitor_ptr != NULL)

  1233.         return (jackbridge_instance()->port_request_monitor_ptr(port, onoff) == 0);

  1234. #endif

  1235.     return false;

  1236. }

  1237. 

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

  1239. {

  1240. #if defined(JACKBRIDGE_DUMMY)

  1241. #elif defined(JACKBRIDGE_DIRECT)

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

  1243. #else

  1244.     if (jackbridge_instance()->port_request_monitor_by_name_ptr != NULL)

  1245.         return (jackbridge_instance()->port_request_monitor_by_name_ptr(client, port_name, onoff) == 0);

  1246. #endif

  1247.     return false;

  1248. }

  1249. 

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

  1251. {

  1252. #if defined(JACKBRIDGE_DUMMY)

  1253. #elif defined(JACKBRIDGE_DIRECT)

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

  1255. #else

  1256.     if (jackbridge_instance()->port_ensure_monitor_ptr != NULL)

  1257.         return (jackbridge_instance()->port_ensure_monitor_ptr(port, onoff) == 0);

  1258. #endif

  1259.     return false;

  1260. }

  1261. 

  1262. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1263. {

  1264. #if defined(JACKBRIDGE_DUMMY)

  1265. #elif defined(JACKBRIDGE_DIRECT)

  1266.     return jack_port_monitoring_input(port);

  1267. #else

  1268.     if (jackbridge_instance()->port_monitoring_input_ptr != NULL)

  1269.         return jackbridge_instance()->port_monitoring_input_ptr(port);

  1270. #endif

  1271.     return false;

  1272. }

  1273. 

  1274. // -----------------------------------------------------------------------------

  1275. 

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

  1277. {

  1278. #if defined(JACKBRIDGE_DUMMY)

  1279. #elif defined(JACKBRIDGE_DIRECT)

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

  1281. #else

  1282.     if (jackbridge_instance()->connect_ptr != NULL)

  1283.     {

  1284.         const int ret = jackbridge_instance()->connect_ptr(client, source_port, destination_port);

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

  1286.     }

  1287. #endif

  1288.     return false;

  1289. }

  1290. 

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

  1292. {

  1293. #if defined(JACKBRIDGE_DUMMY)

  1294. #elif defined(JACKBRIDGE_DIRECT)

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

  1296. #else

  1297.     if (jackbridge_instance()->disconnect_ptr != NULL)

  1298.         return (jackbridge_instance()->disconnect_ptr(client, source_port, destination_port) == 0);

  1299. #endif

  1300.     return false;

  1301. }

  1302. 

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

  1304. {

  1305. #if defined(JACKBRIDGE_DUMMY)

  1306. #elif defined(JACKBRIDGE_DIRECT)

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

  1308. #else

  1309.     if (jackbridge_instance()->port_disconnect_ptr != NULL)

  1310.         return (jackbridge_instance()->port_disconnect_ptr(client, port) == 0);

  1311. #endif

  1312.     return false;

  1313. }

  1314. 

  1315. // -----------------------------------------------------------------------------

  1316. 

  1317. int jackbridge_port_name_size()

  1318. {

  1319. #if defined(JACKBRIDGE_DUMMY)

  1320. #elif defined(JACKBRIDGE_DIRECT)

  1321.     return jack_port_name_size();

  1322. #else

  1323.     if (jackbridge_instance()->port_name_size_ptr != NULL)

  1324.         return jackbridge_instance()->port_name_size_ptr();

  1325. #endif

  1326.     return 256;

  1327. }

  1328. 

  1329. int jackbridge_port_type_size()

  1330. {

  1331. #if defined(JACKBRIDGE_DUMMY)

  1332. #elif defined(JACKBRIDGE_DIRECT)

  1333.     return jack_port_type_size();

  1334. #else

  1335.     if (jackbridge_instance()->port_type_size_ptr != NULL)

  1336.         return jackbridge_instance()->port_type_size_ptr();

  1337. #endif

  1338.     return 32;

  1339. }

  1340. 

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

  1342. {

  1343. #if defined(JACKBRIDGE_DUMMY)

  1344. #elif defined(JACKBRIDGE_DIRECT)

  1345.     return (uint32_t)jack_port_type_get_buffer_size(client, port_type);

  1346. #else

  1347.     if (jackbridge_instance()->port_type_get_buffer_size_ptr != NULL)

  1348.         return (uint32_t)jackbridge_instance()->port_type_get_buffer_size_ptr(client, port_type);

  1349. #endif

  1350.     return 0;

  1351. }

  1352. 

  1353. // -----------------------------------------------------------------------------

  1354. 

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

  1356. {

  1357. #if defined(JACKBRIDGE_DUMMY)

  1358. #elif defined(JACKBRIDGE_DIRECT)

  1359.     return jack_port_get_latency_range(port, (jack_latency_callback_mode_t)mode, range);

  1360. #else

  1361.     if (jackbridge_instance()->port_get_latency_range_ptr != NULL)

  1362.         return jackbridge_instance()->port_get_latency_range_ptr(port, (jack_latency_callback_mode_t)mode, range);

  1363. #endif

  1364.     range->min = 0;

  1365.     range->max = 0;

  1366. }

  1367. 

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

  1369. {

  1370. #if defined(JACKBRIDGE_DUMMY)

  1371. #elif defined(JACKBRIDGE_DIRECT)

  1372.     jack_port_set_latency_range(port, (jack_latency_callback_mode_t)mode, range);

  1373. #else

  1374.     if (jackbridge_instance()->port_set_latency_range_ptr != NULL)

  1375.         jackbridge_instance()->port_set_latency_range_ptr(port, (jack_latency_callback_mode_t)mode, range);

  1376. #endif

  1377. }

  1378. 

  1379. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1380. {

  1381. #if defined(JACKBRIDGE_DUMMY)

  1382. #elif defined(JACKBRIDGE_DIRECT)

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

  1384. #else

  1385.     if (jackbridge_instance()->recompute_total_latencies_ptr != NULL)

  1386.         return (jackbridge_instance()->recompute_total_latencies_ptr(client) == 0);

  1387. #endif

  1388.     return false;

  1389. }

  1390. 

  1391. // -----------------------------------------------------------------------------

  1392. 

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

  1394. {

  1395. #if defined(JACKBRIDGE_DUMMY)

  1396. #elif defined(JACKBRIDGE_DIRECT)

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

  1398. #else

  1399.     if (jackbridge_instance()->get_ports_ptr != NULL)

  1400.         return jackbridge_instance()->get_ports_ptr(client, port_name_pattern, type_name_pattern, (ulong)flags);

  1401. #endif

  1402.     return NULL;

  1403. }

  1404. 

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

  1406. {

  1407. #if defined(JACKBRIDGE_DUMMY)

  1408. #elif defined(JACKBRIDGE_DIRECT)

  1409.     return jack_port_by_name(client, port_name);

  1410. #else

  1411.     if (jackbridge_instance()->port_by_name_ptr != NULL)

  1412.         return jackbridge_instance()->port_by_name_ptr(client, port_name);

  1413. #endif

  1414.     return NULL;

  1415. }

  1416. 

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

  1418. {

  1419. #if defined(JACKBRIDGE_DUMMY)

  1420. #elif defined(JACKBRIDGE_DIRECT)

  1421.     return jack_port_by_id(client, port_id);

  1422. #else

  1423.     if (jackbridge_instance()->port_by_id_ptr != NULL)

  1424.         return jackbridge_instance()->port_by_id_ptr(client, port_id);

  1425. #endif

  1426.     return NULL;

  1427. }

  1428. 

  1429. // -----------------------------------------------------------------------------

  1430. 

  1431. void jackbridge_free(void* ptr)

  1432. {

  1433. #if defined(JACKBRIDGE_DUMMY)

  1434. #elif defined(JACKBRIDGE_DIRECT)

  1435.     return jack_free(ptr);

  1436. #else

  1437.     if (jackbridge_instance()->free_ptr != NULL)

  1438.         return jackbridge_instance()->free_ptr(ptr);

  1439. 

  1440.    #ifndef _WIN32

  1441.     free(ptr);

  1442.    #endif

  1443. #endif

  1444. }

  1445. 

  1446. // -----------------------------------------------------------------------------

  1447. 

  1448. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1449. {

  1450. #if defined(JACKBRIDGE_DUMMY)

  1451. #elif defined(JACKBRIDGE_DIRECT)

  1452.     return jack_midi_get_event_count(port_buffer);

  1453. #else

  1454.     if (jackbridge_instance()->midi_get_event_count_ptr != NULL)

  1455.         return jackbridge_instance()->midi_get_event_count_ptr(port_buffer);

  1456. #endif

  1457.     return 0;

  1458. }

  1459. 

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

  1461. {

  1462. #if defined(JACKBRIDGE_DUMMY)

  1463. #elif defined(JACKBRIDGE_DIRECT)

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

  1465. #else

  1466.     if (jackbridge_instance()->midi_event_get_ptr != NULL)

  1467.         return (jackbridge_instance()->midi_event_get_ptr(event, port_buffer, event_index) == 0);

  1468. #endif

  1469.     return false;

  1470. }

  1471. 

  1472. void jackbridge_midi_clear_buffer(void* port_buffer)

  1473. {

  1474. #if defined(JACKBRIDGE_DUMMY)

  1475. #elif defined(JACKBRIDGE_DIRECT)

  1476.     jack_midi_clear_buffer(port_buffer);

  1477. #else

  1478.     if (jackbridge_instance()->midi_clear_buffer_ptr != NULL)

  1479.         jackbridge_instance()->midi_clear_buffer_ptr(port_buffer);

  1480. #endif

  1481. }

  1482. 

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

  1484. {

  1485. #if defined(JACKBRIDGE_DUMMY)

  1486. #elif defined(JACKBRIDGE_DIRECT)

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

  1488. #else

  1489.     if (jackbridge_instance()->midi_event_write_ptr != NULL)

  1490.         return (jackbridge_instance()->midi_event_write_ptr(port_buffer, time, data, data_size) == 0);

  1491. #endif

  1492.     return false;

  1493. }

  1494. 

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

  1496. {

  1497. #if defined(JACKBRIDGE_DUMMY)

  1498. #elif defined(JACKBRIDGE_DIRECT)

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

  1500. #else

  1501.     if (jackbridge_instance()->midi_event_reserve_ptr != NULL)

  1502.         return jackbridge_instance()->midi_event_reserve_ptr(port_buffer, time, data_size);

  1503. #endif

  1504.     return NULL;

  1505. }

  1506. 

  1507. // -----------------------------------------------------------------------------

  1508. 

  1509. bool jackbridge_release_timebase(jack_client_t* client)

  1510. {

  1511. #if defined(JACKBRIDGE_DUMMY)

  1512. #elif defined(JACKBRIDGE_DIRECT)

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

  1514. #else

  1515.     if (jackbridge_instance()->release_timebase_ptr != NULL)

  1516.         return (jackbridge_instance()->release_timebase_ptr(client) == 0);

  1517. #endif

  1518.     return false;

  1519. }

  1520. 

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

  1522. {

  1523. #if defined(JACKBRIDGE_DUMMY)

  1524. #elif defined(JACKBRIDGE_DIRECT)

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

  1526. #else

  1527.     if (jackbridge_instance()->set_sync_callback_ptr != NULL)

  1528.     {

  1529. # ifdef __WINE__

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

  1531.         return (jackbridge_instance()->set_sync_callback_ptr(client, WineBridge::sync, arg) == 0);

  1532. # else

  1533.         return (jackbridge_instance()->set_sync_callback_ptr(client, sync_callback, arg) == 0);

  1534. # endif

  1535.     }

  1536. #endif

  1537.     return false;

  1538. }

  1539. 

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

  1541. {

  1542. #if defined(JACKBRIDGE_DUMMY)

  1543. #elif defined(JACKBRIDGE_DIRECT)

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

  1545. #else

  1546.     if (jackbridge_instance()->set_sync_timeout_ptr != NULL)

  1547.         return (jackbridge_instance()->set_sync_timeout_ptr(client, timeout) == 0);

  1548. #endif

  1549.     return false;

  1550. }

  1551. 

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

  1553. {

  1554. #if defined(JACKBRIDGE_DUMMY)

  1555. #elif defined(JACKBRIDGE_DIRECT)

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

  1557. #else

  1558.     if (jackbridge_instance()->set_timebase_callback_ptr != NULL)

  1559.         return (jackbridge_instance()->set_timebase_callback_ptr(client, conditional, timebase_callback, arg) == 0);

  1560. #endif

  1561.     return false;

  1562. }

  1563. 

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

  1565. {

  1566. #if defined(JACKBRIDGE_DUMMY)

  1567. #elif defined(JACKBRIDGE_DIRECT)

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

  1569. #else

  1570.     if (jackbridge_instance()->transport_locate_ptr != NULL)

  1571.         return (jackbridge_instance()->transport_locate_ptr(client, frame) == 0);

  1572. #endif

  1573.     return false;

  1574. }

  1575. 

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

  1577. {

  1578. #if defined(JACKBRIDGE_DUMMY)

  1579. #elif defined(JACKBRIDGE_DIRECT)

  1580.     return jack_transport_query(client, pos);

  1581. #else

  1582.     if (jackbridge_instance()->transport_query_ptr != NULL)

  1583.         return jackbridge_instance()->transport_query_ptr(client, pos);

  1584. #endif

  1585.     if (pos != NULL)

  1586.     {

  1587.         // invalidate

  1588.         memset(pos, 0, sizeof(*pos));

  1589.         pos->unique_1 = 0;

  1590.         pos->unique_2 = 1;

  1591.     }

  1592.     return JackTransportStopped;

  1593. }

  1594. 

  1595. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1596. {

  1597. #if defined(JACKBRIDGE_DUMMY)

  1598. #elif defined(JACKBRIDGE_DIRECT)

  1599.     return jack_get_current_transport_frame(client);

  1600. #else

  1601.     if (jackbridge_instance()->get_current_transport_frame_ptr != NULL)

  1602.         return jackbridge_instance()->get_current_transport_frame_ptr(client);

  1603. #endif

  1604.     return 0;

  1605. }

  1606. 

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

  1608. {

  1609. #if defined(JACKBRIDGE_DUMMY)

  1610. #elif defined(JACKBRIDGE_DIRECT)

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

  1612. #else

  1613.     if (jackbridge_instance()->transport_reposition_ptr != NULL)

  1614.         return (jackbridge_instance()->transport_reposition_ptr(client, pos) == 0);

  1615. #endif

  1616.     return false;

  1617. }

  1618. 

  1619. void jackbridge_transport_start(jack_client_t* client)

  1620. {

  1621. #if defined(JACKBRIDGE_DUMMY)

  1622. #elif defined(JACKBRIDGE_DIRECT)

  1623.     jack_transport_start(client);

  1624. #else

  1625.     if (jackbridge_instance()->transport_start_ptr != NULL)

  1626.         jackbridge_instance()->transport_start_ptr(client);

  1627. #endif

  1628. }

  1629. 

  1630. void jackbridge_transport_stop(jack_client_t* client)

  1631. {

  1632. #if defined(JACKBRIDGE_DUMMY)

  1633. #elif defined(JACKBRIDGE_DIRECT)

  1634.     jack_transport_stop(client);

  1635. #else

  1636.     if (jackbridge_instance()->transport_stop_ptr != NULL)

  1637.         jackbridge_instance()->transport_stop_ptr(client);

  1638. #endif

  1639. }

  1640. 

  1641. // -----------------------------------------------------------------------------

  1642. 

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

  1644. {

  1645. #if defined(JACKBRIDGE_DUMMY)

  1646. #elif defined(JACKBRIDGE_DIRECT)

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

  1648. #else

  1649.     if (jackbridge_instance()->set_property_ptr != NULL)

  1650.         return (jackbridge_instance()->set_property_ptr(client, subject, key, value, type) == 0);

  1651. #endif

  1652.     return false;

  1653. }

  1654. 

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

  1656. {

  1657. #if defined(JACKBRIDGE_DUMMY)

  1658. #elif defined(JACKBRIDGE_DIRECT)

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

  1660. #else

  1661.     if (jackbridge_instance()->get_property_ptr != NULL)

  1662.         return (jackbridge_instance()->get_property_ptr(subject, key, value, type) == 0);

  1663. #endif

  1664.     return false;

  1665. }

  1666. 

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

  1668. {

  1669. #if defined(JACKBRIDGE_DUMMY)

  1670. #elif defined(JACKBRIDGE_DIRECT)

  1671.     jack_free_description(desc, free_description_itself);

  1672. #else

  1673.     if (jackbridge_instance()->free_description_ptr != NULL)

  1674.         jackbridge_instance()->free_description_ptr(desc, free_description_itself);

  1675. #endif

  1676. }

  1677. 

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

  1679. {

  1680. #if defined(JACKBRIDGE_DUMMY)

  1681. #elif defined(JACKBRIDGE_DIRECT)

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

  1683. #else

  1684.     if (jackbridge_instance()->get_properties_ptr != NULL)

  1685.         return (jackbridge_instance()->get_properties_ptr(subject, desc) == 0);

  1686. #endif

  1687.     return false;

  1688. }

  1689. 

  1690. bool jackbridge_get_all_properties(jack_description_t** descs)

  1691. {

  1692. #if defined(JACKBRIDGE_DUMMY)

  1693. #elif defined(JACKBRIDGE_DIRECT)

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

  1695. #else

  1696.     if (jackbridge_instance()->get_all_properties_ptr != NULL)

  1697.         return (jackbridge_instance()->get_all_properties_ptr(descs) == 0);

  1698. #endif

  1699.     return false;

  1700. }

  1701. 

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

  1703. {

  1704. #if defined(JACKBRIDGE_DUMMY)

  1705. #elif defined(JACKBRIDGE_DIRECT)

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

  1707. #else

  1708.     if (jackbridge_instance()->remove_property_ptr != NULL)

  1709.         return (jackbridge_instance()->remove_property_ptr(client, subject, key) == 0);

  1710. #endif

  1711.     return false;

  1712. }

  1713. 

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

  1715. {

  1716. #if defined(JACKBRIDGE_DUMMY)

  1717. #elif defined(JACKBRIDGE_DIRECT)

  1718.     return jack_remove_properties(client, subject);

  1719. #else

  1720.     if (jackbridge_instance()->remove_properties_ptr != NULL)

  1721.         return jackbridge_instance()->remove_properties_ptr(client, subject);

  1722. #endif

  1723.     return 0;

  1724. }

  1725. 

  1726. bool jackbridge_remove_all_properties(jack_client_t* client)

  1727. {

  1728. #if defined(JACKBRIDGE_DUMMY)

  1729. #elif defined(JACKBRIDGE_DIRECT)

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

  1731. #else

  1732.     if (jackbridge_instance()->remove_all_properties_ptr != NULL)

  1733.         return (jackbridge_instance()->remove_all_properties_ptr(client) == 0);

  1734. #endif

  1735.     return false;

  1736. }

  1737. 

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

  1739. {

  1740. #if defined(JACKBRIDGE_DUMMY)

  1741. #elif defined(JACKBRIDGE_DIRECT)

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

  1743. #else

  1744.     if (jackbridge_instance()->set_property_change_callback_ptr != NULL)

  1745.     {

  1746. # ifdef __WINE__

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

  1748.         return (jackbridge_instance()->set_property_change_callback_ptr(client, WineBridge::prop_change, arg) == 0);

  1749. # else

  1750.         return (jackbridge_instance()->set_property_change_callback_ptr(client, callback, arg) == 0);

  1751. # endif

  1752.     }

  1753. #endif

  1754.     return false;

  1755. }

  1756. 

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

  1758. {

  1759. #if defined(JACKBRIDGE_DUMMY)

  1760. #elif defined(JACKBRIDGE_DIRECT)

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

  1762. #else

  1763.     if (jackbridge_instance()->set_process_thread_ptr != NULL)

  1764.     {

  1765. # ifdef __WINE__

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

  1767.         return (jackbridge_instance()->set_process_thread_ptr(client, WineBridge::process_thread, arg) == 0);

  1768. # else

  1769.         return (jackbridge_instance()->set_process_thread_ptr(client, callback, arg) == 0);

  1770. # endif

  1771.     }

  1772. #endif

  1773.     return false;

  1774. }

  1775. 

  1776. jack_nframes_t jackbridge_cycle_wait(jack_client_t* client)

  1777. {

  1778. #if defined(JACKBRIDGE_DUMMY)

  1779. #elif defined(JACKBRIDGE_DIRECT)

  1780.     return jack_cycle_wait(client);

  1781. #else

  1782.     if (jackbridge_instance()->cycle_wait_ptr != NULL)

  1783.         return jackbridge_instance()->cycle_wait_ptr(client);

  1784. #endif

  1785.     return 0;

  1786. }

  1787. 

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

  1789. {

  1790. #if defined(JACKBRIDGE_DUMMY)

  1791. #elif defined(JACKBRIDGE_DIRECT)

  1792.     jack_cycle_signal(client, status);

  1793. #else

  1794.     if (jackbridge_instance()->cycle_signal_ptr != NULL)

  1795.         jackbridge_instance()->cycle_signal_ptr(client, status);

  1796. #endif

  1797. }

  1798. 

  1799. jack_nframes_t jackbridge_port_get_latency(jack_port_t* port)

  1800. {

  1801. #if defined(JACKBRIDGE_DUMMY)

  1802. #elif defined(JACKBRIDGE_DIRECT)

  1803.     return jack_port_get_latency(port);

  1804. #else

  1805.     if (jackbridge_instance()->port_get_latency_ptr != NULL)

  1806.         jackbridge_instance()->port_get_latency_ptr(port);

  1807.     return 0;

  1808. #endif

  1809. }

  1810. 

  1811. jack_nframes_t jackbridge_frame_time(const jack_client_t* client)

  1812. {

  1813. #if defined(JACKBRIDGE_DUMMY)

  1814. #elif defined(JACKBRIDGE_DIRECT)

  1815.     return jackbridge_frame_time(client);

  1816. #else

  1817.     if (jackbridge_instance()->frame_time_ptr != NULL)

  1818.         jackbridge_instance()->frame_time_ptr(client);

  1819.     return 0;

  1820. #endif

  1821. }