WineASIO
/
wineasio
mirror of https://github.com/wineasio/wineasio
1
0
Fork 0
Code Releases 4 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.
108 Commits
2 Branches
826KB
Tree: 5fee7e65a2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5fee7e65a2'
${ noResults }
wineasio/jackbridge.c

1216 lines
46KB
Raw Blame History 

  1. /*

  2.  * JackBridge for DPF

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

  21. 

  22. #include <windows.h>

  23. 

  24. #include <dlfcn.h>

  25. #include <errno.h>

  26. 

  27. typedef unsigned long ulong;

  28. 

  29. // --------------------------------------------------------------------------------------------------------------------

  30. 

  31. typedef void (*JackSymLatencyCallback)(jack_latency_callback_mode_t, void*);

  32. typedef int  (*JackSymProcessCallback)(jack_nframes_t, void*);

  33. typedef void (*JackSymThreadInitCallback)(void*);

  34. typedef int  (*JackSymGraphOrderCallback)(void*);

  35. typedef int  (*JackSymXRunCallback)(void*);

  36. typedef int  (*JackSymBufferSizeCallback)(jack_nframes_t, void*);

  37. typedef int  (*JackSymSampleRateCallback)(jack_nframes_t, void*);

  38. typedef void (*JackSymPortRegistrationCallback)(jack_port_id_t, int, void*);

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

  40. typedef void (*JackSymPortConnectCallback)(jack_port_id_t, jack_port_id_t, int, void*);

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

  42. typedef void (*JackSymFreewheelCallback)(int, void*);

  43. typedef void (*JackSymShutdownCallback)(void*);

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

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

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

  47. typedef void (*JackSymSessionCallback)(jack_session_event_t*, void*);

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

  49. typedef void* (*JackSymThreadCallback)(void*);

  50. 

  51. typedef void        (*jacksym_get_version)(int*, int*, int*, int*);

  52. typedef const char* (*jacksym_get_version_string)(void);

  53. 

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

  55. typedef int            (*jacksym_client_close)(jack_client_t*);

  56. 

  57. typedef int   (*jacksym_client_name_size)(void);

  58. typedef char* (*jacksym_get_client_name)(jack_client_t*);

  59. 

  60. typedef char* (*jacksym_client_get_uuid)(jack_client_t*);

  61. typedef char* (*jacksym_get_uuid_for_client_name)(jack_client_t*, const char*);

  62. typedef char* (*jacksym_get_client_name_by_uuid)(jack_client_t*, const char*);

  63. 

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

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

  66. 

  67. typedef int (*jacksym_activate)(jack_client_t*);

  68. typedef int (*jacksym_deactivate)(jack_client_t*);

  69. typedef int (*jacksym_is_realtime)(jack_client_t*);

  70. 

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

  72. typedef void (*jacksym_on_shutdown)(jack_client_t*, JackSymShutdownCallback, void*);

  73. typedef void (*jacksym_on_info_shutdown)(jack_client_t*, JackSymInfoShutdownCallback, void*);

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

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

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

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

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

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

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

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

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

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

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

  85. 

  86. typedef int (*jacksym_set_freewheel)(jack_client_t*, int);

  87. typedef int (*jacksym_set_buffer_size)(jack_client_t*, jack_nframes_t);

  88. 

  89. typedef jack_nframes_t (*jacksym_get_sample_rate)(jack_client_t*);

  90. typedef jack_nframes_t (*jacksym_get_buffer_size)(jack_client_t*);

  91. typedef float          (*jacksym_cpu_load)(jack_client_t*);

  92. 

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

  94. typedef int          (*jacksym_port_unregister)(jack_client_t*, jack_port_t*);

  95. typedef void*        (*jacksym_port_get_buffer)(jack_port_t*, jack_nframes_t);

  96. 

  97. typedef const char*  (*jacksym_port_name)(const jack_port_t*);

  98. typedef jack_uuid_t  (*jacksym_port_uuid)(const jack_port_t*);

  99. typedef const char*  (*jacksym_port_short_name)(const jack_port_t*);

  100. typedef int          (*jacksym_port_flags)(const jack_port_t*);

  101. typedef const char*  (*jacksym_port_type)(const jack_port_t*);

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

  103. typedef int          (*jacksym_port_connected)(const jack_port_t*);

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

  105. typedef const char** (*jacksym_port_get_connections)(const jack_port_t*);

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

  107. 

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

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

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

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

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

  113. 

  114. typedef int (*jacksym_port_request_monitor)(jack_port_t*, int);

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

  116. typedef int (*jacksym_port_ensure_monitor)(jack_port_t*, int);

  117. typedef int (*jacksym_port_monitoring_input)(jack_port_t*);

  118. 

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

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

  121. typedef int (*jacksym_port_disconnect)(jack_client_t*, jack_port_t*);

  122. 

  123. typedef int    (*jacksym_port_name_size)(void);

  124. typedef int    (*jacksym_port_type_size)(void);

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

  126. 

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

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

  129. typedef int  (*jacksym_recompute_total_latencies)(jack_client_t*);

  130. 

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

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

  133. typedef jack_port_t* (*jacksym_port_by_id)(jack_client_t*, jack_port_id_t);

  134. 

  135. typedef void (*jacksym_free)(void*);

  136. 

  137. typedef uint32_t (*jacksym_midi_get_event_count)(void*);

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

  139. typedef void     (*jacksym_midi_clear_buffer)(void*);

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

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

  142. 

  143. typedef int (*jacksym_release_timebase)(jack_client_t*);

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

  145. typedef int (*jacksym_set_sync_timeout)(jack_client_t*, jack_time_t);

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

  147. typedef int (*jacksym_transport_locate)(jack_client_t*, jack_nframes_t);

  148. 

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

  150. typedef jack_nframes_t         (*jacksym_get_current_transport_frame)(const jack_client_t*);

  151. 

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

  153. typedef void (*jacksym_transport_start)(jack_client_t*);

  154. typedef void (*jacksym_transport_stop)(jack_client_t*);

  155. 

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

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

  158. typedef void (*jacksym_free_description)(jack_description_t*, int);

  159. typedef int  (*jacksym_get_properties)(jack_uuid_t, jack_description_t*);

  160. typedef int  (*jacksym_get_all_properties)(jack_description_t**);

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

  162. typedef int  (*jacksym_remove_properties)(jack_client_t*, jack_uuid_t);

  163. typedef int  (*jacksym_remove_all_properties)(jack_client_t*);

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

  165. 

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

  167. typedef void (*jacksym_set_thread_creator)(jacksym_thread_creator_t);

  168. 

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

  170. typedef jack_nframes_t (*jacksym_cycle_wait)(jack_client_t*);

  171. typedef void           (*jacksym_cycle_signal)(jack_client_t*, int);

  172. 

  173. typedef jack_nframes_t (*jacksym_port_get_latency)(jack_port_t*);

  174. typedef jack_nframes_t (*jacksym_frame_time)(const jack_client_t*);

  175. 

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

  177. 

  178. typedef struct JackBridge {

  179.     void* lib;

  180. 

  181.     jacksym_get_version get_version_ptr;

  182.     jacksym_get_version_string get_version_string_ptr;

  183. 

  184.     jacksym_client_open client_open_ptr;

  185.     jacksym_client_close client_close_ptr;

  186. 

  187.     jacksym_client_name_size client_name_size_ptr;

  188.     jacksym_get_client_name get_client_name_ptr;

  189. 

  190.     jacksym_client_get_uuid client_get_uuid_ptr;

  191.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  192.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  193. 

  194.     jacksym_uuid_parse uuid_parse_ptr;

  195.     jacksym_uuid_unparse uuid_unparse_ptr;

  196. 

  197.     jacksym_activate activate_ptr;

  198.     jacksym_deactivate deactivate_ptr;

  199.     jacksym_is_realtime is_realtime_ptr;

  200. 

  201.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  202.     jacksym_on_shutdown on_shutdown_ptr;

  203.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  204.     jacksym_set_process_callback set_process_callback_ptr;

  205.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  206.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  207.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  208.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  209.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  210.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  211.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  212.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  213.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  214.     jacksym_set_latency_callback set_latency_callback_ptr;

  215. 

  216.     jacksym_set_freewheel set_freewheel_ptr;

  217.     jacksym_set_buffer_size set_buffer_size_ptr;

  218. 

  219.     jacksym_get_sample_rate get_sample_rate_ptr;

  220.     jacksym_get_buffer_size get_buffer_size_ptr;

  221.     jacksym_cpu_load cpu_load_ptr;

  222. 

  223.     jacksym_port_register port_register_ptr;

  224.     jacksym_port_unregister port_unregister_ptr;

  225.     jacksym_port_get_buffer port_get_buffer_ptr;

  226. 

  227.     jacksym_port_name port_name_ptr;

  228.     jacksym_port_uuid port_uuid_ptr;

  229.     jacksym_port_short_name port_short_name_ptr;

  230.     jacksym_port_flags port_flags_ptr;

  231.     jacksym_port_type port_type_ptr;

  232.     jacksym_port_is_mine port_is_mine_ptr;

  233.     jacksym_port_connected port_connected_ptr;

  234.     jacksym_port_connected_to port_connected_to_ptr;

  235.     jacksym_port_get_connections port_get_connections_ptr;

  236.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  237. 

  238.     jacksym_port_rename port_rename_ptr;

  239.     jacksym_port_set_name port_set_name_ptr;

  240.     jacksym_port_set_alias port_set_alias_ptr;

  241.     jacksym_port_unset_alias port_unset_alias_ptr;

  242.     jacksym_port_get_aliases port_get_aliases_ptr;

  243. 

  244.     jacksym_port_request_monitor port_request_monitor_ptr;

  245.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  246.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  247.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  248. 

  249.     jacksym_connect connect_ptr;

  250.     jacksym_disconnect disconnect_ptr;

  251.     jacksym_port_disconnect port_disconnect_ptr;

  252. 

  253.     jacksym_port_name_size port_name_size_ptr;

  254.     jacksym_port_type_size port_type_size_ptr;

  255.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  256. 

  257.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  258.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  259.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  260. 

  261.     jacksym_get_ports get_ports_ptr;

  262.     jacksym_port_by_name port_by_name_ptr;

  263.     jacksym_port_by_id port_by_id_ptr;

  264. 

  265.     jacksym_free free_ptr;

  266. 

  267.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  268.     jacksym_midi_event_get midi_event_get_ptr;

  269.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  270.     jacksym_midi_event_write midi_event_write_ptr;

  271.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  272. 

  273.     jacksym_release_timebase release_timebase_ptr;

  274.     jacksym_set_sync_callback set_sync_callback_ptr;

  275.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  276.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  277.     jacksym_transport_locate transport_locate_ptr;

  278. 

  279.     jacksym_transport_query transport_query_ptr;

  280.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  281. 

  282.     jacksym_transport_reposition transport_reposition_ptr;

  283.     jacksym_transport_start transport_start_ptr;

  284.     jacksym_transport_stop transport_stop_ptr;

  285. 

  286.     jacksym_set_property set_property_ptr;

  287.     jacksym_get_property get_property_ptr;

  288.     jacksym_free_description free_description_ptr;

  289.     jacksym_get_properties get_properties_ptr;

  290.     jacksym_get_all_properties get_all_properties_ptr;

  291.     jacksym_remove_property remove_property_ptr;

  292.     jacksym_remove_properties remove_properties_ptr;

  293.     jacksym_remove_all_properties remove_all_properties_ptr;

  294.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  295. 

  296.     jacksym_set_thread_creator set_thread_creator_ptr;

  297. 

  298.     jacksym_set_process_thread set_process_thread_ptr;

  299.     jacksym_cycle_wait cycle_wait_ptr;

  300.     jacksym_cycle_signal cycle_signal_ptr;

  301. 

  302.     jacksym_port_get_latency port_get_latency_ptr;

  303.     jacksym_frame_time frame_time_ptr;

  304. } JackBridge;

  305. 

  306. static void jackbridge_init(JackBridge* const bridge)

  307. {

  308.     void* lib;

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

  310. 

  311.     lib = dlopen("libjack.so.0", RTLD_NOW);

  312.     if (lib == NULL)

  313.     {

  314.         fprintf(stderr, "[wineasio] Failed to load libjack.so.0: '%s'\n", dlerror());

  315.         return;

  316.     }

  317.     else

  318.     {

  319.         fprintf(stdout, "[wineasio] libjack.so.0 loaded successfully!\n");

  320.     }

  321. 

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

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

  324. 

  325.     LIB_SYMBOL(get_version)

  326.     LIB_SYMBOL(get_version_string)

  327. 

  328.     LIB_SYMBOL(client_open)

  329.     LIB_SYMBOL(client_close)

  330. 

  331.     LIB_SYMBOL(client_name_size)

  332.     LIB_SYMBOL(get_client_name)

  333. 

  334.     LIB_SYMBOL(client_get_uuid)

  335.     LIB_SYMBOL(get_uuid_for_client_name)

  336.     LIB_SYMBOL(get_client_name_by_uuid)

  337. 

  338.     LIB_SYMBOL(uuid_parse)

  339.     LIB_SYMBOL(uuid_unparse)

  340. 

  341.     LIB_SYMBOL(activate)

  342.     LIB_SYMBOL(deactivate)

  343.     LIB_SYMBOL(is_realtime)

  344. 

  345.     LIB_SYMBOL(set_thread_init_callback)

  346.     LIB_SYMBOL(on_shutdown)

  347.     LIB_SYMBOL(on_info_shutdown)

  348.     LIB_SYMBOL(set_process_callback)

  349.     LIB_SYMBOL(set_freewheel_callback)

  350.     LIB_SYMBOL(set_buffer_size_callback)

  351.     LIB_SYMBOL(set_sample_rate_callback)

  352.     LIB_SYMBOL(set_client_registration_callback)

  353.     LIB_SYMBOL(set_port_registration_callback)

  354.     LIB_SYMBOL(set_port_rename_callback)

  355.     LIB_SYMBOL(set_port_connect_callback)

  356.     LIB_SYMBOL(set_graph_order_callback)

  357.     LIB_SYMBOL(set_xrun_callback)

  358.     LIB_SYMBOL(set_latency_callback)

  359. 

  360.     LIB_SYMBOL(set_freewheel)

  361.     LIB_SYMBOL(set_buffer_size)

  362. 

  363.     LIB_SYMBOL(get_sample_rate)

  364.     LIB_SYMBOL(get_buffer_size)

  365.     LIB_SYMBOL(cpu_load)

  366. 

  367.     LIB_SYMBOL(port_register)

  368.     LIB_SYMBOL(port_unregister)

  369.     LIB_SYMBOL(port_get_buffer)

  370. 

  371.     LIB_SYMBOL(port_name)

  372.     LIB_SYMBOL(port_uuid)

  373.     LIB_SYMBOL(port_short_name)

  374.     LIB_SYMBOL(port_flags)

  375.     LIB_SYMBOL(port_type)

  376.     LIB_SYMBOL(port_is_mine)

  377.     LIB_SYMBOL(port_connected)

  378.     LIB_SYMBOL(port_connected_to)

  379.     LIB_SYMBOL(port_get_connections)

  380.     LIB_SYMBOL(port_get_all_connections)

  381. 

  382.     LIB_SYMBOL(port_rename)

  383.     LIB_SYMBOL(port_set_name)

  384.     LIB_SYMBOL(port_set_alias)

  385.     LIB_SYMBOL(port_unset_alias)

  386.     LIB_SYMBOL(port_get_aliases)

  387. 

  388.     LIB_SYMBOL(port_request_monitor)

  389.     LIB_SYMBOL(port_request_monitor_by_name)

  390.     LIB_SYMBOL(port_ensure_monitor)

  391.     LIB_SYMBOL(port_monitoring_input)

  392. 

  393.     LIB_SYMBOL(connect)

  394.     LIB_SYMBOL(disconnect)

  395.     LIB_SYMBOL(port_disconnect)

  396. 

  397.     LIB_SYMBOL(port_name_size)

  398.     LIB_SYMBOL(port_type_size)

  399.     LIB_SYMBOL(port_type_get_buffer_size)

  400. 

  401.     LIB_SYMBOL(port_get_latency_range)

  402.     LIB_SYMBOL(port_set_latency_range)

  403.     LIB_SYMBOL(recompute_total_latencies)

  404. 

  405.     LIB_SYMBOL(get_ports)

  406.     LIB_SYMBOL(port_by_name)

  407.     LIB_SYMBOL(port_by_id)

  408. 

  409.     LIB_SYMBOL(free)

  410. 

  411.     LIB_SYMBOL(midi_get_event_count)

  412.     LIB_SYMBOL(midi_event_get)

  413.     LIB_SYMBOL(midi_clear_buffer)

  414.     LIB_SYMBOL(midi_event_write)

  415.     LIB_SYMBOL(midi_event_reserve)

  416. 

  417.     LIB_SYMBOL(release_timebase)

  418.     LIB_SYMBOL(set_sync_callback)

  419.     LIB_SYMBOL(set_sync_timeout)

  420.     LIB_SYMBOL(set_timebase_callback)

  421.     LIB_SYMBOL(transport_locate)

  422.     LIB_SYMBOL(transport_query)

  423.     LIB_SYMBOL(get_current_transport_frame)

  424.     LIB_SYMBOL(transport_reposition)

  425.     LIB_SYMBOL(transport_start)

  426.     LIB_SYMBOL(transport_stop)

  427. 

  428.     LIB_SYMBOL(set_property)

  429.     LIB_SYMBOL(get_property)

  430.     LIB_SYMBOL(free_description)

  431.     LIB_SYMBOL(get_properties)

  432.     LIB_SYMBOL(get_all_properties)

  433.     LIB_SYMBOL(remove_property)

  434.     LIB_SYMBOL(remove_properties)

  435.     LIB_SYMBOL(remove_all_properties)

  436.     LIB_SYMBOL(set_property_change_callback)

  437. 

  438.     LIB_SYMBOL(set_thread_creator)

  439. 

  440.     LIB_SYMBOL(set_process_thread)

  441.     LIB_SYMBOL(cycle_wait)

  442.     LIB_SYMBOL(cycle_signal)

  443. 

  444.     LIB_SYMBOL(port_get_latency)

  445.     LIB_SYMBOL(frame_time)

  446. 

  447.     #undef JOIN

  448.     #undef LIB_SYMBOL

  449. 

  450.     bridge->lib = lib;

  451. }

  452. 

  453. __attribute__((destructor))

  454. static void jackbridge_destroy(JackBridge* const bridge)

  455. {

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

  457.     {

  458.         dlclose(bridge->lib);

  459.         bridge->lib = NULL;

  460.     }

  461. }

  462. 

  463. static JackBridge* jackbridge_instance()

  464. {

  465.     static JackBridge bridge;

  466.     static bool init = false;

  467.     if (! init)

  468.     {

  469.         init = true;

  470.         jackbridge_init(&bridge);

  471.     }

  472.     return &bridge;

  473. }

  474. 

  475. // --------------------------------------------------------------------------------------------------------------------

  476. 

  477. bool jackbridge_is_ok()

  478. {

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

  480. }

  481. 

  482. // --------------------------------------------------------------------------------------------------------------------

  483. 

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

  485. {

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

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

  488.     if (major_ptr != NULL)

  489.         *major_ptr = 0;

  490.     if (minor_ptr != NULL)

  491.         *minor_ptr = 0;

  492.     if (micro_ptr != NULL)

  493.         *micro_ptr = 0;

  494.     if (proto_ptr != NULL)

  495.         *proto_ptr = 0;

  496. }

  497. 

  498. const char* jackbridge_get_version_string()

  499. {

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

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

  502.     return NULL;

  503. }

  504. 

  505. // --------------------------------------------------------------------------------------------------------------------

  506. 

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

  508. {

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

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

  511.     if (status != NULL)

  512.         *status = JackServerError;

  513.     return NULL;

  514. }

  515. 

  516. bool jackbridge_client_close(jack_client_t* client)

  517. {

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

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

  520.     return false;

  521. }

  522. 

  523. // --------------------------------------------------------------------------------------------------------------------

  524. 

  525. int jackbridge_client_name_size()

  526. {

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

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

  529.     return 33;

  530. }

  531. 

  532. const char* jackbridge_get_client_name(jack_client_t* client)

  533. {

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

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

  536.     return NULL;

  537. }

  538. 

  539. // --------------------------------------------------------------------------------------------------------------------

  540. 

  541. char* jackbridge_client_get_uuid(jack_client_t* client)

  542. {

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

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

  545.     return NULL;

  546. }

  547. 

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

  549. {

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

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

  552.     return NULL;

  553. }

  554. 

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

  556. {

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

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

  559.     return NULL;

  560. }

  561. 

  562. // --------------------------------------------------------------------------------------------------------------------

  563. 

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

  565. {

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

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

  568.     return false;

  569. }

  570. 

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

  572. {

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

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

  575. }

  576. 

  577. // --------------------------------------------------------------------------------------------------------------------

  578. 

  579. bool jackbridge_activate(jack_client_t* client)

  580. {

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

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

  583.     return false;

  584. }

  585. 

  586. bool jackbridge_deactivate(jack_client_t* client)

  587. {

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

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

  590.     return false;

  591. }

  592. 

  593. bool jackbridge_is_realtime(jack_client_t* client)

  594. {

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

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

  597.     return false;

  598. }

  599. 

  600. // --------------------------------------------------------------------------------------------------------------------

  601. 

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

  603. {

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

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

  606.     return false;

  607. }

  608. 

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

  610. {

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

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

  613. }

  614. 

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

  616. {

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

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

  619. }

  620. 

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

  622. {

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

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

  625.     return false;

  626. }

  627. 

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

  629. {

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

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

  632.     return false;

  633. }

  634. 

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

  636. {

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

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

  639.     return false;

  640. }

  641. 

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

  643. {

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

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

  646.     return false;

  647. }

  648. 

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

  650. {

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

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

  653.     return false;

  654. }

  655. 

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

  657. {

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

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

  660.     return false;

  661. }

  662. 

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

  664. {

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

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

  667.     return false;

  668. }

  669. 

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

  671. {

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

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

  674.     return false;

  675. }

  676. 

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

  678. {

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

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

  681.     return false;

  682. }

  683. 

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

  685. {

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

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

  688.     return false;

  689. }

  690. 

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

  692. {

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

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

  695.     return false;

  696. }

  697. 

  698. // --------------------------------------------------------------------------------------------------------------------

  699. 

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

  701. {

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

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

  704.     return false;

  705. }

  706. 

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

  708. {

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

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

  711.     return false;

  712. }

  713. 

  714. // --------------------------------------------------------------------------------------------------------------------

  715. 

  716. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  717. {

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

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

  720.     return 0;

  721. }

  722. 

  723. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  724. {

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

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

  727.     return 0;

  728. }

  729. 

  730. float jackbridge_cpu_load(jack_client_t* client)

  731. {

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

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

  734.     return 0.0f;

  735. }

  736. 

  737. // --------------------------------------------------------------------------------------------------------------------

  738. 

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

  740. {

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

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

  743.     return NULL;

  744. }

  745. 

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

  747. {

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

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

  750.     return false;

  751. }

  752. 

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

  754. {

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

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

  757.     return NULL;

  758. }

  759. 

  760. // --------------------------------------------------------------------------------------------------------------------

  761. 

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

  763. {

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

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

  766.     return NULL;

  767. }

  768. 

  769. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  770. {

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

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

  773.     return 0;

  774. }

  775. 

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

  777. {

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

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

  780.     return NULL;

  781. }

  782. 

  783. int jackbridge_port_flags(const jack_port_t* port)

  784. {

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

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

  787.     return 0x0;

  788. }

  789. 

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

  791. {

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

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

  794.     return NULL;

  795. }

  796. 

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

  798. {

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

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

  801.     return false;

  802. }

  803. 

  804. int jackbridge_port_connected(const jack_port_t* port)

  805. {

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

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

  808.     return 0;

  809. }

  810. 

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

  812. {

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

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

  815.     return false;

  816. }

  817. 

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

  819. {

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

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

  822.     return NULL;

  823. }

  824. 

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

  826. {

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

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

  829.     return NULL;

  830. }

  831. 

  832. // --------------------------------------------------------------------------------------------------------------------

  833. 

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

  835. {

  836.     // Try new API first

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

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

  839.     // Try old API if using JACK2

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

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

  842.     return false;

  843. }

  844. 

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

  846. {

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

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

  849.     return false;

  850. }

  851. 

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

  853. {

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

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

  856.     return false;

  857. }

  858. 

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

  860. {

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

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

  863.     return 0;

  864. }

  865. 

  866. // --------------------------------------------------------------------------------------------------------------------

  867. 

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

  869. {

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

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

  872.     return false;

  873. }

  874. 

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

  876. {

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

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

  879.     return false;

  880. }

  881. 

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

  883. {

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

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

  886.     return false;

  887. }

  888. 

  889. bool jackbridge_port_monitoring_input(jack_port_t* port)

  890. {

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

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

  893.     return false;

  894. }

  895. 

  896. // --------------------------------------------------------------------------------------------------------------------

  897. 

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

  899. {

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

  901.     {

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

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

  904.     }

  905.     return false;

  906. }

  907. 

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

  909. {

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

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

  912.     return false;

  913. }

  914. 

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

  916. {

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

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

  919.     return false;

  920. }

  921. 

  922. // --------------------------------------------------------------------------------------------------------------------

  923. 

  924. int jackbridge_port_name_size()

  925. {

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

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

  928.     return 256;

  929. }

  930. 

  931. int jackbridge_port_type_size()

  932. {

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

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

  935.     return 32;

  936. }

  937. 

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

  939. {

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

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

  942.     return 0;

  943. }

  944. 

  945. // --------------------------------------------------------------------------------------------------------------------

  946. 

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

  948. {

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

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

  951.     range->min = 0;

  952.     range->max = 0;

  953. }

  954. 

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

  956. {

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

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

  959. }

  960. 

  961. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  962. {

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

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

  965.     return false;

  966. }

  967. 

  968. // --------------------------------------------------------------------------------------------------------------------

  969. 

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

  971. {

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

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

  974.     return NULL;

  975. }

  976. 

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

  978. {

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

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

  981.     return NULL;

  982. }

  983. 

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

  985. {

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

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

  988.     return NULL;

  989. }

  990. 

  991. // --------------------------------------------------------------------------------------------------------------------

  992. 

  993. void jackbridge_free(void* ptr)

  994. {

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

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

  997.     free(ptr);

  998. }

  999. 

  1000. // --------------------------------------------------------------------------------------------------------------------

  1001. 

  1002. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1003. {

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

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

  1006.     return 0;

  1007. }

  1008. 

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

  1010. {

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

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

  1013.     return false;

  1014. }

  1015. 

  1016. void jackbridge_midi_clear_buffer(void* port_buffer)

  1017. {

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

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

  1020. }

  1021. 

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

  1023. {

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

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

  1026.     return false;

  1027. }

  1028. 

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

  1030. {

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

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

  1033.     return NULL;

  1034. }

  1035. 

  1036. // --------------------------------------------------------------------------------------------------------------------

  1037. 

  1038. bool jackbridge_release_timebase(jack_client_t* client)

  1039. {

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

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

  1042.     return false;

  1043. }

  1044. 

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

  1046. {

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

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

  1049.     return false;

  1050. }

  1051. 

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

  1053. {

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

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

  1056.     return false;

  1057. }

  1058. 

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

  1060. {

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

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

  1063.     return false;

  1064. }

  1065. 

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

  1067. {

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

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

  1070.     return false;

  1071. }

  1072. 

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

  1074. {

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

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

  1077.     if (pos != NULL)

  1078.     {

  1079.         // invalidate

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

  1081.         pos->unique_1 = 0;

  1082.         pos->unique_2 = 1;

  1083.     }

  1084.     return JackTransportStopped;

  1085. }

  1086. 

  1087. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1088. {

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

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

  1091.     return 0;

  1092. }

  1093. 

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

  1095. {

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

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

  1098.     return false;

  1099. }

  1100. 

  1101. void jackbridge_transport_start(jack_client_t* client)

  1102. {

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

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

  1105. }

  1106. 

  1107. void jackbridge_transport_stop(jack_client_t* client)

  1108. {

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

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

  1111. }

  1112. 

  1113. // --------------------------------------------------------------------------------------------------------------------

  1114. 

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

  1116. {

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

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

  1119.     return false;

  1120. }

  1121. 

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

  1123. {

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

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

  1126.     return false;

  1127. }

  1128. 

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

  1130. {

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

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

  1133. }

  1134. 

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

  1136. {

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

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

  1139.     return false;

  1140. }

  1141. 

  1142. bool jackbridge_get_all_properties(jack_description_t** descs)

  1143. {

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

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

  1146.     return false;

  1147. }

  1148. 

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

  1150. {

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

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

  1153.     return false;

  1154. }

  1155. 

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

  1157. {

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

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

  1160.     return 0;

  1161. }

  1162. 

  1163. bool jackbridge_remove_all_properties(jack_client_t* client)

  1164. {

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

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

  1167.     return false;

  1168. }

  1169. 

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

  1171. {

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

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

  1174.     return false;

  1175. }

  1176. 

  1177. void jackbridge_set_thread_creator(JackThreadCreator creator)

  1178. {

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

  1180.         jackbridge_instance()->set_thread_creator_ptr(creator);

  1181. }

  1182. 

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

  1184. {

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

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

  1187.     return false;

  1188. }

  1189. 

  1190. jack_nframes_t jackbridge_cycle_wait(jack_client_t* client)

  1191. {

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

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

  1194.     return 0;

  1195. }

  1196. 

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

  1198. {

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

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

  1201. }

  1202. 

  1203. jack_nframes_t jackbridge_port_get_latency(jack_port_t* port)

  1204. {

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

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

  1207.     return 0;

  1208. }

  1209. 

  1210. jack_nframes_t jackbridge_frame_time(const jack_client_t* client)

  1211. {

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

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

  1214.     return 0;

  1215. }