falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3100 Commits
17 Branches
166MB
Tree: 4fa392bd3b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4fa392bd3b'
${ noResults }
Carla/source/jackbridge/JackBridge1.cpp

2026 lines
71KB
Raw Blame History 

  1. /*

  2.  * JackBridge (Part 1, JACK functions)

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

  4.  *

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

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

  7.  * permission notice appear in all copies.

  8.  *

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

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

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

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

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

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

  15.  */

  16. 

  17. #include "JackBridge.hpp"

  18. 

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

  20. 

  21. #include "CarlaLibUtils.hpp"

  22. 

  23. // -----------------------------------------------------------------------------

  24. 

  25. extern "C" {

  26. 

  27. typedef void (*JackSymLatencyCallback)(jack_latency_callback_mode_t mode, void* arg);

  28. typedef int  (*JackSymProcessCallback)(jack_nframes_t nframes, void* arg);

  29. typedef void (*JackSymThreadInitCallback)(void* arg);

  30. typedef int  (*JackSymGraphOrderCallback)(void* arg);

  31. typedef int  (*JackSymXRunCallback)(void* arg);

  32. typedef int  (*JackSymBufferSizeCallback)(jack_nframes_t nframes, void* arg);

  33. typedef int  (*JackSymSampleRateCallback)(jack_nframes_t nframes, void* arg);

  34. typedef void (*JackSymPortRegistrationCallback)(jack_port_id_t port, int register_, void* arg);

  35. typedef void (*JackSymClientRegistrationCallback)(const char* name, int register_, void* arg);

  36. typedef void (*JackSymPortConnectCallback)(jack_port_id_t a, jack_port_id_t b, int connect, void* arg);

  37. typedef int  (*JackSymPortRenameCallback)(jack_port_id_t port, const char* old_name, const char* new_name, void* arg); // NOTE: returns void in JACK1, int in JACK2

  38. typedef void (*JackSymFreewheelCallback)(int starting, void* arg);

  39. typedef void (*JackSymShutdownCallback)(void* arg);

  40. typedef void (*JackSymInfoShutdownCallback)(jack_status_t code, const char* reason, void* arg);

  41. typedef int  (*JackSymSyncCallback)(jack_transport_state_t state, jack_position_t* pos, void* arg);

  42. typedef void (*JackSymTimebaseCallback)(jack_transport_state_t state, jack_nframes_t nframes, jack_position_t* pos, int new_pos, void* arg);

  43. typedef void (*JackSymSessionCallback)(jack_session_event_t* event, void* arg);

  44. typedef void (*JackSymPropertyChangeCallback)(jack_uuid_t subject, const char* key, jack_property_change_t change, void* arg);

  45. 

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

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

  48. 

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

  50. typedef const char*    (*jacksym_client_rename)(jack_client_t* client, const char* new_name);

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

  52. 

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

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

  55. 

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

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

  58. 

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

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

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

  62. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  77. 

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

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

  80. 

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

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

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

  84. 

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

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

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

  88. 

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

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

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

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

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

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

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

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

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

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

  99. 

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

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

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

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

  104. 

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

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

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

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

  109. 

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

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

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

  113. 

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

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

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

  117. 

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

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

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

  121. 

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

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

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

  125. 

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

  127. 

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

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

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

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

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

  133. 

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

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

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

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

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

  139. 

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

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

  142. 

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

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

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

  146. 

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

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

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

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

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

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

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

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

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

  156. 

  157. } // extern "C"

  158. 

  159. // -----------------------------------------------------------------------------

  160. 

  161. struct JackBridge {

  162.     lib_t lib;

  163. 

  164.     jacksym_get_version get_version_ptr;

  165.     jacksym_get_version_string get_version_string_ptr;

  166. 

  167.     jacksym_client_open client_open_ptr;

  168.     jacksym_client_rename client_rename_ptr;

  169.     jacksym_client_close client_close_ptr;

  170. 

  171.     jacksym_client_name_size client_name_size_ptr;

  172.     jacksym_get_client_name get_client_name_ptr;

  173. 

  174.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  175.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  176. 

  177.     jacksym_activate activate_ptr;

  178.     jacksym_deactivate deactivate_ptr;

  179.     jacksym_is_realtime is_realtime_ptr;

  180. 

  181.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  182.     jacksym_on_shutdown on_shutdown_ptr;

  183.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  184.     jacksym_set_process_callback set_process_callback_ptr;

  185.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  186.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  187.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  188.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  189.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  190.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  191.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  192.     jacksym_set_graph_order_callback set_graph_order_callback_ptr;

  193.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  194.     jacksym_set_latency_callback set_latency_callback_ptr;

  195. 

  196.     jacksym_set_freewheel set_freewheel_ptr;

  197.     jacksym_set_buffer_size set_buffer_size_ptr;

  198. 

  199.     jacksym_get_sample_rate get_sample_rate_ptr;

  200.     jacksym_get_buffer_size get_buffer_size_ptr;

  201.     jacksym_cpu_load cpu_load_ptr;

  202. 

  203.     jacksym_port_register port_register_ptr;

  204.     jacksym_port_unregister port_unregister_ptr;

  205.     jacksym_port_get_buffer port_get_buffer_ptr;

  206. 

  207.     jacksym_port_name port_name_ptr;

  208.     jacksym_port_uuid port_uuid_ptr;

  209.     jacksym_port_short_name port_short_name_ptr;

  210.     jacksym_port_flags port_flags_ptr;

  211.     jacksym_port_type port_type_ptr;

  212.     jacksym_port_is_mine port_is_mine_ptr;

  213.     jacksym_port_connected port_connected_ptr;

  214.     jacksym_port_connected_to port_connected_to_ptr;

  215.     jacksym_port_get_connections port_get_connections_ptr;

  216.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  217. 

  218.     jacksym_port_set_name port_set_name_ptr;

  219.     jacksym_port_set_alias port_set_alias_ptr;

  220.     jacksym_port_unset_alias port_unset_alias_ptr;

  221.     jacksym_port_get_aliases port_get_aliases_ptr;

  222. 

  223.     jacksym_port_request_monitor port_request_monitor_ptr;

  224.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  225.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  226.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  227. 

  228.     jacksym_connect connect_ptr;

  229.     jacksym_disconnect disconnect_ptr;

  230.     jacksym_port_disconnect port_disconnect_ptr;

  231. 

  232.     jacksym_port_name_size port_name_size_ptr;

  233.     jacksym_port_type_size port_type_size_ptr;

  234.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  235. 

  236.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  237.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  238.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  239. 

  240.     jacksym_get_ports get_ports_ptr;

  241.     jacksym_port_by_name port_by_name_ptr;

  242.     jacksym_port_by_id port_by_id_ptr;

  243. 

  244.     jacksym_free free_ptr;

  245. 

  246.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  247.     jacksym_midi_event_get midi_event_get_ptr;

  248.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  249.     jacksym_midi_event_write midi_event_write_ptr;

  250.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  251. 

  252.     jacksym_release_timebase release_timebase_ptr;

  253.     jacksym_set_sync_callback set_sync_callback_ptr;

  254.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  255.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  256.     jacksym_transport_locate transport_locate_ptr;

  257. 

  258.     jacksym_transport_query transport_query_ptr;

  259.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  260. 

  261.     jacksym_transport_reposition transport_reposition_ptr;

  262.     jacksym_transport_start transport_start_ptr;

  263.     jacksym_transport_stop transport_stop_ptr;

  264. 

  265.     jacksym_set_property set_property_ptr;

  266.     jacksym_get_property get_property_ptr;

  267.     jacksym_free_description free_description_ptr;

  268.     jacksym_get_properties get_properties_ptr;

  269.     jacksym_get_all_properties get_all_properties_ptr;

  270.     jacksym_remove_property remove_property_ptr;

  271.     jacksym_remove_properties remove_properties_ptr;

  272.     jacksym_remove_all_properties remove_all_properties_ptr;

  273.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  274. 

  275.     JackBridge()

  276.         : lib(nullptr),

  277.           get_version_ptr(nullptr),

  278.           get_version_string_ptr(nullptr),

  279.           client_open_ptr(nullptr),

  280.           client_rename_ptr(nullptr),

  281.           client_close_ptr(nullptr),

  282.           client_name_size_ptr(nullptr),

  283.           get_client_name_ptr(nullptr),

  284.           get_uuid_for_client_name_ptr(nullptr),

  285.           get_client_name_by_uuid_ptr(nullptr),

  286.           activate_ptr(nullptr),

  287.           deactivate_ptr(nullptr),

  288.           is_realtime_ptr(nullptr),

  289.           set_thread_init_callback_ptr(nullptr),

  290.           on_shutdown_ptr(nullptr),

  291.           on_info_shutdown_ptr(nullptr),

  292.           set_process_callback_ptr(nullptr),

  293.           set_freewheel_callback_ptr(nullptr),

  294.           set_buffer_size_callback_ptr(nullptr),

  295.           set_sample_rate_callback_ptr(nullptr),

  296.           set_client_registration_callback_ptr(nullptr),

  297.           set_port_registration_callback_ptr(nullptr),

  298.           set_port_rename_callback_ptr(nullptr),

  299.           set_port_connect_callback_ptr(nullptr),

  300.           set_graph_order_callback_ptr(nullptr),

  301.           set_xrun_callback_ptr(nullptr),

  302.           set_latency_callback_ptr(nullptr),

  303.           set_freewheel_ptr(nullptr),

  304.           set_buffer_size_ptr(nullptr),

  305.           get_sample_rate_ptr(nullptr),

  306.           get_buffer_size_ptr(nullptr),

  307.           cpu_load_ptr(nullptr),

  308.           port_register_ptr(nullptr),

  309.           port_unregister_ptr(nullptr),

  310.           port_get_buffer_ptr(nullptr),

  311.           port_name_ptr(nullptr),

  312.           port_uuid_ptr(nullptr),

  313.           port_short_name_ptr(nullptr),

  314.           port_flags_ptr(nullptr),

  315.           port_type_ptr(nullptr),

  316.           port_is_mine_ptr(nullptr),

  317.           port_connected_ptr(nullptr),

  318.           port_connected_to_ptr(nullptr),

  319.           port_get_connections_ptr(nullptr),

  320.           port_get_all_connections_ptr(nullptr),

  321.           port_set_name_ptr(nullptr),

  322.           port_set_alias_ptr(nullptr),

  323.           port_unset_alias_ptr(nullptr),

  324.           port_get_aliases_ptr(nullptr),

  325.           port_request_monitor_ptr(nullptr),

  326.           port_request_monitor_by_name_ptr(nullptr),

  327.           port_ensure_monitor_ptr(nullptr),

  328.           port_monitoring_input_ptr(nullptr),

  329.           connect_ptr(nullptr),

  330.           disconnect_ptr(nullptr),

  331.           port_disconnect_ptr(nullptr),

  332.           port_name_size_ptr(nullptr),

  333.           port_type_size_ptr(nullptr),

  334.           port_type_get_buffer_size_ptr(nullptr),

  335.           port_get_latency_range_ptr(nullptr),

  336.           port_set_latency_range_ptr(nullptr),

  337.           recompute_total_latencies_ptr(nullptr),

  338.           get_ports_ptr(nullptr),

  339.           port_by_name_ptr(nullptr),

  340.           port_by_id_ptr(nullptr),

  341.           free_ptr(nullptr),

  342.           midi_get_event_count_ptr(nullptr),

  343.           midi_event_get_ptr(nullptr),

  344.           midi_clear_buffer_ptr(nullptr),

  345.           midi_event_write_ptr(nullptr),

  346.           midi_event_reserve_ptr(nullptr),

  347.           release_timebase_ptr(nullptr),

  348.           set_sync_callback_ptr(nullptr),

  349.           set_sync_timeout_ptr(nullptr),

  350.           set_timebase_callback_ptr(nullptr),

  351.           transport_locate_ptr(nullptr),

  352.           transport_query_ptr(nullptr),

  353.           get_current_transport_frame_ptr(nullptr),

  354.           transport_reposition_ptr(nullptr),

  355.           transport_start_ptr(nullptr),

  356.           transport_stop_ptr(nullptr),

  357.           set_property_ptr(nullptr),

  358.           get_property_ptr(nullptr),

  359.           free_description_ptr(nullptr),

  360.           get_properties_ptr(nullptr),

  361.           get_all_properties_ptr(nullptr),

  362.           remove_property_ptr(nullptr),

  363.           remove_properties_ptr(nullptr),

  364.           remove_all_properties_ptr(nullptr),

  365.           set_property_change_callback_ptr(nullptr)

  366.     {

  367. # if defined(CARLA_OS_MAC)

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

  369. # elif defined(CARLA_OS_WIN64)

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

  371. # elif defined(CARLA_OS_WIN)

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

  373. # else

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

  375. # endif

  376. 

  377.         lib = lib_open(filename);

  378. 

  379.         if (lib == nullptr)

  380.         {

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

  382.             return;

  383.         }

  384.         else

  385.         {

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

  387.         }

  388. 

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

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

  391. 

  392.         LIB_SYMBOL(get_version)

  393.         LIB_SYMBOL(get_version_string)

  394. 

  395.         LIB_SYMBOL(client_open)

  396.         LIB_SYMBOL(client_rename)

  397.         LIB_SYMBOL(client_close)

  398. 

  399.         LIB_SYMBOL(client_name_size)

  400.         LIB_SYMBOL(get_client_name)

  401. 

  402.         LIB_SYMBOL(get_uuid_for_client_name)

  403.         LIB_SYMBOL(get_client_name_by_uuid)

  404. 

  405.         LIB_SYMBOL(activate)

  406.         LIB_SYMBOL(deactivate)

  407.         LIB_SYMBOL(is_realtime)

  408. 

  409.         LIB_SYMBOL(set_thread_init_callback)

  410.         LIB_SYMBOL(on_shutdown)

  411.         LIB_SYMBOL(on_info_shutdown)

  412.         LIB_SYMBOL(set_process_callback)

  413.         LIB_SYMBOL(set_freewheel_callback)

  414.         LIB_SYMBOL(set_buffer_size_callback)

  415.         LIB_SYMBOL(set_sample_rate_callback)

  416.         LIB_SYMBOL(set_client_registration_callback)

  417.         LIB_SYMBOL(set_port_registration_callback)

  418.         LIB_SYMBOL(set_port_rename_callback)

  419.         LIB_SYMBOL(set_port_connect_callback)

  420.         LIB_SYMBOL(set_graph_order_callback)

  421.         LIB_SYMBOL(set_xrun_callback)

  422.         LIB_SYMBOL(set_latency_callback)

  423. 

  424.         LIB_SYMBOL(set_freewheel)

  425.         LIB_SYMBOL(set_buffer_size)

  426. 

  427.         LIB_SYMBOL(get_sample_rate)

  428.         LIB_SYMBOL(get_buffer_size)

  429.         LIB_SYMBOL(cpu_load)

  430. 

  431.         LIB_SYMBOL(port_register)

  432.         LIB_SYMBOL(port_unregister)

  433.         LIB_SYMBOL(port_get_buffer)

  434. 

  435.         LIB_SYMBOL(port_name)

  436.         LIB_SYMBOL(port_uuid)

  437.         LIB_SYMBOL(port_short_name)

  438.         LIB_SYMBOL(port_flags)

  439.         LIB_SYMBOL(port_type)

  440.         LIB_SYMBOL(port_is_mine)

  441.         LIB_SYMBOL(port_connected)

  442.         LIB_SYMBOL(port_connected_to)

  443.         LIB_SYMBOL(port_get_connections)

  444.         LIB_SYMBOL(port_get_all_connections)

  445. 

  446.         LIB_SYMBOL(port_set_name)

  447.         LIB_SYMBOL(port_set_alias)

  448.         LIB_SYMBOL(port_unset_alias)

  449.         LIB_SYMBOL(port_get_aliases)

  450. 

  451.         LIB_SYMBOL(port_request_monitor)

  452.         LIB_SYMBOL(port_request_monitor_by_name)

  453.         LIB_SYMBOL(port_ensure_monitor)

  454.         LIB_SYMBOL(port_monitoring_input)

  455. 

  456.         LIB_SYMBOL(connect)

  457.         LIB_SYMBOL(disconnect)

  458.         LIB_SYMBOL(port_disconnect)

  459. 

  460.         LIB_SYMBOL(port_name_size)

  461.         LIB_SYMBOL(port_type_size)

  462.         LIB_SYMBOL(port_type_get_buffer_size)

  463. 

  464.         LIB_SYMBOL(port_get_latency_range)

  465.         LIB_SYMBOL(port_set_latency_range)

  466.         LIB_SYMBOL(recompute_total_latencies)

  467. 

  468.         LIB_SYMBOL(get_ports)

  469.         LIB_SYMBOL(port_by_name)

  470.         LIB_SYMBOL(port_by_id)

  471. 

  472.         LIB_SYMBOL(free)

  473. 

  474.         LIB_SYMBOL(midi_get_event_count)

  475.         LIB_SYMBOL(midi_event_get)

  476.         LIB_SYMBOL(midi_clear_buffer)

  477.         LIB_SYMBOL(midi_event_write)

  478.         LIB_SYMBOL(midi_event_reserve)

  479. 

  480.         LIB_SYMBOL(release_timebase)

  481.         LIB_SYMBOL(set_sync_callback)

  482.         LIB_SYMBOL(set_sync_timeout)

  483.         LIB_SYMBOL(set_timebase_callback)

  484.         LIB_SYMBOL(transport_locate)

  485.         LIB_SYMBOL(transport_query)

  486.         LIB_SYMBOL(get_current_transport_frame)

  487.         LIB_SYMBOL(transport_reposition)

  488.         LIB_SYMBOL(transport_start)

  489.         LIB_SYMBOL(transport_stop)

  490. 

  491.         LIB_SYMBOL(set_property)

  492.         LIB_SYMBOL(get_property)

  493.         LIB_SYMBOL(free_description)

  494.         LIB_SYMBOL(get_properties)

  495.         LIB_SYMBOL(get_all_properties)

  496.         LIB_SYMBOL(remove_property)

  497.         LIB_SYMBOL(remove_properties)

  498.         LIB_SYMBOL(remove_all_properties)

  499.         LIB_SYMBOL(set_property_change_callback)

  500. 

  501.         #undef JOIN

  502.         #undef LIB_SYMBOL

  503.     }

  504. 

  505.     ~JackBridge() noexcept

  506.     {

  507.         if (lib != nullptr)

  508.         {

  509.             lib_close(lib);

  510.             lib = nullptr;

  511.         }

  512.     }

  513. 

  514.     CARLA_DECLARE_NON_COPY_STRUCT(JackBridge);

  515. };

  516. 

  517. // -----------------------------------------------------------------------------

  518. 

  519. static const JackBridge& getBridgeInstance() noexcept

  520. {

  521.     static const JackBridge bridge;

  522.     return bridge;

  523. }

  524. 

  525. // -----------------------------------------------------------------------------

  526. 

  527. #ifdef __WINE__

  528. 

  529. struct WineBridge {

  530.     void* ptr;

  531.     JackLatencyCallback latency_cb;

  532.     JackProcessCallback process_cb;

  533.     JackThreadInitCallback thread_init_cb;

  534.     JackGraphOrderCallback graph_order_cb;

  535.     JackXRunCallback xrun_cb;

  536.     JackBufferSizeCallback bufsize_cb;

  537.     JackSampleRateCallback srate_cb;

  538.     JackPortRegistrationCallback port_reg_cb;

  539.     JackClientRegistrationCallback client_reg_cb;

  540.     JackPortConnectCallback port_conn_cb;

  541.     JackPortRenameCallback port_rename_cb;

  542.     JackFreewheelCallback freewheel_cb;

  543.     JackShutdownCallback shutdown_cb;

  544.     JackInfoShutdownCallback info_shutdown_cb;

  545.     JackSyncCallback sync_cb;

  546.     JackTimebaseCallback timebase_cb;

  547.     JackSessionCallback session_cb;

  548.     JackPropertyChangeCallback prop_change_cb;

  549. 

  550.     WineBridge() noexcept

  551.         : ptr(nullptr),

  552.           latency_cb(nullptr),

  553.           process_cb(nullptr),

  554.           thread_init_cb(nullptr),

  555.           graph_order_cb(nullptr),

  556.           xrun_cb(nullptr),

  557.           bufsize_cb(nullptr),

  558.           srate_cb(nullptr),

  559.           port_reg_cb(nullptr),

  560.           client_reg_cb(nullptr),

  561.           port_conn_cb(nullptr),

  562.           port_rename_cb(nullptr),

  563.           freewheel_cb(nullptr),

  564.           shutdown_cb(nullptr),

  565.           info_shutdown_cb(nullptr),

  566.           sync_cb(nullptr),

  567.           timebase_cb(nullptr),

  568.           session_cb(nullptr),

  569.           prop_change_cb(nullptr) {}

  570. 

  571.     static /*const*/ WineBridge& getInstance() noexcept

  572.     {

  573.         static /*const*/ WineBridge bridge;

  574.         return bridge;

  575.     }

  576. 

  577.     void set_ptr(void* p) noexcept { ptr = p; }

  578. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  597. 

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

  599.     {

  600.         return getInstance().latency_cb(mode, getInstance().ptr);

  601.     }

  602. 

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

  604.     {

  605.         return getInstance().process_cb(nframes, getInstance().ptr);

  606.     }

  607. 

  608.     static void thread_init(void* arg)

  609.     {

  610.         return getInstance().thread_init_cb(getInstance().ptr);

  611.     }

  612. 

  613.     static int graph_order(void* arg)

  614.     {

  615.         return getInstance().graph_order_cb(getInstance().ptr);

  616.     }

  617. 

  618.     static int xrun(void* arg)

  619.     {

  620.         return getInstance().xrun_cb(getInstance().ptr);

  621.     }

  622. 

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

  624.     {

  625.         return getInstance().bufsize_cb(nframes, getInstance().ptr);

  626.     }

  627. 

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

  629.     {

  630.         return getInstance().srate_cb(nframes, getInstance().ptr);

  631.     }

  632. 

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

  634.     {

  635.         return getInstance().port_reg_cb(port, register_, getInstance().ptr);

  636.     }

  637. 

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

  639.     {

  640.         return getInstance().client_reg_cb(name, register_, getInstance().ptr);

  641.     }

  642. 

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

  644.     {

  645.         return getInstance().port_conn_cb(a, b, connect, getInstance().ptr);

  646.     }

  647. 

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

  649.     {

  650.         return getInstance().port_rename_cb(port, old_name, new_name, getInstance().ptr);

  651.     }

  652. 

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

  654.     {

  655.         return getInstance().freewheel_cb(starting, getInstance().ptr);

  656.     }

  657. 

  658.     static void shutdown(void* arg)

  659.     {

  660.         return getInstance().shutdown_cb(getInstance().ptr);

  661.     }

  662. 

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

  664.     {

  665.         return getInstance().info_shutdown_cb(code, reason, getInstance().ptr);

  666.     }

  667. 

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

  669.     {

  670.         return getInstance().sync_cb(state, pos, getInstance().ptr);

  671.     }

  672. 

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

  674.     {

  675.         return getInstance().timebase_cb(state, nframes, pos, new_pos, getInstance().ptr);

  676.     }

  677. 

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

  679.     {

  680.         return getInstance().session_cb(event, getInstance().ptr);

  681.     }

  682. 

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

  684.     {

  685.         return getInstance().prop_change_cb(subject, key, change, getInstance().ptr);

  686.     }

  687. 

  688.     CARLA_DECLARE_NON_COPY_STRUCT(WineBridge);

  689. };

  690. 

  691. #endif // __WINE__

  692. 

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

  694. 

  695. // -----------------------------------------------------------------------------

  696. 

  697. bool jackbridge_is_ok() noexcept

  698. {

  699. #if defined(JACKBRIDGE_DUMMY)

  700.     return false;

  701. #elif defined(JACKBRIDGE_DIRECT)

  702.     return true;

  703. #else

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

  705. #endif

  706. }

  707. 

  708. // -----------------------------------------------------------------------------

  709. 

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

  711. {

  712. #if defined(JACKBRIDGE_DUMMY)

  713. #elif defined(JACKBRIDGE_DIRECT)

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

  715. #else

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

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

  718. #endif

  719.     if (major_ptr != nullptr)

  720.         *major_ptr = 0;

  721.     if (minor_ptr != nullptr)

  722.         *minor_ptr = 0;

  723.     if (micro_ptr != nullptr)

  724.         *micro_ptr = 0;

  725.     if (proto_ptr != nullptr)

  726.         *proto_ptr = 0;

  727. }

  728. 

  729. const char* jackbridge_get_version_string()

  730. {

  731. #if defined(JACKBRIDGE_DUMMY)

  732. #elif defined(JACKBRIDGE_DIRECT)

  733.     return jack_get_version_string();

  734. #else

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

  736.         return getBridgeInstance().get_version_string_ptr();

  737. #endif

  738.     return nullptr;

  739. }

  740. 

  741. // -----------------------------------------------------------------------------

  742. 

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

  744. {

  745.     carla_stdout("%s called", __FUNCTION__);

  746. #if defined(JACKBRIDGE_DUMMY)

  747. #elif defined(JACKBRIDGE_DIRECT)

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

  749. #else

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

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

  752. #endif

  753.     if (status != nullptr)

  754.         *status = JackServerError;

  755.     return nullptr;

  756. }

  757. 

  758. bool jackbridge_client_close(jack_client_t* client)

  759. {

  760.     carla_stdout("%s called", __FUNCTION__);

  761. #if defined(JACKBRIDGE_DUMMY)

  762. #elif defined(JACKBRIDGE_DIRECT)

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

  764. #else

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

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

  767. #endif

  768.     return false;

  769. }

  770. 

  771. // -----------------------------------------------------------------------------

  772. 

  773. int jackbridge_client_name_size()

  774. {

  775.     carla_stdout("%s called", __FUNCTION__);

  776. #if defined(JACKBRIDGE_DUMMY)

  777. #elif defined(JACKBRIDGE_DIRECT)

  778.     return jack_client_name_size();

  779. #else

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

  781.         return getBridgeInstance().client_name_size_ptr();

  782. #endif

  783.     return 33;

  784. }

  785. 

  786. char* jackbridge_get_client_name(jack_client_t* client)

  787. {

  788.     carla_stdout("%s called", __FUNCTION__);

  789. #if defined(JACKBRIDGE_DUMMY)

  790. #elif defined(JACKBRIDGE_DIRECT)

  791.     return jack_get_client_name(client);

  792. #else

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

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

  795. #endif

  796.     return nullptr;

  797. }

  798. 

  799. // -----------------------------------------------------------------------------

  800. 

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

  802. {

  803.     carla_stdout("%s called", __FUNCTION__);

  804. #if defined(JACKBRIDGE_DUMMY)

  805. #elif defined(JACKBRIDGE_DIRECT)

  806.     return jack_get_uuid_for_client_name(client, name);

  807. #else

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

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

  810. #endif

  811.     return nullptr;

  812. }

  813. 

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

  815. {

  816.     carla_stdout("%s called", __FUNCTION__);

  817. #if defined(JACKBRIDGE_DUMMY)

  818. #elif defined(JACKBRIDGE_DIRECT)

  819.     return jack_get_client_name_by_uuid(client, uuid);

  820. #else

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

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

  823. #endif

  824.     return nullptr;

  825. }

  826. 

  827. // -----------------------------------------------------------------------------

  828. 

  829. bool jackbridge_activate(jack_client_t* client)

  830. {

  831.     carla_stdout("%s called", __FUNCTION__);

  832. #if defined(JACKBRIDGE_DUMMY)

  833. #elif defined(JACKBRIDGE_DIRECT)

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

  835. #else

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

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

  838. #endif

  839.     return false;

  840. }

  841. 

  842. bool jackbridge_deactivate(jack_client_t* client)

  843. {

  844.     carla_stdout("%s called", __FUNCTION__);

  845. #if defined(JACKBRIDGE_DUMMY)

  846. #elif defined(JACKBRIDGE_DIRECT)

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

  848. #else

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

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

  851. #endif

  852.     return false;

  853. }

  854. 

  855. bool jackbridge_is_realtime(jack_client_t* client)

  856. {

  857.     carla_stdout("%s called", __FUNCTION__);

  858. #if defined(JACKBRIDGE_DUMMY)

  859. #elif defined(JACKBRIDGE_DIRECT)

  860.     return jack_is_realtime(client);

  861. #else

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

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

  864. #endif

  865.     return false;

  866. }

  867. 

  868. // -----------------------------------------------------------------------------

  869. 

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

  871. {

  872.     carla_stdout("%s called", __FUNCTION__);

  873. #if defined(JACKBRIDGE_DUMMY)

  874. #elif defined(JACKBRIDGE_DIRECT)

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

  876. #else

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

  878.     {

  879. # ifdef __WINE__

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

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

  882. # else

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

  884. # endif

  885.     }

  886. #endif

  887.     return false;

  888. }

  889. 

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

  891. {

  892.     carla_stdout("%s called", __FUNCTION__);

  893. #if defined(JACKBRIDGE_DUMMY)

  894. #elif defined(JACKBRIDGE_DIRECT)

  895.     jack_on_shutdown(client, shutdown_callback, arg);

  896. #else

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

  898.     {

  899. # ifdef __WINE__

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

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

  902. # else

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

  904. # endif

  905.     }

  906. #endif

  907. }

  908. 

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

  910. {

  911.     carla_stdout("%s called", __FUNCTION__);

  912. #if defined(JACKBRIDGE_DUMMY)

  913. #elif defined(JACKBRIDGE_DIRECT)

  914.     jack_on_info_shutdown(client, shutdown_callback, arg);

  915. #else

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

  917.     {

  918. # ifdef __WINE__

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

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

  921. # else

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

  923. # endif

  924.     }

  925. #endif

  926. }

  927. 

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

  929. {

  930.     carla_stdout("%s called", __FUNCTION__);

  931. #if defined(JACKBRIDGE_DUMMY)

  932. #elif defined(JACKBRIDGE_DIRECT)

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

  934. #else

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

  936.     {

  937. # ifdef __WINE__

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

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

  940. # else

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

  942. # endif

  943.     }

  944. #endif

  945.     return false;

  946. }

  947. 

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

  949. {

  950.     carla_stdout("%s called", __FUNCTION__);

  951. #if defined(JACKBRIDGE_DUMMY)

  952. #elif defined(JACKBRIDGE_DIRECT)

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

  954. #else

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

  956.     {

  957. # ifdef __WINE__

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

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

  960. # else

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

  962. # endif

  963.     }

  964. #endif

  965.     return false;

  966. }

  967. 

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

  969. {

  970.     carla_stdout("%s called", __FUNCTION__);

  971. #if defined(JACKBRIDGE_DUMMY)

  972. #elif defined(JACKBRIDGE_DIRECT)

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

  974. #else

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

  976.     {

  977. # ifdef __WINE__

  978.         WineBridge::getInstance().set_ptr(arg);

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

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

  981. # else

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

  983. # endif

  984.     }

  985. #endif

  986.     return false;

  987. }

  988. 

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

  990. {

  991.     carla_stdout("%s called", __FUNCTION__);

  992. #if defined(JACKBRIDGE_DUMMY)

  993. #elif defined(JACKBRIDGE_DIRECT)

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

  995. #else

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

  997.     {

  998. # ifdef __WINE__

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

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

  1001. # else

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

  1003. # endif

  1004.     }

  1005. #endif

  1006.     return false;

  1007. }

  1008. 

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

  1010. {

  1011.     carla_stdout("%s called", __FUNCTION__);

  1012. #if defined(JACKBRIDGE_DUMMY)

  1013. #elif defined(JACKBRIDGE_DIRECT)

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

  1015. #else

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

  1017.     {

  1018. # ifdef __WINE__

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

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

  1021. # else

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

  1023. # endif

  1024.     }

  1025. #endif

  1026.     return false;

  1027. }

  1028. 

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

  1030. {

  1031.     carla_stdout("%s called", __FUNCTION__);

  1032. #if defined(JACKBRIDGE_DUMMY)

  1033. #elif defined(JACKBRIDGE_DIRECT)

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

  1035. #else

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

  1037.     {

  1038. # ifdef __WINE__

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

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

  1041. # else

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

  1043. # endif

  1044.     }

  1045. #endif

  1046.     return false;

  1047. }

  1048. 

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

  1050. {

  1051.     carla_stdout("%s called", __FUNCTION__);

  1052. #if defined(JACKBRIDGE_DUMMY)

  1053. #elif defined(JACKBRIDGE_DIRECT)

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

  1055. #else

  1056.     if (getBridgeInstance().get_version_string_ptr != nullptr) // don't use this on JACK1

  1057.         return false;

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

  1059.     {

  1060. # ifdef __WINE__

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

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

  1063. # else

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

  1065. # endif

  1066.     }

  1067. #endif

  1068.     return false;

  1069. }

  1070. 

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

  1072. {

  1073.     carla_stdout("%s called", __FUNCTION__);

  1074. #if defined(JACKBRIDGE_DUMMY)

  1075. #elif defined(JACKBRIDGE_DIRECT)

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

  1077. #else

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

  1079.     {

  1080. # ifdef __WINE__

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

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

  1083. # else

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

  1085. # endif

  1086.     }

  1087. #endif

  1088.     return false;

  1089. }

  1090. 

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

  1092. {

  1093.     carla_stdout("%s called", __FUNCTION__);

  1094. #if defined(JACKBRIDGE_DUMMY)

  1095. #elif defined(JACKBRIDGE_DIRECT)

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

  1097. #else

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

  1099.     {

  1100. # ifdef __WINE__

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

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

  1103. # else

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

  1105. # endif

  1106.     }

  1107. #endif

  1108.     return false;

  1109. }

  1110. 

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

  1112. {

  1113.     carla_stdout("%s called", __FUNCTION__);

  1114. #if defined(JACKBRIDGE_DUMMY)

  1115. #elif defined(JACKBRIDGE_DIRECT)

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

  1117. #else

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

  1119.     {

  1120. # ifdef __WINE__

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

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

  1123. # else

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

  1125. # endif

  1126.     }

  1127. #endif

  1128.     return false;

  1129. }

  1130. 

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

  1132. {

  1133.     carla_stdout("%s called", __FUNCTION__);

  1134. #if defined(JACKBRIDGE_DUMMY)

  1135. #elif defined(JACKBRIDGE_DIRECT)

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

  1137. #else

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

  1139.     {

  1140. # ifdef __WINE__

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

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

  1143. # else

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

  1145. # endif

  1146.     }

  1147. #endif

  1148.     return false;

  1149. }

  1150. 

  1151. // -----------------------------------------------------------------------------

  1152. 

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

  1154. {

  1155.     carla_stdout("%s called", __FUNCTION__);

  1156. #if defined(JACKBRIDGE_DUMMY)

  1157. #elif defined(JACKBRIDGE_DIRECT)

  1158.     return jack_set_freewheel(client, onoff);

  1159. #else

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

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

  1162. #endif

  1163.     return false;

  1164. }

  1165. 

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

  1167. {

  1168.     carla_stdout("%s called", __FUNCTION__);

  1169. #if defined(JACKBRIDGE_DUMMY)

  1170. #elif defined(JACKBRIDGE_DIRECT)

  1171.     return jack_set_buffer_size(client, nframes);

  1172. #else

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

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

  1175. #endif

  1176.     return false;

  1177. }

  1178. 

  1179. // -----------------------------------------------------------------------------

  1180. 

  1181. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  1182. {

  1183.     carla_stdout("%s called", __FUNCTION__);

  1184. #if defined(JACKBRIDGE_DUMMY)

  1185. #elif defined(JACKBRIDGE_DIRECT)

  1186.     return jack_get_sample_rate(client);

  1187. #else

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

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

  1190. #endif

  1191.     return 0;

  1192. }

  1193. 

  1194. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  1195. {

  1196.     carla_stdout("%s called", __FUNCTION__);

  1197. #if defined(JACKBRIDGE_DUMMY)

  1198. #elif defined(JACKBRIDGE_DIRECT)

  1199.     return jack_get_buffer_size(client);

  1200. #else

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

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

  1203. #endif

  1204.     return 0;

  1205. }

  1206. 

  1207. float jackbridge_cpu_load(jack_client_t* client)

  1208. {

  1209.     carla_stdout("%s called", __FUNCTION__);

  1210. #if defined(JACKBRIDGE_DUMMY)

  1211. #elif defined(JACKBRIDGE_DIRECT)

  1212.     return jack_cpu_load(client);

  1213. #else

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

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

  1216. #endif

  1217.     return 0.0f;

  1218. }

  1219. 

  1220. // -----------------------------------------------------------------------------

  1221. 

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

  1223. {

  1224.     carla_stdout("%s called", __FUNCTION__);

  1225. #if defined(JACKBRIDGE_DUMMY)

  1226. #elif defined(JACKBRIDGE_DIRECT)

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

  1228. #else

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

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

  1231. #endif

  1232.     return nullptr;

  1233. }

  1234. 

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

  1236. {

  1237.     carla_stdout("%s called", __FUNCTION__);

  1238. #if defined(JACKBRIDGE_DUMMY)

  1239. #elif defined(JACKBRIDGE_DIRECT)

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

  1241. #else

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

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

  1244. #endif

  1245.     return false;

  1246. }

  1247. 

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

  1249. {

  1250.     carla_stdout("%s called", __FUNCTION__);

  1251. #if defined(JACKBRIDGE_DUMMY)

  1252. #elif defined(JACKBRIDGE_DIRECT)

  1253.     return jack_port_get_buffer(port, nframes);

  1254. #else

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

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

  1257. #endif

  1258.     return nullptr;

  1259. }

  1260. 

  1261. // -----------------------------------------------------------------------------

  1262. 

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

  1264. {

  1265.     carla_stdout("%s called", __FUNCTION__);

  1266. #if defined(JACKBRIDGE_DUMMY)

  1267. #elif defined(JACKBRIDGE_DIRECT)

  1268.     return jack_port_name(port);

  1269. #else

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

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

  1272. #endif

  1273.     return nullptr;

  1274. }

  1275. 

  1276. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  1277. {

  1278.     carla_stdout("%s called", __FUNCTION__);

  1279. #if defined(JACKBRIDGE_DUMMY)

  1280. #elif defined(JACKBRIDGE_DIRECT)

  1281.     return jack_port_uuid(port);

  1282. #else

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

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

  1285. #endif

  1286.     return 0;

  1287. }

  1288. 

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

  1290. {

  1291.     carla_stdout("%s called", __FUNCTION__);

  1292. #if defined(JACKBRIDGE_DUMMY)

  1293. #elif defined(JACKBRIDGE_DIRECT)

  1294.     return jack_port_short_name(port);

  1295. #else

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

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

  1298. #endif

  1299.     return nullptr;

  1300. }

  1301. 

  1302. int jackbridge_port_flags(const jack_port_t* port)

  1303. {

  1304.     carla_stdout("%s called", __FUNCTION__);

  1305. #if defined(JACKBRIDGE_DUMMY)

  1306. #elif defined(JACKBRIDGE_DIRECT)

  1307.     return jack_port_flags(port);

  1308. #else

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

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

  1311. #endif

  1312.     return 0x0;

  1313. }

  1314. 

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

  1316. {

  1317.     carla_stdout("%s called", __FUNCTION__);

  1318. #if defined(JACKBRIDGE_DUMMY)

  1319. #elif defined(JACKBRIDGE_DIRECT)

  1320.     return jack_port_type(port);

  1321. #else

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

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

  1324. #endif

  1325.     return nullptr;

  1326. }

  1327. 

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

  1329. {

  1330.     carla_stdout("%s called", __FUNCTION__);

  1331. #if defined(JACKBRIDGE_DUMMY)

  1332. #elif defined(JACKBRIDGE_DIRECT)

  1333.     return jack_port_is_mine(client, port);

  1334. #else

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

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

  1337. #endif

  1338.     return false;

  1339. }

  1340. 

  1341. int jackbridge_port_connected(const jack_port_t* port)

  1342. {

  1343.     carla_stdout("%s called", __FUNCTION__);

  1344. #if defined(JACKBRIDGE_DUMMY)

  1345. #elif defined(JACKBRIDGE_DIRECT)

  1346.     return jack_port_connected(port);

  1347. #else

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

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

  1350. #endif

  1351.     return 0;

  1352. }

  1353. 

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

  1355. {

  1356.     carla_stdout("%s called", __FUNCTION__);

  1357. #if defined(JACKBRIDGE_DUMMY)

  1358. #elif defined(JACKBRIDGE_DIRECT)

  1359.     return jack_port_connected_to(port, port_name);

  1360. #else

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

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

  1363. #endif

  1364.     return false;

  1365. }

  1366. 

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

  1368. {

  1369.     carla_stdout("%s called", __FUNCTION__);

  1370. #if defined(JACKBRIDGE_DUMMY)

  1371. #elif defined(JACKBRIDGE_DIRECT)

  1372.     return jack_port_get_connections(port);

  1373. #else

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

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

  1376. #endif

  1377.     return nullptr;

  1378. }

  1379. 

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

  1381. {

  1382.     carla_stdout("%s called", __FUNCTION__);

  1383. #if defined(JACKBRIDGE_DUMMY)

  1384. #elif defined(JACKBRIDGE_DIRECT)

  1385.     return jack_port_get_all_connections(client, port);

  1386. #else

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

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

  1389. #endif

  1390.     return nullptr;

  1391. }

  1392. 

  1393. // -----------------------------------------------------------------------------

  1394. 

  1395. bool jackbridge_port_set_name(jack_port_t* port, const char* port_name)

  1396. {

  1397.     carla_stdout("%s called", __FUNCTION__);

  1398. #if defined(JACKBRIDGE_DUMMY)

  1399. #elif defined(JACKBRIDGE_DIRECT)

  1400.     return (jack_port_set_name(port, port_name) == 0);

  1401. #else

  1402.     if (getBridgeInstance().get_version_string_ptr != nullptr) // don't use this on JACK1

  1403.         return false;

  1404.     if (getBridgeInstance().port_set_name_ptr != nullptr)

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

  1406. #endif

  1407.     return false;

  1408. }

  1409. 

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

  1411. {

  1412.     carla_stdout("%s called", __FUNCTION__);

  1413. #if defined(JACKBRIDGE_DUMMY)

  1414. #elif defined(JACKBRIDGE_DIRECT)

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

  1416. #else

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

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

  1419. #endif

  1420.     return false;

  1421. }

  1422. 

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

  1424. {

  1425.     carla_stdout("%s called", __FUNCTION__);

  1426. #if defined(JACKBRIDGE_DUMMY)

  1427. #elif defined(JACKBRIDGE_DIRECT)

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

  1429. #else

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

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

  1432. #endif

  1433.     return false;

  1434. }

  1435. 

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

  1437. {

  1438.     carla_stdout("%s called", __FUNCTION__);

  1439. #if defined(JACKBRIDGE_DUMMY)

  1440. #elif defined(JACKBRIDGE_DIRECT)

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

  1442. #else

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

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

  1445. #endif

  1446.     return 0;

  1447. }

  1448. 

  1449. // -----------------------------------------------------------------------------

  1450. 

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

  1452. {

  1453.     carla_stdout("%s called", __FUNCTION__);

  1454. #if defined(JACKBRIDGE_DUMMY)

  1455. #elif defined(JACKBRIDGE_DIRECT)

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

  1457. #else

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

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

  1460. #endif

  1461.     return false;

  1462. }

  1463. 

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

  1465. {

  1466.     carla_stdout("%s called", __FUNCTION__);

  1467. #if defined(JACKBRIDGE_DUMMY)

  1468. #elif defined(JACKBRIDGE_DIRECT)

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

  1470. #else

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

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

  1473. #endif

  1474.     return false;

  1475. }

  1476. 

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

  1478. {

  1479.     carla_stdout("%s called", __FUNCTION__);

  1480. #if defined(JACKBRIDGE_DUMMY)

  1481. #elif defined(JACKBRIDGE_DIRECT)

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

  1483. #else

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

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

  1486. #endif

  1487.     return false;

  1488. }

  1489. 

  1490. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1491. {

  1492.     carla_stdout("%s called", __FUNCTION__);

  1493. #if defined(JACKBRIDGE_DUMMY)

  1494. #elif defined(JACKBRIDGE_DIRECT)

  1495.     return jack_port_monitoring_input(port);

  1496. #else

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

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

  1499. #endif

  1500.     return false;

  1501. }

  1502. 

  1503. // -----------------------------------------------------------------------------

  1504. 

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

  1506. {

  1507.     carla_stdout("%s called", __FUNCTION__);

  1508. #if defined(JACKBRIDGE_DUMMY)

  1509. #elif defined(JACKBRIDGE_DIRECT)

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

  1511. #else

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

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

  1514. #endif

  1515.     return false;

  1516. }

  1517. 

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

  1519. {

  1520.     carla_stdout("%s called", __FUNCTION__);

  1521. #if defined(JACKBRIDGE_DUMMY)

  1522. #elif defined(JACKBRIDGE_DIRECT)

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

  1524. #else

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

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

  1527. #endif

  1528.     return false;

  1529. }

  1530. 

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

  1532. {

  1533.     carla_stdout("%s called", __FUNCTION__);

  1534. #if defined(JACKBRIDGE_DUMMY)

  1535. #elif defined(JACKBRIDGE_DIRECT)

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

  1537. #else

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

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

  1540. #endif

  1541.     return false;

  1542. }

  1543. 

  1544. // -----------------------------------------------------------------------------

  1545. 

  1546. int jackbridge_port_name_size()

  1547. {

  1548.     carla_stdout("%s called", __FUNCTION__);

  1549. #if defined(JACKBRIDGE_DUMMY)

  1550. #elif defined(JACKBRIDGE_DIRECT)

  1551.     return jack_port_name_size();

  1552. #else

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

  1554.         return getBridgeInstance().port_name_size_ptr();

  1555. #endif

  1556.     return 256;

  1557. }

  1558. 

  1559. int jackbridge_port_type_size()

  1560. {

  1561.     carla_stdout("%s called", __FUNCTION__);

  1562. #if defined(JACKBRIDGE_DUMMY)

  1563. #elif defined(JACKBRIDGE_DIRECT)

  1564.     return jack_port_type_size();

  1565. #else

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

  1567.         return getBridgeInstance().port_type_size_ptr();

  1568. #endif

  1569.     return 32;

  1570. }

  1571. 

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

  1573. {

  1574.     carla_stdout("%s called", __FUNCTION__);

  1575. #if defined(JACKBRIDGE_DUMMY)

  1576. #elif defined(JACKBRIDGE_DIRECT)

  1577.     return jack_port_type_get_buffer_size(client, port_type);

  1578. #else

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

  1580.         return getBridgeInstance().port_type_get_buffer_size_ptr(client, port_type);

  1581. #endif

  1582.     return 0;

  1583. }

  1584. 

  1585. // -----------------------------------------------------------------------------

  1586. 

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

  1588. {

  1589.     carla_stdout("%s called", __FUNCTION__);

  1590. #if defined(JACKBRIDGE_DUMMY)

  1591. #elif defined(JACKBRIDGE_DIRECT)

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

  1593. #else

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

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

  1596. #endif

  1597.     range->min = 0;

  1598.     range->max = 0;

  1599. }

  1600. 

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

  1602. {

  1603.     carla_stdout("%s called", __FUNCTION__);

  1604. #if defined(JACKBRIDGE_DUMMY)

  1605. #elif defined(JACKBRIDGE_DIRECT)

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

  1607. #else

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

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

  1610. #endif

  1611. }

  1612. 

  1613. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1614. {

  1615.     carla_stdout("%s called", __FUNCTION__);

  1616. #if defined(JACKBRIDGE_DUMMY)

  1617. #elif defined(JACKBRIDGE_DIRECT)

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

  1619. #else

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

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

  1622. #endif

  1623.     return false;

  1624. }

  1625. 

  1626. // -----------------------------------------------------------------------------

  1627. 

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

  1629. {

  1630.     carla_stdout("%s called", __FUNCTION__);

  1631. #if defined(JACKBRIDGE_DUMMY)

  1632. #elif defined(JACKBRIDGE_DIRECT)

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

  1634. #else

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

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

  1637. #endif

  1638.     return nullptr;

  1639. }

  1640. 

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

  1642. {

  1643.     carla_stdout("%s called", __FUNCTION__);

  1644. #if defined(JACKBRIDGE_DUMMY)

  1645. #elif defined(JACKBRIDGE_DIRECT)

  1646.     return jack_port_by_name(client, port_name);

  1647. #else

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

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

  1650. #endif

  1651.     return nullptr;

  1652. }

  1653. 

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

  1655. {

  1656.     carla_stdout("%s called", __FUNCTION__);

  1657. #if defined(JACKBRIDGE_DUMMY)

  1658. #elif defined(JACKBRIDGE_DIRECT)

  1659.     return jack_port_by_id(client, port_id);

  1660. #else

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

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

  1663. #endif

  1664.     return nullptr;

  1665. }

  1666. 

  1667. // -----------------------------------------------------------------------------

  1668. 

  1669. void jackbridge_free(void* ptr)

  1670. {

  1671.     carla_stdout("%s called", __FUNCTION__);

  1672. #if defined(JACKBRIDGE_DUMMY)

  1673. #elif defined(JACKBRIDGE_DIRECT)

  1674.     return jack_free(ptr);

  1675. #else

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

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

  1678. 

  1679.     // just in case

  1680.     std::free(ptr);

  1681. #endif

  1682. }

  1683. 

  1684. // -----------------------------------------------------------------------------

  1685. 

  1686. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1687. {

  1688.     carla_stdout("%s called", __FUNCTION__);

  1689. #if defined(JACKBRIDGE_DUMMY)

  1690. #elif defined(JACKBRIDGE_DIRECT)

  1691.     return jack_midi_get_event_count(port_buffer);

  1692. #else

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

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

  1695. #endif

  1696.     return 0;

  1697. }

  1698. 

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

  1700. {

  1701.     carla_stdout("%s called", __FUNCTION__);

  1702. #if defined(JACKBRIDGE_DUMMY)

  1703. #elif defined(JACKBRIDGE_DIRECT)

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

  1705. #else

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

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

  1708. #endif

  1709.     return false;

  1710. }

  1711. 

  1712. void jackbridge_midi_clear_buffer(void* port_buffer)

  1713. {

  1714.     carla_stdout("%s called", __FUNCTION__);

  1715. #if defined(JACKBRIDGE_DUMMY)

  1716. #elif defined(JACKBRIDGE_DIRECT)

  1717.     jack_midi_clear_buffer(port_buffer);

  1718. #else

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

  1720.         getBridgeInstance().midi_clear_buffer_ptr(port_buffer);

  1721. #endif

  1722. }

  1723. 

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

  1725. {

  1726.     carla_stdout("%s called", __FUNCTION__);

  1727. #if defined(JACKBRIDGE_DUMMY)

  1728. #elif defined(JACKBRIDGE_DIRECT)

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

  1730. #else

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

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

  1733. #endif

  1734.     return false;

  1735. }

  1736. 

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

  1738. {

  1739.     carla_stdout("%s called", __FUNCTION__);

  1740. #if defined(JACKBRIDGE_DUMMY)

  1741. #elif defined(JACKBRIDGE_DIRECT)

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

  1743. #else

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

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

  1746. #endif

  1747.     return nullptr;

  1748. }

  1749. 

  1750. // -----------------------------------------------------------------------------

  1751. 

  1752. bool jackbridge_release_timebase(jack_client_t* client)

  1753. {

  1754.     carla_stdout("%s called", __FUNCTION__);

  1755. #if defined(JACKBRIDGE_DUMMY)

  1756. #elif defined(JACKBRIDGE_DIRECT)

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

  1758. #else

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

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

  1761. #endif

  1762.     return false;

  1763. }

  1764. 

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

  1766. {

  1767.     carla_stdout("%s called", __FUNCTION__);

  1768. #if defined(JACKBRIDGE_DUMMY)

  1769. #elif defined(JACKBRIDGE_DIRECT)

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

  1771. #else

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

  1773.     {

  1774. # ifdef __WINE__

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

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

  1777. # else

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

  1779. # endif

  1780.     }

  1781. #endif

  1782.     return false;

  1783. }

  1784. 

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

  1786. {

  1787.     carla_stdout("%s called", __FUNCTION__);

  1788. #if defined(JACKBRIDGE_DUMMY)

  1789. #elif defined(JACKBRIDGE_DIRECT)

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

  1791. #else

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

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

  1794. #endif

  1795.     return false;

  1796. }

  1797. 

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

  1799. {

  1800.     carla_stdout("%s called", __FUNCTION__);

  1801. #if defined(JACKBRIDGE_DUMMY)

  1802. #elif defined(JACKBRIDGE_DIRECT)

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

  1804. #else

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

  1806.     {

  1807. # ifdef __WINE__

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

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

  1810. # else

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

  1812. # endif

  1813.     }

  1814. #endif

  1815.     return false;

  1816. }

  1817. 

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

  1819. {

  1820.     carla_stdout("%s called", __FUNCTION__);

  1821. #if defined(JACKBRIDGE_DUMMY)

  1822. #elif defined(JACKBRIDGE_DIRECT)

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

  1824. #else

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

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

  1827. #endif

  1828.     return false;

  1829. }

  1830. 

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

  1832. {

  1833.     carla_stdout("%s called", __FUNCTION__);

  1834. #if defined(JACKBRIDGE_DUMMY)

  1835. #elif defined(JACKBRIDGE_DIRECT)

  1836.     return jack_transport_query(client, pos);

  1837. #else

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

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

  1840. #endif

  1841.     if (pos != nullptr)

  1842.     {

  1843.         // invalidate

  1844.         pos->unique_1 = 0;

  1845.         pos->unique_2 = 1;

  1846.     }

  1847.     return JackTransportStopped;

  1848. }

  1849. 

  1850. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1851. {

  1852.     carla_stdout("%s called", __FUNCTION__);

  1853. #if defined(JACKBRIDGE_DUMMY)

  1854. #elif defined(JACKBRIDGE_DIRECT)

  1855.     return jack_get_current_transport_frame(client);

  1856. #else

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

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

  1859. #endif

  1860.     return 0;

  1861. }

  1862. 

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

  1864. {

  1865.     carla_stdout("%s called", __FUNCTION__);

  1866. #if defined(JACKBRIDGE_DUMMY)

  1867. #elif defined(JACKBRIDGE_DIRECT)

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

  1869. #else

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

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

  1872. #endif

  1873.     return false;

  1874. }

  1875. 

  1876. void jackbridge_transport_start(jack_client_t* client)

  1877. {

  1878.     carla_stdout("%s called", __FUNCTION__);

  1879. #if defined(JACKBRIDGE_DUMMY)

  1880. #elif defined(JACKBRIDGE_DIRECT)

  1881.     jack_transport_start(client);

  1882. #else

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

  1884.         getBridgeInstance().transport_start_ptr(client);

  1885. #endif

  1886. }

  1887. 

  1888. void jackbridge_transport_stop(jack_client_t* client)

  1889. {

  1890.     carla_stdout("%s called", __FUNCTION__);

  1891. #if defined(JACKBRIDGE_DUMMY)

  1892. #elif defined(JACKBRIDGE_DIRECT)

  1893.     jack_transport_stop(client);

  1894. #else

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

  1896.         getBridgeInstance().transport_stop_ptr(client);

  1897. #endif

  1898. }

  1899. 

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

  1901. 

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

  1903. {

  1904.     carla_stdout("%s called", __FUNCTION__);

  1905. #if defined(JACKBRIDGE_DUMMY)

  1906. #elif defined(JACKBRIDGE_DIRECT)

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

  1908. #else

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

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

  1911. #endif

  1912.     return false;

  1913. }

  1914. 

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

  1916. {

  1917.     carla_stdout("%s called", __FUNCTION__);

  1918. #if defined(JACKBRIDGE_DUMMY)

  1919. #elif defined(JACKBRIDGE_DIRECT)

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

  1921. #else

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

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

  1924. #endif

  1925.     return false;

  1926. }

  1927. 

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

  1929. {

  1930.     carla_stdout("%s called", __FUNCTION__);

  1931. #if defined(JACKBRIDGE_DUMMY)

  1932. #elif defined(JACKBRIDGE_DIRECT)

  1933.     jack_free_description(desc, free_description_itself);

  1934. #else

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

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

  1937. #endif

  1938. }

  1939. 

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

  1941. {

  1942.     carla_stdout("%s called", __FUNCTION__);

  1943. #if defined(JACKBRIDGE_DUMMY)

  1944. #elif defined(JACKBRIDGE_DIRECT)

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

  1946. #else

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

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

  1949. #endif

  1950.     return false;

  1951. }

  1952. 

  1953. bool jackbridge_get_all_properties(jack_description_t** descs)

  1954. {

  1955.     carla_stdout("%s called", __FUNCTION__);

  1956. #if defined(JACKBRIDGE_DUMMY)

  1957. #elif defined(JACKBRIDGE_DIRECT)

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

  1959. #else

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

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

  1962. #endif

  1963.     return false;

  1964. }

  1965. 

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

  1967. {

  1968.     carla_stdout("%s called", __FUNCTION__);

  1969. #if defined(JACKBRIDGE_DUMMY)

  1970. #elif defined(JACKBRIDGE_DIRECT)

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

  1972. #else

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

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

  1975. #endif

  1976.     return false;

  1977. }

  1978. 

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

  1980. {

  1981.     carla_stdout("%s called", __FUNCTION__);

  1982. #if defined(JACKBRIDGE_DUMMY)

  1983. #elif defined(JACKBRIDGE_DIRECT)

  1984.     return jack_remove_properties(client, subject);

  1985. #else

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

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

  1988. #endif

  1989.     return 0;

  1990. }

  1991. 

  1992. bool jackbridge_remove_all_properties(jack_client_t* client)

  1993. {

  1994.     carla_stdout("%s called", __FUNCTION__);

  1995. #if defined(JACKBRIDGE_DUMMY)

  1996. #elif defined(JACKBRIDGE_DIRECT)

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

  1998. #else

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

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

  2001. #endif

  2002.     return false;

  2003. }

  2004. 

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

  2006. {

  2007.     carla_stdout("%s called", __FUNCTION__);

  2008. #if defined(JACKBRIDGE_DUMMY)

  2009. #elif defined(JACKBRIDGE_DIRECT)

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

  2011. #else

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

  2013.     {

  2014. # ifdef __WINE__

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

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

  2017. # else

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

  2019. # endif

  2020.     }

  2021. #endif

  2022.     return false;

  2023. }

  2024. 

  2025. // -----------------------------------------------------------------------------