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

1600 lines
52KB
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. typedef void        (*jacksym_get_version)(int*, int*, int*, int*);

  26. typedef const char* (*jacksym_get_version_string)();

  27. 

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

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

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

  31. 

  32. typedef int   (*jacksym_client_name_size)();

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

  34. 

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

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

  37. 

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

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

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

  41. 

  42. typedef int  (*jacksym_set_thread_init_callback)(jack_client_t*, JackThreadInitCallback, void*);

  43. typedef void (*jacksym_on_shutdown)(jack_client_t*, JackShutdownCallback, void*);

  44. typedef void (*jacksym_on_info_shutdown)(jack_client_t*, JackInfoShutdownCallback, void*);

  45. typedef int  (*jacksym_set_process_callback)(jack_client_t*, JackProcessCallback, void*);

  46. typedef int  (*jacksym_set_freewheel_callback)(jack_client_t*, JackFreewheelCallback, void*);

  47. typedef int  (*jacksym_set_buffer_size_callback)(jack_client_t*, JackBufferSizeCallback, void*);

  48. typedef int  (*jacksym_set_sample_rate_callback)(jack_client_t*, JackSampleRateCallback, void*);

  49. typedef int  (*jacksym_set_client_registration_callback)(jack_client_t*, JackClientRegistrationCallback, void*);

  50. typedef int  (*jacksym_set_port_registration_callback)(jack_client_t*, JackPortRegistrationCallback, void*);

  51. typedef int  (*jacksym_set_port_rename_callback)(jack_client_t*, JackPortRenameCallback, void*);

  52. typedef int  (*jacksym_set_port_connect_callback)(jack_client_t*, JackPortConnectCallback, void*);

  53. typedef int  (*jacksym_set_graph_order_callback)(jack_client_t*, JackGraphOrderCallback, void*);

  54. typedef int  (*jacksym_set_xrun_callback)(jack_client_t*, JackXRunCallback, void*);

  55. typedef int  (*jacksym_set_latency_callback)(jack_client_t*, JackLatencyCallback, void*);

  56. 

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

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

  59. 

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

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

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

  63. 

  64. typedef jack_port_t* (*jacksym_port_register)(jack_client_t*, const char*, const char*, unsigned long, unsigned long);

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

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

  67. 

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

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

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

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

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

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

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

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

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

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

  78. 

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

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

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

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

  83. 

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

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

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

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

  88. 

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

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

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

  92. 

  93. typedef int    (*jacksym_port_name_size)();

  94. typedef int    (*jacksym_port_type_size)();

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

  96. 

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

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

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

  100. 

  101. typedef const char** (*jacksym_get_ports)(jack_client_t*, const char*, const char*, unsigned long);

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

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

  104. 

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

  106. 

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

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

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

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

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

  112. 

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

  114. typedef int (*jacksym_set_sync_callback)(jack_client_t*, JackSyncCallback, void*);

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

  116. typedef int (*jacksym_set_timebase_callback)(jack_client_t*, int, JackTimebaseCallback, void*);

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

  118. 

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

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

  121. 

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

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

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

  125. 

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

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

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

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

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

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

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

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

  134. typedef int  (*jacksym_set_property_change_callback)(jack_client_t*, JackPropertyChangeCallback, void*);

  135. 

  136. // -----------------------------------------------------------------------------

  137. 

  138. struct JackBridge {

  139.     void* lib;

  140. 

  141.     jacksym_get_version get_version_ptr;

  142.     jacksym_get_version_string get_version_string_ptr;

  143. 

  144.     jacksym_client_open client_open_ptr;

  145.     jacksym_client_rename client_rename_ptr;

  146.     jacksym_client_close client_close_ptr;

  147. 

  148.     jacksym_client_name_size client_name_size_ptr;

  149.     jacksym_get_client_name get_client_name_ptr;

  150. 

  151.     jacksym_get_uuid_for_client_name get_uuid_for_client_name_ptr;

  152.     jacksym_get_client_name_by_uuid get_client_name_by_uuid_ptr;

  153. 

  154.     jacksym_activate activate_ptr;

  155.     jacksym_deactivate deactivate_ptr;

  156.     jacksym_is_realtime is_realtime_ptr;

  157. 

  158.     jacksym_set_thread_init_callback set_thread_init_callback_ptr;

  159.     jacksym_on_shutdown on_shutdown_ptr;

  160.     jacksym_on_info_shutdown on_info_shutdown_ptr;

  161.     jacksym_set_process_callback set_process_callback_ptr;

  162.     jacksym_set_freewheel_callback set_freewheel_callback_ptr;

  163.     jacksym_set_buffer_size_callback set_buffer_size_callback_ptr;

  164.     jacksym_set_sample_rate_callback set_sample_rate_callback_ptr;

  165.     jacksym_set_client_registration_callback set_client_registration_callback_ptr;

  166.     jacksym_set_port_registration_callback set_port_registration_callback_ptr;

  167.     jacksym_set_port_rename_callback set_port_rename_callback_ptr;

  168.     jacksym_set_port_connect_callback set_port_connect_callback_ptr;

  169.     jacksym_set_xrun_callback set_xrun_callback_ptr;

  170.     jacksym_set_latency_callback set_latency_callback_ptr;

  171. 

  172.     jacksym_set_freewheel set_freewheel_ptr;

  173.     jacksym_set_buffer_size set_buffer_size_ptr;

  174. 

  175.     jacksym_get_sample_rate get_sample_rate_ptr;

  176.     jacksym_get_buffer_size get_buffer_size_ptr;

  177.     jacksym_cpu_load cpu_load_ptr;

  178. 

  179.     jacksym_port_register port_register_ptr;

  180.     jacksym_port_unregister port_unregister_ptr;

  181.     jacksym_port_get_buffer port_get_buffer_ptr;

  182. 

  183.     jacksym_port_name port_name_ptr;

  184.     jacksym_port_uuid port_uuid_ptr;

  185.     jacksym_port_short_name port_short_name_ptr;

  186.     jacksym_port_flags port_flags_ptr;

  187.     jacksym_port_type port_type_ptr;

  188.     jacksym_port_is_mine port_is_mine_ptr;

  189.     jacksym_port_connected port_connected_ptr;

  190.     jacksym_port_connected_to port_connected_to_ptr;

  191.     jacksym_port_get_connections port_get_connections_ptr;

  192.     jacksym_port_get_all_connections port_get_all_connections_ptr;

  193. 

  194.     jacksym_port_set_name port_set_name_ptr;

  195.     jacksym_port_set_alias port_set_alias_ptr;

  196.     jacksym_port_unset_alias port_unset_alias_ptr;

  197.     jacksym_port_get_aliases port_get_aliases_ptr;

  198. 

  199.     jacksym_port_request_monitor port_request_monitor_ptr;

  200.     jacksym_port_request_monitor_by_name port_request_monitor_by_name_ptr;

  201.     jacksym_port_ensure_monitor port_ensure_monitor_ptr;

  202.     jacksym_port_monitoring_input port_monitoring_input_ptr;

  203. 

  204.     jacksym_connect connect_ptr;

  205.     jacksym_disconnect disconnect_ptr;

  206.     jacksym_port_disconnect port_disconnect_ptr;

  207. 

  208.     jacksym_port_name_size port_name_size_ptr;

  209.     jacksym_port_type_size port_type_size_ptr;

  210.     jacksym_port_type_get_buffer_size port_type_get_buffer_size_ptr;

  211. 

  212.     jacksym_port_get_latency_range port_get_latency_range_ptr;

  213.     jacksym_port_set_latency_range port_set_latency_range_ptr;

  214.     jacksym_recompute_total_latencies recompute_total_latencies_ptr;

  215. 

  216.     jacksym_get_ports get_ports_ptr;

  217.     jacksym_port_by_name port_by_name_ptr;

  218.     jacksym_port_by_id port_by_id_ptr;

  219. 

  220.     jacksym_free free_ptr;

  221. 

  222.     jacksym_midi_get_event_count midi_get_event_count_ptr;

  223.     jacksym_midi_event_get midi_event_get_ptr;

  224.     jacksym_midi_clear_buffer midi_clear_buffer_ptr;

  225.     jacksym_midi_event_write midi_event_write_ptr;

  226.     jacksym_midi_event_reserve midi_event_reserve_ptr;

  227. 

  228.     jacksym_release_timebase release_timebase_ptr;

  229.     jacksym_set_sync_callback set_sync_callback_ptr;

  230.     jacksym_set_sync_timeout set_sync_timeout_ptr;

  231.     jacksym_set_timebase_callback set_timebase_callback_ptr;

  232.     jacksym_transport_locate transport_locate_ptr;

  233. 

  234.     jacksym_transport_query transport_query_ptr;

  235.     jacksym_get_current_transport_frame get_current_transport_frame_ptr;

  236. 

  237.     jacksym_transport_reposition transport_reposition_ptr;

  238.     jacksym_transport_start transport_start_ptr;

  239.     jacksym_transport_stop transport_stop_ptr;

  240. 

  241.     jacksym_set_property set_property_ptr;

  242.     jacksym_get_property get_property_ptr;

  243.     jacksym_free_description free_description_ptr;

  244.     jacksym_get_properties get_properties_ptr;

  245.     jacksym_get_all_properties get_all_properties_ptr;

  246.     jacksym_remove_property remove_property_ptr;

  247.     jacksym_remove_properties remove_properties_ptr;

  248.     jacksym_remove_all_properties remove_all_properties_ptr;

  249.     jacksym_set_property_change_callback set_property_change_callback_ptr;

  250. 

  251.     JackBridge()

  252.         : lib(nullptr),

  253.           get_version_ptr(nullptr),

  254.           get_version_string_ptr(nullptr),

  255.           client_open_ptr(nullptr),

  256.           client_rename_ptr(nullptr),

  257.           client_close_ptr(nullptr),

  258.           client_name_size_ptr(nullptr),

  259.           get_client_name_ptr(nullptr),

  260.           get_uuid_for_client_name_ptr(nullptr),

  261.           get_client_name_by_uuid_ptr(nullptr),

  262.           activate_ptr(nullptr),

  263.           deactivate_ptr(nullptr),

  264.           is_realtime_ptr(nullptr),

  265.           set_thread_init_callback_ptr(nullptr),

  266.           on_shutdown_ptr(nullptr),

  267.           on_info_shutdown_ptr(nullptr),

  268.           set_process_callback_ptr(nullptr),

  269.           set_freewheel_callback_ptr(nullptr),

  270.           set_buffer_size_callback_ptr(nullptr),

  271.           set_sample_rate_callback_ptr(nullptr),

  272.           set_client_registration_callback_ptr(nullptr),

  273.           set_port_registration_callback_ptr(nullptr),

  274.           set_port_rename_callback_ptr(nullptr),

  275.           set_port_connect_callback_ptr(nullptr),

  276.           set_xrun_callback_ptr(nullptr),

  277.           set_latency_callback_ptr(nullptr),

  278.           set_freewheel_ptr(nullptr),

  279.           set_buffer_size_ptr(nullptr),

  280.           get_sample_rate_ptr(nullptr),

  281.           get_buffer_size_ptr(nullptr),

  282.           cpu_load_ptr(nullptr),

  283.           port_register_ptr(nullptr),

  284.           port_unregister_ptr(nullptr),

  285.           port_get_buffer_ptr(nullptr),

  286.           port_name_ptr(nullptr),

  287.           port_uuid_ptr(nullptr),

  288.           port_short_name_ptr(nullptr),

  289.           port_flags_ptr(nullptr),

  290.           port_type_ptr(nullptr),

  291.           port_is_mine_ptr(nullptr),

  292.           port_connected_ptr(nullptr),

  293.           port_connected_to_ptr(nullptr),

  294.           port_get_connections_ptr(nullptr),

  295.           port_get_all_connections_ptr(nullptr),

  296.           port_set_name_ptr(nullptr),

  297.           port_set_alias_ptr(nullptr),

  298.           port_unset_alias_ptr(nullptr),

  299.           port_get_aliases_ptr(nullptr),

  300.           port_request_monitor_ptr(nullptr),

  301.           port_request_monitor_by_name_ptr(nullptr),

  302.           port_ensure_monitor_ptr(nullptr),

  303.           port_monitoring_input_ptr(nullptr),

  304.           connect_ptr(nullptr),

  305.           disconnect_ptr(nullptr),

  306.           port_disconnect_ptr(nullptr),

  307.           port_name_size_ptr(nullptr),

  308.           port_type_size_ptr(nullptr),

  309.           port_type_get_buffer_size_ptr(nullptr),

  310.           port_get_latency_range_ptr(nullptr),

  311.           port_set_latency_range_ptr(nullptr),

  312.           recompute_total_latencies_ptr(nullptr),

  313.           get_ports_ptr(nullptr),

  314.           port_by_name_ptr(nullptr),

  315.           port_by_id_ptr(nullptr),

  316.           free_ptr(nullptr),

  317.           midi_get_event_count_ptr(nullptr),

  318.           midi_event_get_ptr(nullptr),

  319.           midi_clear_buffer_ptr(nullptr),

  320.           midi_event_write_ptr(nullptr),

  321.           midi_event_reserve_ptr(nullptr),

  322.           release_timebase_ptr(nullptr),

  323.           set_sync_callback_ptr(nullptr),

  324.           set_sync_timeout_ptr(nullptr),

  325.           set_timebase_callback_ptr(nullptr),

  326.           transport_locate_ptr(nullptr),

  327.           transport_query_ptr(nullptr),

  328.           get_current_transport_frame_ptr(nullptr),

  329.           transport_reposition_ptr(nullptr),

  330.           transport_start_ptr(nullptr),

  331.           transport_stop_ptr(nullptr),

  332.           set_property_ptr(nullptr),

  333.           get_property_ptr(nullptr),

  334.           free_description_ptr(nullptr),

  335.           get_properties_ptr(nullptr),

  336.           get_all_properties_ptr(nullptr),

  337.           remove_property_ptr(nullptr),

  338.           remove_properties_ptr(nullptr),

  339.           remove_all_properties_ptr(nullptr),

  340.           set_property_change_callback_ptr(nullptr)

  341.     {

  342. # if defined(CARLA_OS_MAC)

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

  344. # elif defined(CARLA_OS_WIN)

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

  346. # else

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

  348. # endif

  349. 

  350.         lib = lib_open(filename);

  351. 

  352.         if (lib == nullptr)

  353.         {

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

  355.             return;

  356.         }

  357.         else

  358.         {

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

  360.         }

  361. 

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

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

  364. 

  365.         LIB_SYMBOL(get_version)

  366.         LIB_SYMBOL(get_version_string)

  367. 

  368.         LIB_SYMBOL(client_open)

  369.         LIB_SYMBOL(client_rename)

  370.         LIB_SYMBOL(client_close)

  371. 

  372.         LIB_SYMBOL(client_name_size)

  373.         LIB_SYMBOL(get_client_name)

  374. 

  375.         LIB_SYMBOL(get_uuid_for_client_name)

  376.         LIB_SYMBOL(get_client_name_by_uuid)

  377. 

  378.         LIB_SYMBOL(activate)

  379.         LIB_SYMBOL(deactivate)

  380.         LIB_SYMBOL(is_realtime)

  381. 

  382.         LIB_SYMBOL(set_thread_init_callback)

  383.         LIB_SYMBOL(on_shutdown)

  384.         LIB_SYMBOL(on_info_shutdown)

  385.         LIB_SYMBOL(set_process_callback)

  386.         LIB_SYMBOL(set_freewheel_callback)

  387.         LIB_SYMBOL(set_buffer_size_callback)

  388.         LIB_SYMBOL(set_sample_rate_callback)

  389.         LIB_SYMBOL(set_client_registration_callback)

  390.         LIB_SYMBOL(set_port_registration_callback)

  391.         LIB_SYMBOL(set_port_rename_callback)

  392.         LIB_SYMBOL(set_port_connect_callback)

  393.         LIB_SYMBOL(set_xrun_callback)

  394.         LIB_SYMBOL(set_latency_callback)

  395. 

  396.         LIB_SYMBOL(set_freewheel)

  397.         LIB_SYMBOL(set_buffer_size)

  398. 

  399.         LIB_SYMBOL(get_sample_rate)

  400.         LIB_SYMBOL(get_buffer_size)

  401.         LIB_SYMBOL(cpu_load)

  402. 

  403.         LIB_SYMBOL(port_register)

  404.         LIB_SYMBOL(port_unregister)

  405.         LIB_SYMBOL(port_get_buffer)

  406. 

  407.         LIB_SYMBOL(port_name)

  408.         LIB_SYMBOL(port_uuid)

  409.         LIB_SYMBOL(port_short_name)

  410.         LIB_SYMBOL(port_flags)

  411.         LIB_SYMBOL(port_type)

  412.         LIB_SYMBOL(port_is_mine)

  413.         LIB_SYMBOL(port_connected)

  414.         LIB_SYMBOL(port_connected_to)

  415.         LIB_SYMBOL(port_get_connections)

  416.         LIB_SYMBOL(port_get_all_connections)

  417. 

  418.         LIB_SYMBOL(port_set_name)

  419.         LIB_SYMBOL(port_set_alias)

  420.         LIB_SYMBOL(port_unset_alias)

  421.         LIB_SYMBOL(port_get_aliases)

  422. 

  423.         LIB_SYMBOL(port_request_monitor)

  424.         LIB_SYMBOL(port_request_monitor_by_name)

  425.         LIB_SYMBOL(port_ensure_monitor)

  426.         LIB_SYMBOL(port_monitoring_input)

  427. 

  428.         LIB_SYMBOL(connect)

  429.         LIB_SYMBOL(disconnect)

  430.         LIB_SYMBOL(port_disconnect)

  431. 

  432.         LIB_SYMBOL(port_name_size)

  433.         LIB_SYMBOL(port_type_size)

  434.         LIB_SYMBOL(port_type_get_buffer_size)

  435. 

  436.         LIB_SYMBOL(port_get_latency_range)

  437.         LIB_SYMBOL(port_set_latency_range)

  438.         LIB_SYMBOL(recompute_total_latencies)

  439. 

  440.         LIB_SYMBOL(get_ports)

  441.         LIB_SYMBOL(port_by_name)

  442.         LIB_SYMBOL(port_by_id)

  443. 

  444.         LIB_SYMBOL(free)

  445. 

  446.         LIB_SYMBOL(midi_get_event_count)

  447.         LIB_SYMBOL(midi_event_get)

  448.         LIB_SYMBOL(midi_clear_buffer)

  449.         LIB_SYMBOL(midi_event_write)

  450.         LIB_SYMBOL(midi_event_reserve)

  451. 

  452.         LIB_SYMBOL(release_timebase)

  453.         LIB_SYMBOL(set_sync_callback)

  454.         LIB_SYMBOL(set_sync_timeout)

  455.         LIB_SYMBOL(set_timebase_callback)

  456.         LIB_SYMBOL(transport_locate)

  457.         LIB_SYMBOL(transport_query)

  458.         LIB_SYMBOL(get_current_transport_frame)

  459.         LIB_SYMBOL(transport_reposition)

  460.         LIB_SYMBOL(transport_start)

  461.         LIB_SYMBOL(transport_stop)

  462. 

  463.         LIB_SYMBOL(set_property)

  464.         LIB_SYMBOL(get_property)

  465.         LIB_SYMBOL(free_description)

  466.         LIB_SYMBOL(get_properties)

  467.         LIB_SYMBOL(get_all_properties)

  468.         LIB_SYMBOL(remove_property)

  469.         LIB_SYMBOL(remove_properties)

  470.         LIB_SYMBOL(remove_all_properties)

  471.         LIB_SYMBOL(set_property_change_callback)

  472. 

  473.         #undef JOIN

  474.         #undef LIB_SYMBOL

  475.     }

  476. 

  477.     ~JackBridge()

  478.     {

  479.         if (lib != nullptr)

  480.         {

  481.             lib_close(lib);

  482.             lib = nullptr;

  483.         }

  484.     }

  485. 

  486.     CARLA_DECLARE_NON_COPY_STRUCT(JackBridge);

  487. };

  488. 

  489. static const JackBridge bridge;

  490. 

  491. #endif // ! JACKBRIDGE_DIRECT

  492. 

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

  494. 

  495. bool jackbridge_is_ok() noexcept

  496. {

  497. #if defined(JACKBRIDGE_DUMMY) || defined(JACKBRIDGE_DIRECT)

  498.     return true;

  499. #else

  500.     return (bridge.lib != nullptr);

  501. #endif

  502. }

  503. 

  504. // -----------------------------------------------------------------------------

  505. 

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

  507. {

  508. #if defined(JACKBRIDGE_DUMMY)

  509. #elif defined(JACKBRIDGE_DIRECT)

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

  511. #else

  512.     if (bridge.get_version_ptr != nullptr)

  513.         return bridge.get_version_ptr(major_ptr, minor_ptr, micro_ptr, proto_ptr);

  514. #endif

  515.     if (major_ptr != nullptr)

  516.         *major_ptr = 0;

  517.     if (minor_ptr != nullptr)

  518.         *minor_ptr = 0;

  519.     if (micro_ptr != nullptr)

  520.         *micro_ptr = 0;

  521.     if (proto_ptr != nullptr)

  522.         *proto_ptr = 0;

  523. }

  524. 

  525. const char* jackbridge_get_version_string()

  526. {

  527. #if defined(JACKBRIDGE_DUMMY)

  528. #elif defined(JACKBRIDGE_DIRECT)

  529.     return jack_get_version_string();

  530. #else

  531.     if (bridge.get_version_string_ptr != nullptr)

  532.         return bridge.get_version_string_ptr();

  533. #endif

  534.     return nullptr;

  535. }

  536. 

  537. // -----------------------------------------------------------------------------

  538. 

  539. jack_client_t* jackbridge_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...)

  540. {

  541. #if defined(JACKBRIDGE_DUMMY)

  542. #elif defined(JACKBRIDGE_DIRECT)

  543.     return jack_client_open(client_name, options, status);

  544. #else

  545.     if (bridge.client_open_ptr != nullptr)

  546.         return bridge.client_open_ptr(client_name, options, status);

  547. #endif

  548.     if (status != nullptr)

  549.         *status = JackServerError;

  550.     return nullptr;

  551. }

  552. 

  553. bool jackbridge_client_close(jack_client_t* client)

  554. {

  555. #if defined(JACKBRIDGE_DUMMY)

  556. #elif defined(JACKBRIDGE_DIRECT)

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

  558. #else

  559.     if (bridge.client_close_ptr != nullptr)

  560.         return (bridge.client_close_ptr(client) == 0);

  561. #endif

  562.     return false;

  563. }

  564. 

  565. // -----------------------------------------------------------------------------

  566. 

  567. int jackbridge_client_name_size()

  568. {

  569. #if defined(JACKBRIDGE_DUMMY)

  570. #elif defined(JACKBRIDGE_DIRECT)

  571.     return jack_client_name_size();

  572. #else

  573.     if (bridge.client_name_size_ptr != nullptr)

  574.         return bridge.client_name_size_ptr();

  575. #endif

  576.     return 0;

  577. }

  578. 

  579. char* jackbridge_get_client_name(jack_client_t* client)

  580. {

  581. #if defined(JACKBRIDGE_DUMMY)

  582. #elif defined(JACKBRIDGE_DIRECT)

  583.     return jack_get_client_name(client);

  584. #else

  585.     if (bridge.get_client_name_ptr != nullptr)

  586.         return bridge.get_client_name_ptr(client);

  587. #endif

  588.     return nullptr;

  589. }

  590. 

  591. // -----------------------------------------------------------------------------

  592. 

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

  594. {

  595. #if defined(JACKBRIDGE_DUMMY)

  596. #elif defined(JACKBRIDGE_DIRECT)

  597.     return jack_get_uuid_for_client_name(client, name);

  598. #else

  599.     if (bridge.get_uuid_for_client_name_ptr != nullptr)

  600.         return bridge.get_uuid_for_client_name_ptr(client, name);

  601. #endif

  602.     return nullptr;

  603. }

  604. 

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

  606. {

  607. #if defined(JACKBRIDGE_DUMMY)

  608. #elif defined(JACKBRIDGE_DIRECT)

  609.     return jack_get_client_name_by_uuid(client, uuid);

  610. #else

  611.     if (bridge.get_client_name_by_uuid_ptr != nullptr)

  612.         return bridge.get_client_name_by_uuid_ptr(client, uuid);

  613. #endif

  614.     return nullptr;

  615. }

  616. 

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

  618. 

  619. bool jackbridge_activate(jack_client_t* client)

  620. {

  621. #if defined(JACKBRIDGE_DUMMY)

  622. #elif defined(JACKBRIDGE_DIRECT)

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

  624. #else

  625.     if (bridge.activate_ptr != nullptr)

  626.         return (bridge.activate_ptr(client) == 0);

  627. #endif

  628.     return false;

  629. }

  630. 

  631. bool jackbridge_deactivate(jack_client_t* client)

  632. {

  633. #if defined(JACKBRIDGE_DUMMY)

  634. #elif defined(JACKBRIDGE_DIRECT)

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

  636. #else

  637.     if (bridge.deactivate_ptr != nullptr)

  638.         return (bridge.deactivate_ptr(client) == 0);

  639. #endif

  640.     return false;

  641. }

  642. 

  643. bool jackbridge_is_realtime(jack_client_t* client)

  644. {

  645. #if defined(JACKBRIDGE_DUMMY)

  646. #elif defined(JACKBRIDGE_DIRECT)

  647.     return jack_is_realtime(client);

  648. #else

  649.     if (bridge.is_realtime_ptr != nullptr)

  650.         return bridge.is_realtime_ptr(client);

  651. #endif

  652.     return false;

  653. }

  654. 

  655. // -----------------------------------------------------------------------------

  656. 

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

  658. {

  659. #if defined(JACKBRIDGE_DUMMY)

  660. #elif defined(JACKBRIDGE_DIRECT)

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

  662. #else

  663.     if (bridge.set_thread_init_callback_ptr != nullptr)

  664.         return (bridge.set_thread_init_callback_ptr(client, thread_init_callback, arg) == 0);

  665. #endif

  666.     return false;

  667. }

  668. 

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

  670. {

  671. #if defined(JACKBRIDGE_DUMMY)

  672. #elif defined(JACKBRIDGE_DIRECT)

  673.     jack_on_shutdown(client, shutdown_callback, arg);

  674. #else

  675.     if (bridge.on_shutdown_ptr != nullptr)

  676.         bridge.on_shutdown_ptr(client, shutdown_callback, arg);

  677. #endif

  678. }

  679. 

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

  681. {

  682. #if defined(JACKBRIDGE_DUMMY)

  683. #elif defined(JACKBRIDGE_DIRECT)

  684.     jack_on_info_shutdown(client, shutdown_callback, arg);

  685. #else

  686.     if (bridge.on_info_shutdown_ptr != nullptr)

  687.         bridge.on_info_shutdown_ptr(client, shutdown_callback, arg);

  688. #endif

  689. }

  690. 

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

  692. {

  693. #if defined(JACKBRIDGE_DUMMY)

  694. #elif defined(JACKBRIDGE_DIRECT)

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

  696. #else

  697.     if (bridge.set_process_callback_ptr != nullptr)

  698.         return (bridge.set_process_callback_ptr(client, process_callback, arg) == 0);

  699. #endif

  700.     return false;

  701. }

  702. 

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

  704. {

  705. #if defined(JACKBRIDGE_DUMMY)

  706. #elif defined(JACKBRIDGE_DIRECT)

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

  708. #else

  709.     if (bridge.set_freewheel_callback_ptr != nullptr)

  710.         return (bridge.set_freewheel_callback_ptr(client, freewheel_callback, arg) == 0);

  711. #endif

  712.     return false;

  713. }

  714. 

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

  716. {

  717. #if defined(JACKBRIDGE_DUMMY)

  718. #elif defined(JACKBRIDGE_DIRECT)

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

  720. #else

  721.     if (bridge.set_buffer_size_callback_ptr != nullptr)

  722.         return (bridge.set_buffer_size_callback_ptr(client, bufsize_callback, arg) == 0);

  723. #endif

  724.     return false;

  725. }

  726. 

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

  728. {

  729. #if defined(JACKBRIDGE_DUMMY)

  730. #elif defined(JACKBRIDGE_DIRECT)

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

  732. #else

  733.     if (bridge.set_sample_rate_callback_ptr != nullptr)

  734.         return (bridge.set_sample_rate_callback_ptr(client, srate_callback, arg) == 0);

  735. #endif

  736.     return false;

  737. }

  738. 

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

  740. {

  741. #if defined(JACKBRIDGE_DUMMY)

  742. #elif defined(JACKBRIDGE_DIRECT)

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

  744. #else

  745.     if (bridge.set_client_registration_callback_ptr != nullptr)

  746.         return (bridge.set_client_registration_callback_ptr(client, registration_callback, arg) == 0);

  747. #endif

  748.     return false;

  749. }

  750. 

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

  752. {

  753. #if defined(JACKBRIDGE_DUMMY)

  754. #elif defined(JACKBRIDGE_DIRECT)

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

  756. #else

  757.     if (bridge.set_port_registration_callback_ptr != nullptr)

  758.         return (bridge.set_port_registration_callback_ptr(client, registration_callback, arg) == 0);

  759. #endif

  760.     return false;

  761. }

  762. 

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

  764. {

  765. #if defined(JACKBRIDGE_DUMMY)

  766. #elif defined(JACKBRIDGE_DIRECT)

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

  768. #else

  769.     if (bridge.set_port_rename_callback_ptr != nullptr)

  770.         return (bridge.set_port_rename_callback_ptr(client, rename_callback, arg) == 0);

  771. #endif

  772.     return false;

  773. }

  774. 

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

  776. {

  777. #if defined(JACKBRIDGE_DUMMY)

  778. #elif defined(JACKBRIDGE_DIRECT)

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

  780. #else

  781.     if (bridge.set_port_connect_callback_ptr != nullptr)

  782.         return (bridge.set_port_connect_callback_ptr(client, connect_callback, arg) == 0);

  783. #endif

  784.     return false;

  785. }

  786. 

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

  788. {

  789. #if defined(JACKBRIDGE_DUMMY)

  790. #elif defined(JACKBRIDGE_DIRECT)

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

  792. #else

  793.     if (bridge.set_xrun_callback_ptr != nullptr)

  794.         return (bridge.set_xrun_callback_ptr(client, xrun_callback, arg) == 0);

  795. #endif

  796.     return false;

  797. }

  798. 

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

  800. {

  801. #if defined(JACKBRIDGE_DUMMY)

  802. #elif defined(JACKBRIDGE_DIRECT)

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

  804. #else

  805.     if (bridge.set_latency_callback_ptr != nullptr)

  806.         return (bridge.set_latency_callback_ptr(client, latency_callback, arg) == 0);

  807. #endif

  808.     return false;

  809. }

  810. 

  811. // -----------------------------------------------------------------------------

  812. 

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

  814. {

  815. #if defined(JACKBRIDGE_DUMMY)

  816. #elif defined(JACKBRIDGE_DIRECT)

  817.     return jack_set_freewheel(client, onoff);

  818. #else

  819.     if (bridge.set_freewheel_ptr != nullptr)

  820.         return bridge.set_freewheel_ptr(client, onoff);

  821. #endif

  822.     return false;

  823. }

  824. 

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

  826. {

  827. #if defined(JACKBRIDGE_DUMMY)

  828. #elif defined(JACKBRIDGE_DIRECT)

  829.     return jack_set_buffer_size(client, nframes);

  830. #else

  831.     if (bridge.set_buffer_size_ptr != nullptr)

  832.         return bridge.set_buffer_size_ptr(client, nframes);

  833. #endif

  834.     return false;

  835. }

  836. 

  837. // -----------------------------------------------------------------------------

  838. 

  839. jack_nframes_t jackbridge_get_sample_rate(jack_client_t* client)

  840. {

  841. #if defined(JACKBRIDGE_DUMMY)

  842. #elif defined(JACKBRIDGE_DIRECT)

  843.     return jack_get_sample_rate(client);

  844. #else

  845.     if (bridge.get_sample_rate_ptr != nullptr)

  846.         return bridge.get_sample_rate_ptr(client);

  847. #endif

  848.     return 0;

  849. }

  850. 

  851. jack_nframes_t jackbridge_get_buffer_size(jack_client_t* client)

  852. {

  853. #if defined(JACKBRIDGE_DUMMY)

  854. #elif defined(JACKBRIDGE_DIRECT)

  855.     return jack_get_buffer_size(client);

  856. #else

  857.     if (bridge.get_buffer_size_ptr != nullptr)

  858.         return bridge.get_buffer_size_ptr(client);

  859. #endif

  860.     return 0;

  861. }

  862. 

  863. float jackbridge_cpu_load(jack_client_t* client)

  864. {

  865. #if defined(JACKBRIDGE_DUMMY)

  866. #elif defined(JACKBRIDGE_DIRECT)

  867.     return jack_cpu_load(client);

  868. #else

  869.     if (bridge.cpu_load_ptr != nullptr)

  870.         return bridge.cpu_load_ptr(client);

  871. #endif

  872.     return 0.0f;

  873. }

  874. 

  875. // -----------------------------------------------------------------------------

  876. 

  877. jack_port_t* jackbridge_port_register(jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size)

  878. {

  879. #if defined(JACKBRIDGE_DUMMY)

  880. #elif defined(JACKBRIDGE_DIRECT)

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

  882. #else

  883.     if (bridge.port_register_ptr != nullptr)

  884.         return bridge.port_register_ptr(client, port_name, port_type, flags, buffer_size);

  885. #endif

  886.     return nullptr;

  887. }

  888. 

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

  890. {

  891. #if defined(JACKBRIDGE_DUMMY)

  892. #elif defined(JACKBRIDGE_DIRECT)

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

  894. #else

  895.     if (bridge.port_unregister_ptr != nullptr)

  896.         return (bridge.port_unregister_ptr(client, port) == 0);

  897. #endif

  898.     return false;

  899. }

  900. 

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

  902. {

  903. #if defined(JACKBRIDGE_DUMMY)

  904. #elif defined(JACKBRIDGE_DIRECT)

  905.     return jack_port_get_buffer(port, nframes);

  906. #else

  907.     if (bridge.port_get_buffer_ptr != nullptr)

  908.         return bridge.port_get_buffer_ptr(port, nframes);

  909. #endif

  910.     return nullptr;

  911. }

  912. 

  913. // -----------------------------------------------------------------------------

  914. 

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

  916. {

  917. #if defined(JACKBRIDGE_DUMMY)

  918. #elif defined(JACKBRIDGE_DIRECT)

  919.     return jack_port_name(port);

  920. #else

  921.     if (bridge.port_name_ptr != nullptr)

  922.         return bridge.port_name_ptr(port);

  923. #endif

  924.     return nullptr;

  925. }

  926. 

  927. jack_uuid_t jackbridge_port_uuid(const jack_port_t* port)

  928. {

  929. #if defined(JACKBRIDGE_DUMMY)

  930. #elif defined(JACKBRIDGE_DIRECT)

  931.     return jack_port_uuid(port);

  932. #else

  933.     if (bridge.port_uuid_ptr != nullptr)

  934.         return bridge.port_uuid_ptr(port);

  935. #endif

  936.     return 0;

  937. }

  938. 

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

  940. {

  941. #if defined(JACKBRIDGE_DUMMY)

  942. #elif defined(JACKBRIDGE_DIRECT)

  943.     return jack_port_short_name(port);

  944. #else

  945.     if (bridge.port_short_name_ptr != nullptr)

  946.         return bridge.port_short_name_ptr(port);

  947. #endif

  948.     return nullptr;

  949. }

  950. 

  951. int jackbridge_port_flags(const jack_port_t* port)

  952. {

  953. #if defined(JACKBRIDGE_DUMMY)

  954. #elif defined(JACKBRIDGE_DIRECT)

  955.     return jack_port_flags(port);

  956. #else

  957.     if (bridge.port_flags_ptr != nullptr)

  958.         return bridge.port_flags_ptr(port);

  959. #endif

  960.     return 0x0;

  961. }

  962. 

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

  964. {

  965. #if defined(JACKBRIDGE_DUMMY)

  966. #elif defined(JACKBRIDGE_DIRECT)

  967.     return jack_port_type(port);

  968. #else

  969.     if (bridge.port_type_ptr != nullptr)

  970.         return bridge.port_type_ptr(port);

  971. #endif

  972.     return nullptr;

  973. }

  974. 

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

  976. {

  977. #if defined(JACKBRIDGE_DUMMY)

  978. #elif defined(JACKBRIDGE_DIRECT)

  979.     return jack_port_is_mine(client, port);

  980. #else

  981.     if (bridge.port_is_mine_ptr != nullptr)

  982.         return bridge.port_is_mine_ptr(client, port);

  983. #endif

  984.     return false;

  985. }

  986. 

  987. int jackbridge_port_connected(const jack_port_t* port)

  988. {

  989. #if defined(JACKBRIDGE_DUMMY)

  990. #elif defined(JACKBRIDGE_DIRECT)

  991.     return jack_port_connected(port);

  992. #else

  993.     if (bridge.port_connected_ptr != nullptr)

  994.         return bridge.port_connected_ptr(port);

  995. #endif

  996.     return 0;

  997. }

  998. 

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

  1000. {

  1001. #if defined(JACKBRIDGE_DUMMY)

  1002. #elif defined(JACKBRIDGE_DIRECT)

  1003.     return jack_port_connected_to(port, port_name);

  1004. #else

  1005.     if (bridge.port_connected_to_ptr != nullptr)

  1006.         return bridge.port_connected_to_ptr(port, port_name);

  1007. #endif

  1008.     return false;

  1009. }

  1010. 

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

  1012. {

  1013. #if defined(JACKBRIDGE_DUMMY)

  1014. #elif defined(JACKBRIDGE_DIRECT)

  1015.     return jack_port_get_connections(port);

  1016. #else

  1017.     if (bridge.port_get_connections_ptr != nullptr)

  1018.         return bridge.port_get_connections_ptr(port);

  1019. #endif

  1020.     return nullptr;

  1021. }

  1022. 

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

  1024. {

  1025. #if defined(JACKBRIDGE_DUMMY)

  1026. #elif defined(JACKBRIDGE_DIRECT)

  1027.     return jack_port_get_all_connections(client, port);

  1028. #else

  1029.     if (bridge.port_get_all_connections_ptr != nullptr)

  1030.         return bridge.port_get_all_connections_ptr(client, port);

  1031. #endif

  1032.     return nullptr;

  1033. }

  1034. 

  1035. // -----------------------------------------------------------------------------

  1036. 

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

  1038. {

  1039. #if defined(JACKBRIDGE_DUMMY)

  1040. #elif defined(JACKBRIDGE_DIRECT)

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

  1042. #else

  1043.     if (bridge.port_set_name_ptr != nullptr)

  1044.         return (bridge.port_set_name_ptr(port, port_name) == 0);

  1045. #endif

  1046.     return false;

  1047. }

  1048. 

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

  1050. {

  1051. #if defined(JACKBRIDGE_DUMMY)

  1052. #elif defined(JACKBRIDGE_DIRECT)

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

  1054. #else

  1055.     if (bridge.port_set_alias_ptr != nullptr)

  1056.         return (bridge.port_set_alias_ptr(port, alias) == 0);

  1057. #endif

  1058.     return false;

  1059. }

  1060. 

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

  1062. {

  1063. #if defined(JACKBRIDGE_DUMMY)

  1064. #elif defined(JACKBRIDGE_DIRECT)

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

  1066. #else

  1067.     if (bridge.port_unset_alias_ptr != nullptr)

  1068.         return (bridge.port_unset_alias_ptr(port, alias) == 0);

  1069. #endif

  1070.     return false;

  1071. }

  1072. 

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

  1074. {

  1075. #if defined(JACKBRIDGE_DUMMY)

  1076. #elif defined(JACKBRIDGE_DIRECT)

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

  1078. #else

  1079.     if (bridge.port_get_aliases_ptr != nullptr)

  1080.         return bridge.port_get_aliases_ptr(port, aliases);

  1081. #endif

  1082.     return 0;

  1083. }

  1084. 

  1085. // -----------------------------------------------------------------------------

  1086. 

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

  1088. {

  1089. #if defined(JACKBRIDGE_DUMMY)

  1090. #elif defined(JACKBRIDGE_DIRECT)

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

  1092. #else

  1093.     if (bridge.port_request_monitor_ptr != nullptr)

  1094.         return (bridge.port_request_monitor_ptr(port, onoff) == 0);

  1095. #endif

  1096.     return false;

  1097. }

  1098. 

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

  1100. {

  1101. #if defined(JACKBRIDGE_DUMMY)

  1102. #elif defined(JACKBRIDGE_DIRECT)

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

  1104. #else

  1105.     if (bridge.port_request_monitor_by_name_ptr != nullptr)

  1106.         return (bridge.port_request_monitor_by_name_ptr(client, port_name, onoff) == 0);

  1107. #endif

  1108.     return false;

  1109. }

  1110. 

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

  1112. {

  1113. #if defined(JACKBRIDGE_DUMMY)

  1114. #elif defined(JACKBRIDGE_DIRECT)

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

  1116. #else

  1117.     if (bridge.port_ensure_monitor_ptr != nullptr)

  1118.         return (bridge.port_ensure_monitor_ptr(port, onoff) == 0);

  1119. #endif

  1120.     return false;

  1121. }

  1122. 

  1123. bool jackbridge_port_monitoring_input(jack_port_t* port)

  1124. {

  1125. #if defined(JACKBRIDGE_DUMMY)

  1126. #elif defined(JACKBRIDGE_DIRECT)

  1127.     return jack_port_monitoring_input(port);

  1128. #else

  1129.     if (bridge.port_monitoring_input_ptr != nullptr)

  1130.         return bridge.port_monitoring_input_ptr(port);

  1131. #endif

  1132.     return false;

  1133. }

  1134. 

  1135. // -----------------------------------------------------------------------------

  1136. 

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

  1138. {

  1139. #if defined(JACKBRIDGE_DUMMY)

  1140. #elif defined(JACKBRIDGE_DIRECT)

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

  1142. #else

  1143.     if (bridge.connect_ptr != nullptr)

  1144.         return (bridge.connect_ptr(client, source_port, destination_port) == 0);

  1145. #endif

  1146.     return false;

  1147. }

  1148. 

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

  1150. {

  1151. #if defined(JACKBRIDGE_DUMMY)

  1152. #elif defined(JACKBRIDGE_DIRECT)

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

  1154. #else

  1155.     if (bridge.disconnect_ptr != nullptr)

  1156.         return (bridge.disconnect_ptr(client, source_port, destination_port) == 0);

  1157. #endif

  1158.     return false;

  1159. }

  1160. 

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

  1162. {

  1163. #if defined(JACKBRIDGE_DUMMY)

  1164. #elif defined(JACKBRIDGE_DIRECT)

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

  1166. #else

  1167.     if (bridge.port_disconnect_ptr != nullptr)

  1168.         return (bridge.port_disconnect_ptr(client, port) == 0);

  1169. #endif

  1170.     return false;

  1171. }

  1172. 

  1173. // -----------------------------------------------------------------------------

  1174. 

  1175. int jackbridge_port_name_size()

  1176. {

  1177. #if defined(JACKBRIDGE_DUMMY)

  1178. #elif defined(JACKBRIDGE_DIRECT)

  1179.     return jack_port_name_size();

  1180. #else

  1181.     if (bridge.port_name_size_ptr != nullptr)

  1182.         return bridge.port_name_size_ptr();

  1183. #endif

  1184.     return 0;

  1185. }

  1186. 

  1187. int jackbridge_port_type_size()

  1188. {

  1189. #if defined(JACKBRIDGE_DUMMY)

  1190. #elif defined(JACKBRIDGE_DIRECT)

  1191.     return jack_port_type_size();

  1192. #else

  1193.     if (bridge.port_type_size_ptr != nullptr)

  1194.         return bridge.port_type_size_ptr();

  1195. #endif

  1196.     return 0;

  1197. }

  1198. 

  1199. size_t jackbridge_port_type_get_buffer_size(jack_client_t* client, const char* port_type)

  1200. {

  1201. #if defined(JACKBRIDGE_DUMMY)

  1202. #elif defined(JACKBRIDGE_DIRECT)

  1203.     return jack_port_type_get_buffer_size(client, port_type);

  1204. #else

  1205.     if (bridge.port_type_get_buffer_size_ptr != nullptr)

  1206.         return bridge.port_type_get_buffer_size_ptr(client, port_type);

  1207. #endif

  1208.     return 0;

  1209. }

  1210. 

  1211. // -----------------------------------------------------------------------------

  1212. 

  1213. void jackbridge_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range)

  1214. {

  1215. #if defined(JACKBRIDGE_DUMMY)

  1216. #elif defined(JACKBRIDGE_DIRECT)

  1217.     return jack_port_get_latency_range(port, mode, range);

  1218. #else

  1219.     if (bridge.port_get_latency_range_ptr != nullptr)

  1220.         return bridge.port_get_latency_range_ptr(port, mode, range);

  1221. #endif

  1222.     range->min = 0;

  1223.     range->max = 0;

  1224. }

  1225. 

  1226. void jackbridge_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range)

  1227. {

  1228. #if defined(JACKBRIDGE_DUMMY)

  1229. #elif defined(JACKBRIDGE_DIRECT)

  1230.     jack_port_set_latency_range(port, mode, range);

  1231. #else

  1232.     if (bridge.port_set_latency_range_ptr != nullptr)

  1233.         bridge.port_set_latency_range_ptr(port, mode, range);

  1234. #endif

  1235. }

  1236. 

  1237. bool jackbridge_recompute_total_latencies(jack_client_t* client)

  1238. {

  1239. #if defined(JACKBRIDGE_DUMMY)

  1240. #elif defined(JACKBRIDGE_DIRECT)

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

  1242. #else

  1243.     if (bridge.recompute_total_latencies_ptr != nullptr)

  1244.         return (bridge.recompute_total_latencies_ptr(client) == 0);

  1245. #endif

  1246.     return false;

  1247. }

  1248. 

  1249. // -----------------------------------------------------------------------------

  1250. 

  1251. const char** jackbridge_get_ports(jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags)

  1252. {

  1253. #if defined(JACKBRIDGE_DUMMY)

  1254. #elif defined(JACKBRIDGE_DIRECT)

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

  1256. #else

  1257.     if (bridge.get_ports_ptr != nullptr)

  1258.         return bridge.get_ports_ptr(client, port_name_pattern, type_name_pattern, flags);

  1259. #endif

  1260.     return nullptr;

  1261. }

  1262. 

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

  1264. {

  1265. #if defined(JACKBRIDGE_DUMMY)

  1266. #elif defined(JACKBRIDGE_DIRECT)

  1267.     return jack_port_by_name(client, port_name);

  1268. #else

  1269.     if (bridge.port_by_name_ptr != nullptr)

  1270.         return bridge.port_by_name_ptr(client, port_name);

  1271. #endif

  1272.     return nullptr;

  1273. }

  1274. 

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

  1276. {

  1277. #if defined(JACKBRIDGE_DUMMY)

  1278. #elif defined(JACKBRIDGE_DIRECT)

  1279.     return jack_port_by_id(client, port_id);

  1280. #else

  1281.     if (bridge.port_by_id_ptr != nullptr)

  1282.         return bridge.port_by_id_ptr(client, port_id);

  1283. #endif

  1284.     return nullptr;

  1285. }

  1286. 

  1287. // -----------------------------------------------------------------------------

  1288. 

  1289. void jackbridge_free(void* ptr)

  1290. {

  1291. #if defined(JACKBRIDGE_DUMMY)

  1292. #elif defined(JACKBRIDGE_DIRECT)

  1293.     return jack_free(ptr);

  1294. #else

  1295.     if (bridge.free_ptr != nullptr)

  1296.         return bridge.free_ptr(ptr);

  1297. 

  1298.     // just in case

  1299.     std::free(ptr);

  1300. #endif

  1301. }

  1302. 

  1303. // -----------------------------------------------------------------------------

  1304. 

  1305. uint32_t jackbridge_midi_get_event_count(void* port_buffer)

  1306. {

  1307. #if defined(JACKBRIDGE_DUMMY)

  1308. #elif defined(JACKBRIDGE_DIRECT)

  1309.     return jack_midi_get_event_count(port_buffer);

  1310. #else

  1311.     if (bridge.midi_get_event_count_ptr != nullptr)

  1312.         return bridge.midi_get_event_count_ptr(port_buffer);

  1313. #endif

  1314.     return 0;

  1315. }

  1316. 

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

  1318. {

  1319. #if defined(JACKBRIDGE_DUMMY)

  1320. #elif defined(JACKBRIDGE_DIRECT)

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

  1322. #else

  1323.     if (bridge.midi_event_get_ptr != nullptr)

  1324.         return (bridge.midi_event_get_ptr(event, port_buffer, event_index) == 0);

  1325. #endif

  1326.     return false;

  1327. }

  1328. 

  1329. void jackbridge_midi_clear_buffer(void* port_buffer)

  1330. {

  1331. #if defined(JACKBRIDGE_DUMMY)

  1332. #elif defined(JACKBRIDGE_DIRECT)

  1333.     jack_midi_clear_buffer(port_buffer);

  1334. #else

  1335.     if (bridge.midi_clear_buffer_ptr != nullptr)

  1336.         bridge.midi_clear_buffer_ptr(port_buffer);

  1337. #endif

  1338. }

  1339. 

  1340. bool jackbridge_midi_event_write(void* port_buffer, jack_nframes_t time, const jack_midi_data_t* data, size_t data_size)

  1341. {

  1342. #if defined(JACKBRIDGE_DUMMY)

  1343. #elif defined(JACKBRIDGE_DIRECT)

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

  1345. #else

  1346.     if (bridge.midi_event_write_ptr != nullptr)

  1347.         return (bridge.midi_event_write_ptr(port_buffer, time, data, data_size) == 0);

  1348. #endif

  1349.     return false;

  1350. }

  1351. 

  1352. jack_midi_data_t* jackbridge_midi_event_reserve(void* port_buffer, jack_nframes_t time, size_t data_size)

  1353. {

  1354. #if defined(JACKBRIDGE_DUMMY)

  1355. #elif defined(JACKBRIDGE_DIRECT)

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

  1357. #else

  1358.     if (bridge.midi_event_reserve_ptr != nullptr)

  1359.         return bridge.midi_event_reserve_ptr(port_buffer, time, data_size);

  1360. #endif

  1361.     return nullptr;

  1362. }

  1363. 

  1364. // -----------------------------------------------------------------------------

  1365. 

  1366. bool jackbridge_release_timebase(jack_client_t* client)

  1367. {

  1368. #if defined(JACKBRIDGE_DUMMY)

  1369. #elif defined(JACKBRIDGE_DIRECT)

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

  1371. #else

  1372.     if (bridge.release_timebase_ptr != nullptr)

  1373.         return (bridge.release_timebase_ptr(client) == 0);

  1374. #endif

  1375.     return false;

  1376. }

  1377. 

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

  1379. {

  1380. #if defined(JACKBRIDGE_DUMMY)

  1381. #elif defined(JACKBRIDGE_DIRECT)

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

  1383. #else

  1384.     if (bridge.set_sync_callback_ptr != nullptr)

  1385.         return (bridge.set_sync_callback_ptr(client, sync_callback, arg) == 0);

  1386. #endif

  1387.     return false;

  1388. }

  1389. 

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

  1391. {

  1392. #if defined(JACKBRIDGE_DUMMY)

  1393. #elif defined(JACKBRIDGE_DIRECT)

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

  1395. #else

  1396.     if (bridge.set_sync_timeout_ptr != nullptr)

  1397.         return (bridge.set_sync_timeout_ptr(client, timeout) == 0);

  1398. #endif

  1399.     return false;

  1400. }

  1401. 

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

  1403. {

  1404. #if defined(JACKBRIDGE_DUMMY)

  1405. #elif defined(JACKBRIDGE_DIRECT)

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

  1407. #else

  1408.     if (bridge.set_timebase_callback_ptr != nullptr)

  1409.         return (bridge.set_timebase_callback_ptr(client, conditional, timebase_callback, arg) == 0);

  1410. #endif

  1411.     return false;

  1412. }

  1413. 

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

  1415. {

  1416. #if defined(JACKBRIDGE_DUMMY)

  1417. #elif defined(JACKBRIDGE_DIRECT)

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

  1419. #else

  1420.     if (bridge.transport_locate_ptr != nullptr)

  1421.         return (bridge.transport_locate_ptr(client, frame) == 0);

  1422. #endif

  1423.     return false;

  1424. }

  1425. 

  1426. jack_transport_state_t jackbridge_transport_query(const jack_client_t* client, jack_position_t* pos)

  1427. {

  1428. #if defined(JACKBRIDGE_DUMMY)

  1429. #elif defined(JACKBRIDGE_DIRECT)

  1430.     return jack_transport_query(client, pos);

  1431. #else

  1432.     if (bridge.transport_query_ptr != nullptr)

  1433.         return bridge.transport_query_ptr(client, pos);

  1434. #endif

  1435.     if (pos != nullptr)

  1436.     {

  1437.         // invalidate

  1438.         pos->unique_1 = 0;

  1439.         pos->unique_2 = 1;

  1440.     }

  1441.     return JackTransportStopped;

  1442. }

  1443. 

  1444. jack_nframes_t jackbridge_get_current_transport_frame(const jack_client_t* client)

  1445. {

  1446. #if defined(JACKBRIDGE_DUMMY)

  1447. #elif defined(JACKBRIDGE_DIRECT)

  1448.     return jack_get_current_transport_frame(client);

  1449. #else

  1450.     if (bridge.get_current_transport_frame_ptr != nullptr)

  1451.         return bridge.get_current_transport_frame_ptr(client);

  1452. #endif

  1453.     return 0;

  1454. }

  1455. 

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

  1457. {

  1458. #if defined(JACKBRIDGE_DUMMY)

  1459. #elif defined(JACKBRIDGE_DIRECT)

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

  1461. #else

  1462.     if (bridge.transport_reposition_ptr != nullptr)

  1463.         return (bridge.transport_reposition_ptr(client, pos) == 0);

  1464. #endif

  1465.     return false;

  1466. }

  1467. 

  1468. void jackbridge_transport_start(jack_client_t* client)

  1469. {

  1470. #if defined(JACKBRIDGE_DUMMY)

  1471. #elif defined(JACKBRIDGE_DIRECT)

  1472.     jack_transport_start(client);

  1473. #else

  1474.     if (bridge.transport_start_ptr != nullptr)

  1475.         bridge.transport_start_ptr(client);

  1476. #endif

  1477. }

  1478. 

  1479. void jackbridge_transport_stop(jack_client_t* client)

  1480. {

  1481. #if defined(JACKBRIDGE_DUMMY)

  1482. #elif defined(JACKBRIDGE_DIRECT)

  1483.     jack_transport_stop(client);

  1484. #else

  1485.     if (bridge.transport_stop_ptr != nullptr)

  1486.         bridge.transport_stop_ptr(client);

  1487. #endif

  1488. }

  1489. 

  1490. // -----------------------------------------------------------------------------

  1491. 

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

  1493. {

  1494. #if defined(JACKBRIDGE_DUMMY)

  1495. #elif defined(JACKBRIDGE_DIRECT)

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

  1497. #else

  1498.     if (bridge.set_property_ptr != nullptr)

  1499.         return (bridge.set_property_ptr(client, subject, key, value, type) == 0);

  1500. #endif

  1501.     return false;

  1502. }

  1503. 

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

  1505. {

  1506. #if defined(JACKBRIDGE_DUMMY)

  1507. #elif defined(JACKBRIDGE_DIRECT)

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

  1509. #else

  1510.     if (bridge.get_property_ptr != nullptr)

  1511.         return (bridge.get_property_ptr(subject, key, value, type) == 0);

  1512. #endif

  1513.     return false;

  1514. }

  1515. 

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

  1517. {

  1518. #if defined(JACKBRIDGE_DUMMY)

  1519. #elif defined(JACKBRIDGE_DIRECT)

  1520.     jack_free_description(desc, free_description_itself);

  1521. #else

  1522.     if (bridge.free_description_ptr != nullptr)

  1523.         bridge.free_description_ptr(desc, free_description_itself);

  1524. #endif

  1525. }

  1526. 

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

  1528. {

  1529. #if defined(JACKBRIDGE_DUMMY)

  1530. #elif defined(JACKBRIDGE_DIRECT)

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

  1532. #else

  1533.     if (bridge.get_properties_ptr != nullptr)

  1534.         return (bridge.get_properties_ptr(subject, desc) == 0);

  1535. #endif

  1536.     return false;

  1537. }

  1538. 

  1539. bool jackbridge_get_all_properties(jack_description_t** descs)

  1540. {

  1541. #if defined(JACKBRIDGE_DUMMY)

  1542. #elif defined(JACKBRIDGE_DIRECT)

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

  1544. #else

  1545.     if (bridge.get_all_properties_ptr != nullptr)

  1546.         return (bridge.get_all_properties_ptr(descs) == 0);

  1547. #endif

  1548.     return false;

  1549. }

  1550. 

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

  1552. {

  1553. #if defined(JACKBRIDGE_DUMMY)

  1554. #elif defined(JACKBRIDGE_DIRECT)

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

  1556. #else

  1557.     if (bridge.remove_property_ptr != nullptr)

  1558.         return (bridge.remove_property_ptr(client, subject, key) == 0);

  1559. #endif

  1560.     return false;

  1561. }

  1562. 

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

  1564. {

  1565. #if defined(JACKBRIDGE_DUMMY)

  1566. #elif defined(JACKBRIDGE_DIRECT)

  1567.     return jack_remove_properties(client, subject);

  1568. #else

  1569.     if (bridge.remove_properties_ptr != nullptr)

  1570.         return bridge.remove_properties_ptr(client, subject);

  1571. #endif

  1572.     return 0;

  1573. }

  1574. 

  1575. bool jackbridge_remove_all_properties(jack_client_t* client)

  1576. {

  1577. #if defined(JACKBRIDGE_DUMMY)

  1578. #elif defined(JACKBRIDGE_DIRECT)

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

  1580. #else

  1581.     if (bridge.remove_all_properties_ptr != nullptr)

  1582.         return (bridge.remove_all_properties_ptr(client) == 0);

  1583. #endif

  1584.     return false;

  1585. }

  1586. 

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

  1588. {

  1589. #if defined(JACKBRIDGE_DUMMY)

  1590. #elif defined(JACKBRIDGE_DIRECT)

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

  1592. #else

  1593.     if (bridge.set_property_change_callback_ptr != nullptr)

  1594.         return (bridge.set_property_change_callback_ptr(client, callback, arg) == 0);

  1595. #endif

  1596.     return false;

  1597. }

  1598. 

  1599. // -----------------------------------------------------------------------------